kml_src/000755 000765 000024 00000000000 11676172345 013154 5ustar00pawelmstaff000000 000000 kml_src/AUTHORS000644 000765 000024 00000000060 10310251476 014203 0ustar00pawelmstaff000000 000000 Rutger W. ter Borg <> Meredith L. Patterson <> kml_src/boost/000755 000765 000024 00000000000 11676172345 014302 5ustar00pawelmstaff000000 000000 kml_src/COPYING000644 000765 000024 00000063500 10377266331 014207 0ustar00pawelmstaff000000 000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. 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 combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) 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 materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. 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 with 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 Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library 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 Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, 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! kml_src/cpuinfo.py000644 000765 000024 00000056561 10271717025 015174 0ustar00pawelmstaff000000 000000 #!/usr/bin/env python """ cpuinfo Copyright 2002 Pearu Peterson all rights reserved, Pearu Peterson Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: a. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. b. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. c. Neither the name of the Enthought nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. $Revision: 1.6 $ $Date: 2004/10/04 09:30:54 $ Pearu Peterson """ __version__ = "$Id: cpuinfo.py,v 1.6 2004/10/04 09:30:54 pearu Exp $" __all__ = ['cpu'] import sys,string,re,types class cpuinfo_base: """Holds CPU information and provides methods for requiring the availability of various CPU features. """ def _try_call(self,func): try: return func() except: pass def __getattr__(self,name): if name[0]!='_': if hasattr(self,'_'+name): attr = getattr(self,'_'+name) if type(attr) is types.MethodType: return lambda func=self._try_call,attr=attr : func(attr) else: return lambda : None raise AttributeError,name def _getNCPUs(self): return 1 def _is_32bit(self): return not self.is_64bit() class linux_cpuinfo(cpuinfo_base): info = None def __init__(self): if self.info is not None: return info = [] try: for line in open('/proc/cpuinfo').readlines(): name_value = map(string.strip,string.split(line,':',1)) if len(name_value)!=2: continue name,value = name_value if not info or info[-1].has_key(name): # next processor info.append({}) info[-1][name] = value import commands status,output = commands.getstatusoutput('uname -m') if not status: if not info: info.append({}) info[-1]['uname_m'] = string.strip(output) except: print sys.exc_value,'(ignoring)' self.__class__.info = info def _not_impl(self): pass # Athlon def _is_AMD(self): return self.info[0]['vendor_id']=='AuthenticAMD' def _is_AthlonK6_2(self): return self._is_AMD() and self.info[0]['model'] == '2' def _is_AthlonK6_3(self): return self._is_AMD() and self.info[0]['model'] == '3' def _is_AthlonK6(self): return re.match(r'.*?AMD-K6',self.info[0]['model name']) is not None def _is_AthlonK7(self): return re.match(r'.*?AMD-K7',self.info[0]['model name']) is not None def _is_AthlonMP(self): return re.match(r'.*?Athlon\(tm\) MP\b', self.info[0]['model name']) is not None def _is_Athlon64(self): return re.match(r'.*?Athlon\(tm\) 64\b', self.info[0]['model name']) is not None def _is_AthlonHX(self): return re.match(r'.*?Athlon HX\b', self.info[0]['model name']) is not None def _is_Opteron(self): return re.match(r'.*?Opteron\b', self.info[0]['model name']) is not None def _is_Hammer(self): return re.match(r'.*?Hammer\b', self.info[0]['model name']) is not None # Alpha def _is_Alpha(self): return self.info[0]['cpu']=='Alpha' def _is_EV4(self): return self.is_Alpha() and self.info[0]['cpu model'] == 'EV4' def _is_EV5(self): return self.is_Alpha() and self.info[0]['cpu model'] == 'EV5' def _is_EV56(self): return self.is_Alpha() and self.info[0]['cpu model'] == 'EV56' def _is_PCA56(self): return self.is_Alpha() and self.info[0]['cpu model'] == 'PCA56' # Intel #XXX _is_i386 = _not_impl def _is_Intel(self): return self.info[0]['vendor_id']=='GenuineIntel' def _is_i486(self): return self.info[0]['cpu']=='i486' def _is_i586(self): return self.is_Intel() and self.info[0]['cpu family'] == '5' def _is_i686(self): return self.is_Intel() and self.info[0]['cpu family'] == '6' def _is_Celeron(self): return re.match(r'.*?Celeron', self.info[0]['model name']) is not None def _is_Pentium(self): return re.match(r'.*?Pentium', self.info[0]['model name']) is not None def _is_PentiumII(self): return re.match(r'.*?Pentium.*?II\b', self.info[0]['model name']) is not None def _is_PentiumPro(self): return re.match(r'.*?PentiumPro\b', self.info[0]['model name']) is not None def _is_PentiumMMX(self): return re.match(r'.*?Pentium.*?MMX\b', self.info[0]['model name']) is not None def _is_PentiumIII(self): return re.match(r'.*?Pentium.*?III\b', self.info[0]['model name']) is not None def _is_PentiumIV(self): return re.match(r'.*?Pentium.*?(IV|4)\b', self.info[0]['model name']) is not None def _is_Itanium(self): return re.match(r'.*?Itanium\b', self.info[0]['model name']) is not None def _is_XEON(self): return re.match(r'.*?XEON\b', self.info[0]['model name']) is not None # Varia def _is_singleCPU(self): return len(self.info) == 1 def _getNCPUs(self): return len(self.info) def _has_fdiv_bug(self): return self.info[0]['fdiv_bug']=='yes' def _has_f00f_bug(self): return self.info[0]['f00f_bug']=='yes' def _has_mmx(self): return re.match(r'.*?\bmmx\b',self.info[0]['flags']) is not None def _has_sse(self): return re.match(r'.*?\bsse\b',self.info[0]['flags']) is not None def _has_sse2(self): return re.match(r'.*?\bsse2\b',self.info[0]['flags']) is not None def _has_sse3(self): return re.match(r'.*?\bsse3\b',self.info[0]['flags']) is not None def _has_3dnow(self): return re.match(r'.*?\b3dnow\b',self.info[0]['flags']) is not None def _has_3dnowext(self): return re.match(r'.*?\b3dnowext\b',self.info[0]['flags']) is not None def _is_64bit(self): if self.is_Alpha(): return 1 if self.info[0].get('clflush size','')=='64': return 1 if self.info[0]['uname_m']=='x86_64': return 1 return 0 class irix_cpuinfo(cpuinfo_base): info = None def __init__(self): if self.info is not None: return info = [] try: import commands status,output = commands.getstatusoutput('sysconf') if status not in [0,256]: return for line in output.split('\n'): name_value = map(string.strip,string.split(line,' ',1)) if len(name_value)!=2: continue name,value = name_value if not info: info.append({}) info[-1][name] = value except: print sys.exc_value,'(ignoring)' self.__class__.info = info #print info def _not_impl(self): pass def _is_singleCPU(self): return self.info[0].get('NUM_PROCESSORS') == '1' def _getNCPUs(self): return int(self.info[0].get('NUM_PROCESSORS')) def __cputype(self,n): return self.info[0].get('PROCESSORS').split()[0].lower() == 'r%s' % (n) def _is_r2000(self): return self.__cputype(2000) def _is_r3000(self): return self.__cputype(3000) def _is_r3900(self): return self.__cputype(3900) def _is_r4000(self): return self.__cputype(4000) def _is_r4100(self): return self.__cputype(4100) def _is_r4300(self): return self.__cputype(4300) def _is_r4400(self): return self.__cputype(4400) def _is_r4600(self): return self.__cputype(4600) def _is_r4650(self): return self.__cputype(4650) def _is_r5000(self): return self.__cputype(5000) def _is_r6000(self): return self.__cputype(6000) def _is_r8000(self): return self.__cputype(8000) def _is_r10000(self): return self.__cputype(10000) def _is_r12000(self): return self.__cputype(12000) def _is_rorion(self): return self.__cputype('orion') def get_ip(self): try: return self.info[0].get('MACHINE') except: pass def __machine(self,n): return self.info[0].get('MACHINE').lower() == 'ip%s' % (n) def _is_IP19(self): return self.__machine(19) def _is_IP20(self): return self.__machine(20) def _is_IP21(self): return self.__machine(21) def _is_IP22(self): return self.__machine(22) def _is_IP22_4k(self): return self.__machine(22) and self._is_r4000() def _is_IP22_5k(self): return self.__machine(22) and self._is_r5000() def _is_IP24(self): return self.__machine(24) def _is_IP25(self): return self.__machine(25) def _is_IP26(self): return self.__machine(26) def _is_IP27(self): return self.__machine(27) def _is_IP28(self): return self.__machine(28) def _is_IP30(self): return self.__machine(30) def _is_IP32(self): return self.__machine(32) def _is_IP32_5k(self): return self.__machine(32) and self._is_r5000() def _is_IP32_10k(self): return self.__machine(32) and self._is_r10000() class darwin_cpuinfo(cpuinfo_base): info = None def __init__(self): if self.info is not None: return info = [] try: import commands status,output = commands.getstatusoutput('arch') if not status: if not info: info.append({}) info[-1]['arch'] = string.strip(output) status,output = commands.getstatusoutput('machine') if not status: if not info: info.append({}) info[-1]['machine'] = string.strip(output) status,output = commands.getstatusoutput('sysctl hw') if not status: if not info: info.append({}) d = {} for l in string.split(output,'\n'): l = map(string.strip,string.split(l, '=')) if len(l)==2: d[l[0]]=l[1] info[-1]['sysctl_hw'] = d except: print sys.exc_value,'(ignoring)' self.__class__.info = info def _not_impl(self): pass def _getNCPUs(self): try: return int(self.info[0]['sysctl_hw']['hw.ncpu']) except: return 1 def _is_Power_Macintosh(self): return self.info[0]['sysctl_hw']['hw.machine']=='Power Macintosh' def _is_i386(self): return self.info[0]['arch']=='i386' def _is_ppc(self): return self.info[0]['arch']=='ppc' def __machine(self,n): return self.info[0]['machine'] == 'ppc%s'%n def _is_ppc601(self): return self.__machine(601) def _is_ppc602(self): return self.__machine(602) def _is_ppc603(self): return self.__machine(603) def _is_ppc603e(self): return self.__machine('603e') def _is_ppc604(self): return self.__machine(604) def _is_ppc604e(self): return self.__machine('604e') def _is_ppc620(self): return self.__machine(620) def _is_ppc630(self): return self.__machine(630) def _is_ppc740(self): return self.__machine(740) def _is_ppc7400(self): return self.__machine(7400) def _is_ppc7450(self): return self.__machine(7450) def _is_ppc750(self): return self.__machine(750) def _is_ppc403(self): return self.__machine(403) def _is_ppc505(self): return self.__machine(505) def _is_ppc801(self): return self.__machine(801) def _is_ppc821(self): return self.__machine(821) def _is_ppc823(self): return self.__machine(823) def _is_ppc860(self): return self.__machine(860) class sunos_cpuinfo(cpuinfo_base): info = None def __init__(self): if self.info is not None: return info = [] try: import commands status,output = commands.getstatusoutput('arch') if not status: if not info: info.append({}) info[-1]['arch'] = string.strip(output) status,output = commands.getstatusoutput('mach') if not status: if not info: info.append({}) info[-1]['mach'] = string.strip(output) status,output = commands.getstatusoutput('uname -i') if not status: if not info: info.append({}) info[-1]['uname_i'] = string.strip(output) status,output = commands.getstatusoutput('uname -X') if not status: if not info: info.append({}) d = {} for l in string.split(output,'\n'): l = map(string.strip,string.split(l, '=')) if len(l)==2: d[l[0]]=l[1] info[-1]['uname_X'] = d status,output = commands.getstatusoutput('isainfo -b') if not status: if not info: info.append({}) info[-1]['isainfo_b'] = string.strip(output) status,output = commands.getstatusoutput('isainfo -n') if not status: if not info: info.append({}) info[-1]['isainfo_n'] = string.strip(output) status,output = commands.getstatusoutput('psrinfo -v 0') if not status: if not info: info.append({}) for l in string.split(output,'\n'): m = re.match(r'\s*The (?P

[\w\d]+) processor operates at',l) if m: info[-1]['processor'] = m.group('p') break except: print sys.exc_value,'(ignoring)' self.__class__.info = info def _not_impl(self): pass def _is_32bit(self): return self.info[0]['isainfo_b']=='32' def _is_64bit(self): return self.info[0]['isainfo_b']=='64' def _is_i386(self): return self.info[0]['isainfo_n']=='i386' def _is_sparc(self): return self.info[0]['isainfo_n']=='sparc' def _is_sparcv9(self): return self.info[0]['isainfo_n']=='sparcv9' def _getNCPUs(self): try: return int(self.info[0]['uname_X']['NumCPU']) except: return 1 def _is_sun4(self): return self.info[0]['arch']=='sun4' def _is_SUNW(self): return re.match(r'SUNW',self.info[0]['uname_i']) is not None def _is_sparcstation5(self): return re.match(r'.*SPARCstation-5',self.info[0]['uname_i']) is not None def _is_ultra1(self): return re.match(r'.*Ultra-1',self.info[0]['uname_i']) is not None def _is_ultra250(self): return re.match(r'.*Ultra-250',self.info[0]['uname_i']) is not None def _is_ultra2(self): return re.match(r'.*Ultra-2',self.info[0]['uname_i']) is not None def _is_ultra30(self): return re.match(r'.*Ultra-30',self.info[0]['uname_i']) is not None def _is_ultra4(self): return re.match(r'.*Ultra-4',self.info[0]['uname_i']) is not None def _is_ultra5_10(self): return re.match(r'.*Ultra-5_10',self.info[0]['uname_i']) is not None def _is_ultra5(self): return re.match(r'.*Ultra-5',self.info[0]['uname_i']) is not None def _is_ultra60(self): return re.match(r'.*Ultra-60',self.info[0]['uname_i']) is not None def _is_ultra80(self): return re.match(r'.*Ultra-80',self.info[0]['uname_i']) is not None def _is_ultraenterprice(self): return re.match(r'.*Ultra-Enterprise',self.info[0]['uname_i']) is not None def _is_ultraenterprice10k(self): return re.match(r'.*Ultra-Enterprise-10000',self.info[0]['uname_i']) is not None def _is_sunfire(self): return re.match(r'.*Sun-Fire',self.info[0]['uname_i']) is not None def _is_ultra(self): return re.match(r'.*Ultra',self.info[0]['uname_i']) is not None def _is_cpusparcv7(self): return self.info[0]['processor']=='sparcv7' def _is_cpusparcv8(self): return self.info[0]['processor']=='sparcv8' def _is_cpusparcv9(self): return self.info[0]['processor']=='sparcv9' class win32_cpuinfo(cpuinfo_base): info = None pkey = "HARDWARE\\DESCRIPTION\\System\\CentralProcessor" # XXX: what does the value of # HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0 # mean? def __init__(self): if self.info is not None: return info = [] try: #XXX: Bad style to use so long `try:...except:...`. Fix it! import _winreg pkey = "HARDWARE\\DESCRIPTION\\System\\CentralProcessor" prgx = re.compile(r"family\s+(?P\d+)\s+model\s+(?P\d+)"\ "\s+stepping\s+(?P\d+)",re.IGNORECASE) chnd=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,pkey) pnum=0 while 1: try: proc=_winreg.EnumKey(chnd,pnum) except _winreg.error: break else: pnum+=1 print proc info.append({"Processor":proc}) phnd=_winreg.OpenKey(chnd,proc) pidx=0 while True: try: name,value,vtpe=_winreg.EnumValue(phnd,pidx) except _winreg.error: break else: pidx=pidx+1 info[-1][name]=value if name=="Identifier": srch=prgx.search(value) if srch: info[-1]["Family"]=int(srch.group("FML")) info[-1]["Model"]=int(srch.group("MDL")) info[-1]["Stepping"]=int(srch.group("STP")) except: print sys.exc_value,'(ignoring)' self.__class__.info = info def _not_impl(self): pass # Athlon def _is_AMD(self): return self.info[0]['VendorIdentifier']=='AuthenticAMD' def _is_Am486(self): return self.is_AMD() and self.info[0]['Family']==4 def _is_Am5x86(self): return self.is_AMD() and self.info[0]['Family']==4 def _is_AMDK5(self): return self.is_AMD() and self.info[0]['Family']==5 \ and self.info[0]['Model'] in [0,1,2,3] def _is_AMDK6(self): return self.is_AMD() and self.info[0]['Family']==5 \ and self.info[0]['Model'] in [6,7] def _is_AMDK6_2(self): return self.is_AMD() and self.info[0]['Family']==5 \ and self.info[0]['Model']==8 def _is_AMDK6_3(self): return self.is_AMD() and self.info[0]['Family']==5 \ and self.info[0]['Model']==9 def _is_Athlon(self): return self.is_AMD() and self.info[0]['Family']==6 def _is_Athlon64(self): return self.is_AMD() and self.info[0]['Family']==15 \ and self.info[0]['Model']==4 def _is_Opteron(self): return self.is_AMD() and self.info[0]['Family']==15 \ and self.info[0]['Model']==5 # Intel def _is_Intel(self): return self.info[0]['VendorIdentifier']=='GenuineIntel' def _is_i386(self): return self.info[0]['Family']==3 def _is_i486(self): return self.info[0]['Family']==4 def _is_i586(self): return self.is_Intel() and self.info[0]['Family']==5 def _is_i686(self): return self.is_Intel() and self.info[0]['Family']==6 def _is_Pentium(self): return self.is_Intel() and self.info[0]['Family']==5 def _is_PentiumMMX(self): return self.is_Intel() and self.info[0]['Family']==5 \ and self.info[0]['Model']==4 def _is_PentiumPro(self): return self.is_Intel() and self.info[0]['Family']==6 \ and self.info[0]['Model']==1 def _is_PentiumII(self): return self.is_Intel() and self.info[0]['Family']==6 \ and self.info[0]['Model'] in [3,5,6] def _is_PentiumIII(self): return self.is_Intel() and self.info[0]['Family']==6 \ and self.info[0]['Model'] in [7,8,9,10,11] def _is_PentiumIV(self): return self.is_Intel() and self.info[0]['Family']==15 # Varia def _is_singleCPU(self): return len(self.info) == 1 def _getNCPUs(self): return len(self.info) def _has_mmx(self): if self.is_Intel(): return (self.info[0]['Family']==5 and self.info[0]['Model']==4) \ or (self.info[0]['Family'] in [6,15]) elif self.is_AMD(): return self.info[0]['Family'] in [5,6,15] def _has_sse(self): if self.is_Intel(): return (self.info[0]['Family']==6 and \ self.info[0]['Model'] in [7,8,9,10,11]) \ or self.info[0]['Family']==15 elif self.is_AMD(): return (self.info[0]['Family']==6 and \ self.info[0]['Model'] in [6,7,8,10]) \ or self.info[0]['Family']==15 def _has_sse2(self): return self.info[0]['Family']==15 def _has_3dnow(self): # XXX: does only AMD have 3dnow?? return self.is_AMD() and self.info[0]['Family'] in [5,6,15] def _has_3dnowext(self): return self.is_AMD() and self.info[0]['Family'] in [6,15] if sys.platform[:5] == 'linux': # variations: linux2,linux-i386 (any others?) cpuinfo = linux_cpuinfo elif sys.platform[:4] == 'irix': cpuinfo = irix_cpuinfo elif sys.platform == 'darwin': cpuinfo = darwin_cpuinfo elif sys.platform[:5] == 'sunos': cpuinfo = sunos_cpuinfo elif sys.platform[:5] == 'win32': cpuinfo = win32_cpuinfo elif sys.platform[:6] == 'cygwin': cpuinfo = linux_cpuinfo #XXX: other OS's. Eg. use _winreg on Win32. Or os.uname on unices. else: cpuinfo = cpuinfo_base cpu = cpuinfo() if __name__ == "__main__": cpu.is_blaa() cpu.is_Intel() cpu.is_Alpha() print 'CPU information:', for name in dir(cpuinfo): if name[0]=='_' and name[1]!='_': r = getattr(cpu,name[1:])() if r: if r!=1: print '%s=%s' %(name[1:],r), else: print name[1:], print kml_src/doc/000755 000765 000024 00000000000 11676172345 013721 5ustar00pawelmstaff000000 000000 kml_src/Doxyfile000644 000765 000024 00000024014 10353144146 014650 0ustar00pawelmstaff000000 000000 # Doxyfile 1.4.5 #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- PROJECT_NAME = "Kernel-Machine Library" PROJECT_NUMBER = 0.2 OUTPUT_DIRECTORY = CREATE_SUBDIRS = NO OUTPUT_LANGUAGE = English USE_WINDOWS_ENCODING = NO BRIEF_MEMBER_DESC = YES REPEAT_BRIEF = YES ABBREVIATE_BRIEF = "The $name class" \ "The $name widget" \ "The $name file" \ is \ provides \ specifies \ contains \ represents \ a \ an \ the ALWAYS_DETAILED_SEC = NO INLINE_INHERITED_MEMB = NO FULL_PATH_NAMES = NO STRIP_FROM_PATH = / STRIP_FROM_INC_PATH = SHORT_NAMES = NO JAVADOC_AUTOBRIEF = NO MULTILINE_CPP_IS_BRIEF = NO DETAILS_AT_TOP = NO INHERIT_DOCS = YES SEPARATE_MEMBER_PAGES = NO TAB_SIZE = 8 ALIASES = OPTIMIZE_OUTPUT_FOR_C = NO OPTIMIZE_OUTPUT_JAVA = NO BUILTIN_STL_SUPPORT = NO DISTRIBUTE_GROUP_DOC = NO SUBGROUPING = YES #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- EXTRACT_ALL = NO EXTRACT_PRIVATE = NO EXTRACT_STATIC = NO EXTRACT_LOCAL_CLASSES = YES EXTRACT_LOCAL_METHODS = NO HIDE_UNDOC_MEMBERS = NO HIDE_UNDOC_CLASSES = NO HIDE_FRIEND_COMPOUNDS = NO HIDE_IN_BODY_DOCS = NO INTERNAL_DOCS = NO CASE_SENSE_NAMES = YES HIDE_SCOPE_NAMES = NO SHOW_INCLUDE_FILES = YES INLINE_INFO = YES SORT_MEMBER_DOCS = YES SORT_BRIEF_DOCS = NO SORT_BY_SCOPE_NAME = NO GENERATE_TODOLIST = YES GENERATE_TESTLIST = YES GENERATE_BUGLIST = YES GENERATE_DEPRECATEDLIST= YES ENABLED_SECTIONS = MAX_INITIALIZER_LINES = 30 SHOW_USED_FILES = YES SHOW_DIRECTORIES = YES FILE_VERSION_FILTER = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- QUIET = NO WARNINGS = YES WARN_IF_UNDOCUMENTED = YES WARN_IF_DOC_ERROR = YES WARN_NO_PARAMDOC = NO WARN_FORMAT = "$file:$line: $text" WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- INPUT = kml \ INSTALL FILE_PATTERNS = *.c \ *.cc \ *.cxx \ *.cpp \ *.c++ \ *.java \ *.ii \ *.ixx \ *.ipp \ *.i++ \ *.inl \ *.h \ *.hh \ *.hxx \ *.hpp \ *.h++ \ *.idl \ *.odl \ *.cs \ *.php \ *.php3 \ *.inc \ *.m \ *.mm \ *.dox \ *.C \ *.CC \ *.C++ \ *.II \ *.I++ \ *.H \ *.HH \ *.H++ \ *.CS \ *.PHP \ *.PHP3 \ *.M \ *.MM \ *.C \ *.H \ *.tlh \ *.diff \ *.patch \ *.moc \ *.xpm \ *.dox RECURSIVE = YES EXCLUDE = EXCLUDE_SYMLINKS = NO EXCLUDE_PATTERNS = EXAMPLE_PATH = EXAMPLE_PATTERNS = * EXAMPLE_RECURSIVE = NO IMAGE_PATH = INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- SOURCE_BROWSER = NO INLINE_SOURCES = NO STRIP_CODE_COMMENTS = YES REFERENCED_BY_RELATION = YES REFERENCES_RELATION = YES USE_HTAGS = NO VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- ALPHABETICAL_INDEX = NO COLS_IN_ALPHA_INDEX = 5 IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- GENERATE_HTML = YES HTML_OUTPUT = html HTML_FILE_EXTENSION = .html HTML_HEADER = HTML_FOOTER = HTML_STYLESHEET = HTML_ALIGN_MEMBERS = YES GENERATE_HTMLHELP = NO CHM_FILE = HHC_LOCATION = GENERATE_CHI = NO BINARY_TOC = NO TOC_EXPAND = NO DISABLE_INDEX = NO ENUM_VALUES_PER_LINE = 4 GENERATE_TREEVIEW = NO TREEVIEW_WIDTH = 250 #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- GENERATE_LATEX = YES LATEX_OUTPUT = latex LATEX_CMD_NAME = latex MAKEINDEX_CMD_NAME = makeindex COMPACT_LATEX = NO PAPER_TYPE = a4wide EXTRA_PACKAGES = LATEX_HEADER = PDF_HYPERLINKS = NO USE_PDFLATEX = NO LATEX_BATCHMODE = NO LATEX_HIDE_INDICES = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- GENERATE_RTF = NO RTF_OUTPUT = rtf COMPACT_RTF = NO RTF_HYPERLINKS = NO RTF_STYLESHEET_FILE = RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- GENERATE_MAN = NO MAN_OUTPUT = man MAN_EXTENSION = .3 MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- GENERATE_XML = YES XML_OUTPUT = xml XML_SCHEMA = XML_DTD = XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- GENERATE_PERLMOD = NO PERLMOD_LATEX = NO PERLMOD_PRETTY = YES PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- ENABLE_PREPROCESSING = YES MACRO_EXPANSION = NO EXPAND_ONLY_PREDEF = NO SEARCH_INCLUDES = YES INCLUDE_PATH = INCLUDE_FILE_PATTERNS = PREDEFINED = EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- TAGFILES = GENERATE_TAGFILE = kml.tag ALLEXTERNALS = NO EXTERNAL_GROUPS = YES PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- CLASS_DIAGRAMS = YES HIDE_UNDOC_RELATIONS = YES HAVE_DOT = NO CLASS_GRAPH = YES COLLABORATION_GRAPH = YES GROUP_GRAPHS = YES UML_LOOK = NO TEMPLATE_RELATIONS = NO INCLUDE_GRAPH = YES INCLUDED_BY_GRAPH = YES CALL_GRAPH = NO GRAPHICAL_HIERARCHY = YES DIRECTORY_GRAPH = YES DOT_IMAGE_FORMAT = png DOT_PATH = DOTFILE_DIRS = MAX_DOT_GRAPH_WIDTH = 1024 MAX_DOT_GRAPH_HEIGHT = 1024 MAX_DOT_GRAPH_DEPTH = 1000 DOT_TRANSPARENT = NO DOT_MULTI_TARGETS = NO GENERATE_LEGEND = YES DOT_CLEANUP = YES #--------------------------------------------------------------------------- # Configuration::additions related to the search engine #--------------------------------------------------------------------------- SEARCHENGINE = NO kml_src/example/000755 000765 000024 00000000000 11676172345 014607 5ustar00pawelmstaff000000 000000 kml_src/INSTALL000644 000765 000024 00000002565 10353144146 014202 0ustar00pawelmstaff000000 000000 (this file incorporates Doxygen tags so that it can be included in the compiled documentation) /*! \page installation_page Installation These are generic installation instructions. Please be sure to have installed the following packages: - Scons http://www.scons.org - Boost http://www.boost.org - ATLAS http://math-atlas.sourceforge.net The Boost Numeric.Bindings are included in the Kernel-Machine library, but can also be downloaded seperately through Boost's sandbox CVS. The KML contains a few optional bindings as well, these are included mostly for testing purposes. libfann - The fast Artificial Neural Network Library, which can do basic feed-forward neural nets at decent speeds. \section building Building the Kernel-Machine library using Scons To build KML out of the box on windows you will need to have ATLAS installed in /atlas, and Boost in /boost. You will also need either cygwin or mingw to build the CBLAS dll. If they installed in a location other than /mingw or /cygwin, you may need to modify lib/SConscript for scons to execute correctly. If you don't need to build the CBLAS dll, you can simply remove the file lib/SConscript. If all is installed, go to the top-level KML directory, and run scons \verbatim $ cd /foo/bar/kml $ scons \endverbatim to get the examples, test programs, some libraries, and under Windows, a CBLAS dll to be built. */ kml_src/kml/000755 000765 000024 00000000000 11676172345 013737 5ustar00pawelmstaff000000 000000 kml_src/lib/000755 000765 000024 00000000000 11676172345 013722 5ustar00pawelmstaff000000 000000 kml_src/README000644 000765 000024 00000000160 10312310140 013776 0ustar00pawelmstaff000000 000000 These is not a lot here, if you are looking for installation instructions, please check the INSTALL file. kml_src/SConstruct000644 000765 000024 00000012674 11034710124 015175 0ustar00pawelmstaff000000 000000 import cpuinfo, os env = Environment() print "Platform:", env['PLATFORM'] print "Compiler:", env['CXX'] # Start with a default cpp and lib path cpp_path = ['#'] lib_path = [] # Improve platform dependent settings boost_search_path = [] atlas_search_path = [] atlas_link_libs = [] lapack_link_libs = [] c_link_libs = [] arch_flags = '' # for darwin universal binaries if env['PLATFORM'] == 'posix': boost_search_path = ['/usr/include/boost'] atlas_search_path = ['/usr/include/atlas' ] c_link_libs = ['kml'] lib_path = ['/usr/lib', '/usr/lib64/atlas' ] atlas_link_libs = [] search_files = { 'atlas': [ 'libatlas.so.3', 'libatlas.so.3gf' ], 'cblas': [ 'libcblas.so.3', 'libcblas.so.3gf' ], 'lapack_atlas': [ 'liblapack_atlas.so.3' ], 'g2c': [ 'libg2c.so.0' ] } for [ key, value ] in search_files.iteritems(): for file in value: if env.FindFile( file, lib_path ): atlas_link_libs.append( key ) if env.FindFile( 'liblapack.so.3', lib_path ): lapack_link_libs.append( 'lapack' ) elif env['PLATFORM'] == 'win32': env.Replace( ENV = os.environ ) boost_search_path = ['/boost', '/boost/include/boost-1_33_0/boost', '/boost/include/boost-1_33_1/boost'] atlas_search_path = ['/atlas','/atlas/include'] # atlas_link_libs declaration is moved down to the CPU detection code part lib_path = ['#/lib'] if 'VSINSTALLDIR' in os.environ: lib_path.append( os.environ["VSINSTALLDIR"].replace('\\','/') + '/VC/lib' ) elif env['PLATFORM'] == 'darwin': print "Using darwin config" boost_search_path = ['/sw/include/boost'] # atlas_search_path = ['/sw/include/atlas'] atlas_link_libs = ['lapack','cblas','atlas'] lib_path = ['/usr/lib'] c_link_libs = ['kml'] arch_flags = '-arch ppc -arch i386' # Search path dictionaries for dependent libraries path = env.FindFile( 'version.hpp', boost_search_path ) if path == None: print "Could not find Boost! Please check installation and/or search path in SConstruct file." Exit(1) else: # remove the boost directory part from the directory boost_path = os.path.split(os.path.dirname(path.abspath))[0] if not cpp_path.count( boost_path ): cpp_path.append( boost_path ) # try to find the boost library path, and add that to the global libpath for trydir in boost_search_path: if os.path.exists( trydir + '/lib' ): boost_lib_path = trydir + '/lib' if not boost_lib_path in lib_path: lib_path += [ boost_lib_path ] #path = env.FindFile( 'cblas.h', atlas_search_path ) #if path == None: # print "Could not find ATLAS! Please check installation and/or search path in SConstruct file." # Exit(1) #else: # atlas_path = os.path.dirname(path.abspath) # if not cpp_path.count( atlas_path ): # cpp_path.append( atlas_path ) # Adjust the environment env.Replace( CPPPATH = cpp_path ) env.Replace( LIBPATH = lib_path ) # # Alright, perform some basic compile tests (of available libraries etc.) # conf = Configure(env) global_link_libs = [''] if env['PLATFORM'] == 'posix': if conf.CheckLib( 'tcmalloc' ): global_link_libs += ['tcmalloc'] env = conf.Finish() env.Replace( LIBS = global_link_libs ) # # Detect CPU type # cpu = cpuinfo.cpuinfo() cc_flags = '' debug_flags = '' optimise_flags = '' arch_ext = '' if env['CXX'] == 'g++': # change default CXXflags to something which is # CXXFLAGS = .... cc_flags += '-Wall -ansi -pedantic' optimise_flags = '-O3 ' + arch_flags + ' -ffast-math -fomit-frame-pointer -DNDEBUG -DNO_DEBUG' debug_flags += ' -g' if cpu.is_PentiumIII(): optimise_flags += ' -march=pentium3' elif cpu.is_PentiumIV(): optimise_flags += ' -march=pentium4' elif cpu.is_AMDK6(): optimise_flags += ' -march=k6' elif cpu.is_AMDK6_2(): optimise_flags += ' -march=k6-2' elif cpu.is_AMDK6_3(): optimise_flags += ' -march=k6-3' elif cpu.is_Athlon(): optimise_flags += ' -march=athlon' elif cpu.is_Athlon64(): optimise_flags += ' -march=k8' if cpu.is_32bit() and not cpu.is_ppc(): if cpu.has_sse() or cpu.has_sse2(): optimise_flags += ' -mfpmath=sse' if cpu.has_sse(): optimise_flags += ' -msse' if cpu.has_sse2(): optimise_flags += ' -msse2' if cpu.has_sse3(): optimise_flags += ' -msse3' if cpu.has_3dnow(): optimise_flags += ' -m3dnow' if cpu.has_mmx(): optimise_flags += ' -mmmx' elif env['CXX'] == '$CC' and env['CC'] == 'cl': # Set compiler and optimisation flags # for now, warnings are disabled; multithreading is enabled for correct linking cc_flags = '/nologo /EHsc /Zc:forScope /MT' optimise_flags = '/O2 /DNDEBUG /DNO_DEBUG' arch_ext = '' if cpu.is_PentiumIV(): arch_ext += 'P4' if cpu.has_sse2(): optimise_flags += ' /arch:SSE2' arch_ext += 'SSE2' elif cpu.has_sse(): optimise_flags += ' /arch:SSE' arch_ext += 'SSE' atlas_link_libs = ['cblas_' + arch_ext + '.lib'] print "(future use) architecture extension: ", arch_ext # For convenience, attach the environment's LIBS to the atlas_link_libs atlas_link_libs += env['LIBS'] # Export the environment variables Export( 'env' ) Export( 'atlas_link_libs' ) Export( 'lapack_link_libs' ) Export( 'c_link_libs' ) Export( 'arch_ext' ) Export( 'arch_flags' ) # Deligate to build scripts env.Replace( CXXFLAGS = cc_flags + ' ' + optimise_flags + debug_flags ) SConscript( dirs=['lib', 'example'] ) kml_src/test/000755 000765 000024 00000000000 11676172344 014132 5ustar00pawelmstaff000000 000000 kml_src/test/m_tree.cpp000644 000765 000024 00000002766 10312310140 016072 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include int main(int argc, char *argv[]) { kml::m_tree my_tree; return EXIT_SUCCESS; } kml_src/test/matrix_vector_ops.cpp000644 000765 000024 00000007024 10313550351 020371 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; int main(int argc, char *argv[]) { ublas::matrix< double > normal_matrix; ublas::matrix< ublas::vector > test_matrix; normal_matrix.resize( 2, 2 ); test_matrix.resize( 2, 2 ); std::cout << test_matrix << std::endl; ublas::vector u(2); ublas::vector v(2); ublas::vector w(2); u[0] = 1.0; u[1] = -1.0; v[0] = 0.0; v[1] = 2.0; w[0] = 0.5; w[1] = 0.5; test_matrix(0,0) = u; test_matrix(0,1) = v; test_matrix(1,0) = w; test_matrix(1,1) = u; std::cout << "scale_or_dot of " << u << " and " << v << " is " << kml::detail::scale_or_dot( u, v ) << std::endl; std::cout << "scale_or_dot of " << 0.2 << " and " << 0.3 << " is " << kml::detail::scale_or_dot( 0.2, 0.3 ) << std::endl; std::cout << "scale_or_dot of " << u << " and " << 0.2 << " is " << kml::detail::scale_or_dot( u, 0.2 ) << std::endl; std::cout << "scale_or_dot of " << 0.2 << " and " << u << " is " << kml::detail::scale_or_dot( 0.2, u ) << std::endl; std::cout << test_matrix << std::endl; ublas::vector z = kml::detail::prod_element( u, v ); std::cout << z << std::endl; ublas::vector< ublas::vector > test_vector(2); kml::detail::gemv( test_matrix, u, test_vector ); std::cout << "A " << test_matrix << " times " << u << " equals " << test_vector << std::endl; kml::detail::gemv( test_matrix, test_vector, u ); std::cout << "A " << test_matrix << " times " << test_vector << " equals " << u << std::endl; kml::detail::gemv( ublas::trans(test_matrix), u, test_vector ); std::cout << "A^T " << ublas::trans(test_matrix) << " times " << u << " equals " << test_vector << std::endl; kml::detail::gemm( ublas::trans(test_matrix), test_matrix, normal_matrix ); std::cout << "A^T " << ublas::trans(test_matrix) << " times " << test_matrix << " equals " << normal_matrix << std::endl; //kml::detail::gemv( normal_matrix, u, z ); return EXIT_SUCCESS; } kml_src/test/scale.cpp000644 000765 000024 00000006033 10310326113 015702 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; int main(int argc, char *argv[]) { std::vector > points; std::vector target; //kml::read_svm_light( "data/pos_symmetry.data", points, target); kml::read_svm_light( "data/heart_scale.data", points, target); std::cout << "Read inputs " << std::endl; std::cout << "Minima: " << kml::minimum( points ) << std::endl; std::cout << "Mean: " << kml::mean( points ) << std::endl; std::cout << "sd: " << kml::standard_deviation( points ) << std::endl; std::cout << "Maxima: " << kml::maximum( points ) << std::endl; std::cout << std::endl; //std::cout << "Reciprocal of maxima: " << kml::detail::reciprocal_vector( kml::maximum( points ) ) << std::endl; kml::scale_min_max( points ); std::cout << "Min max:" << std::endl; std::cout << "Minima: " << kml::minimum( points ) << std::endl; std::cout << "Mean: " << kml::mean( points ) << std::endl; std::cout << "sd: " << kml::standard_deviation( points ) << std::endl; std::cout << "Maxima: " << kml::maximum( points ) << std::endl; std::cout << std::endl; kml::scale_mean_sd( points ); std::cout << "Scaled: " << std::endl; std::cout << "Minima: " << kml::minimum( points ) << std::endl; std::cout << "Mean: " << kml::mean( points ) << std::endl; std::cout << "sd: " << kml::standard_deviation( points ) << std::endl; std::cout << "Maxima: " << kml::maximum( points ) << std::endl; std::cout << std::endl; } kml_src/test/SConscript000644 000765 000024 00000000274 10312471114 016126 0ustar00pawelmstaff000000 000000 Import('env') Import('atlas_link_libs') env.Program('statistics.cpp' ) env.Program('scale.cpp' ) env.Program('m_tree.cpp' ) env.Program('matrix_vector_ops.cpp', LIBS=atlas_link_libs ) kml_src/test/statistics.cpp000644 000765 000024 00000010110 10314023245 017000 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include #include #include #include #include namespace ublas = boost::numeric::ublas; int main(int argc, char *argv[]) { ublas::vector rand_vector(100); ublas::vector rand_vector_2(100); for( int i=0; i<100; ++i ) { rand_vector[i] = double(i); } std::cout << "x: " << rand_vector << std::endl; // answer should be sum(0:99) == 4950 std::cout << "sum(x): " << kml::sum( rand_vector ) << std::endl; // answer should be mean(0:99) = 49.5 std::cout << "mean(x): " << kml::mean( rand_vector ) << std::endl; // answer should be min(0:99) = 0 std::cout << "min(x): " << kml::minimum( rand_vector ) << std::endl; // answer sould be max(0:99) = 99 std::cout << "max(x): " << kml::maximum( rand_vector ) << std::endl; // population variance should be 841.6666667 std::cout << "var(x): " << kml::variance( rand_vector ) << std::endl; std::cout << "sd(x): " << kml::standard_deviation( rand_vector ) << std::endl; std::cout << "ms(x): " << kml::mean_square( rand_vector ) << std::endl; std::cout << "rms(x): " << kml::root_mean_square( rand_vector ) << std::endl; // but, sum should also work on a vector! std::vector< ublas::vector > vec_of_vec; std::list< ublas::vector > list_of_vec; for( int i=0; i<100; ++i ) { vec_of_vec.push_back( rand_vector ); list_of_vec.push_back( rand_vector ); } // answer should be a vector of lenght 100 containing 0,100,...,9900 std::cout << kml::sum( vec_of_vec ) << std::endl; // answer should be a vector of lenght 100 containing 0,1,...,99 std::cout << kml::mean( vec_of_vec ) << std::endl; // answer should be min(0:99) = (0:99) std::cout << kml::minimum( vec_of_vec ) << std::endl; std::cout << kml::variance( vec_of_vec ) << std::endl; vec_of_vec.push_back( rand_vector_2); std::cout << kml::minimum( vec_of_vec ) << std::endl; std::cout << kml::maximum( vec_of_vec ) << std::endl; std::cout << kml::variance( vec_of_vec ) << std::endl; std::cout << kml::standard_deviation( vec_of_vec ) << std::endl; std::cout << std::endl; std::cout << "Mean square for each element: " << std::endl; std::cout << kml::mean_square( vec_of_vec ) << std::endl; std::cout << std::endl; std::cout << "Mean dot replaces the square with the dot product: " << std::endl; std::cout << kml::mean_dot( vec_of_vec ) << std::endl; std::cout << "which also happens to work on a vector of scalars: " << std::endl; std::cout << kml::mean_dot( rand_vector ) << std::endl; std::cout << std::endl; std::cout << "List container: " << std::endl; std::cout << kml::minimum( list_of_vec ) << std::endl; return EXIT_SUCCESS; } kml_src/lib/cblas.def000644 000765 000024 00000006002 10272460414 015450 0ustar00pawelmstaff000000 000000 EXPORTS cblas_sdsdot=cblas_sdsdot cblas_sdot=cblas_sdot cblas_snrm2=cblas_snrm2 cblas_sasum=cblas_sasum cblas_scnrm2=cblas_scnrm2 cblas_scasum=cblas_scasum cblas_sscal=cblas_sscal cblas_isamax=cblas_isamax cblas_sswap=cblas_sswap cblas_scopy=cblas_scopy cblas_saxpy=cblas_saxpy catlas_saxpby=catlas_saxpby catlas_sset=catlas_sset cblas_srotg=cblas_srotg cblas_srotmg=cblas_srotmg cblas_srot=cblas_srot cblas_srotm=cblas_srotm cblas_sgemv=cblas_sgemv cblas_sgbmv=cblas_sgbmv cblas_strmv=cblas_strmv cblas_stbmv=cblas_stbmv cblas_stpmv=cblas_stpmv cblas_strsv=cblas_strsv cblas_stbsv=cblas_stbsv cblas_stpsv=cblas_stpsv cblas_ssymv=cblas_ssymv cblas_ssbmv=cblas_ssbmv cblas_sspmv=cblas_sspmv cblas_sger=cblas_sger cblas_ssyr=cblas_ssyr cblas_sspr=cblas_sspr cblas_ssyr2=cblas_ssyr2 cblas_sspr2=cblas_sspr2 cblas_sgemm=cblas_sgemm cblas_ssymm=cblas_ssymm cblas_ssyrk=cblas_ssyrk cblas_ssyr2k=cblas_ssyr2k cblas_strmm=cblas_strmm cblas_strsm=cblas_strsm cblas_dsdot=cblas_dsdot cblas_ddot=cblas_ddot cblas_dnrm2=cblas_dnrm2 cblas_dasum=cblas_dasum cblas_dznrm2=cblas_dznrm2 cblas_dzasum=cblas_dzasum cblas_dscal=cblas_dscal cblas_idamax=cblas_idamax cblas_dswap=cblas_dswap cblas_dcopy=cblas_dcopy cblas_daxpy=cblas_daxpy catlas_daxpby=catlas_daxpby catlas_dset=catlas_dset cblas_drotg=cblas_drotg cblas_drotmg=cblas_drotmg cblas_drot=cblas_drot cblas_drotm=cblas_drotm cblas_dgemv=cblas_dgemv cblas_dgbmv=cblas_dgbmv cblas_dtrmv=cblas_dtrmv cblas_dtbmv=cblas_dtbmv cblas_dtpmv=cblas_dtpmv cblas_dtrsv=cblas_dtrsv cblas_dtbsv=cblas_dtbsv cblas_dtpsv=cblas_dtpsv cblas_dsymv=cblas_dsymv cblas_dsbmv=cblas_dsbmv cblas_dspmv=cblas_dspmv cblas_dger=cblas_dger cblas_dsyr=cblas_dsyr cblas_dspr=cblas_dspr cblas_dsyr2=cblas_dsyr2 cblas_dspr2=cblas_dspr2 cblas_dgemm=cblas_dgemm cblas_dsymm=cblas_dsymm cblas_dsyrk=cblas_dsyrk cblas_dsyr2k=cblas_dsyr2k cblas_dtrmm=cblas_dtrmm cblas_dtrsm=cblas_dtrsm clapack_sgesv=clapack_sgesv clapack_sgetrf=clapack_sgetrf clapack_sgetrs=clapack_sgetrs clapack_sgetri=clapack_sgetri clapack_sposv=clapack_sposv clapack_spotrf=clapack_spotrf clapack_spotrs=clapack_spotrs clapack_spotri=clapack_spotri clapack_slauum=clapack_slauum clapack_strtri=clapack_strtri clapack_dgesv=clapack_dgesv clapack_dgetrf=clapack_dgetrf clapack_dgetrs=clapack_dgetrs clapack_dgetri=clapack_dgetri clapack_dposv=clapack_dposv clapack_dpotrf=clapack_dpotrf clapack_dpotrs=clapack_dpotrs clapack_dpotri=clapack_dpotri clapack_dlauum=clapack_dlauum clapack_dtrtri=clapack_dtrtri clapack_cgesv=clapack_cgesv clapack_cgetrf=clapack_cgetrf clapack_cgetrs=clapack_cgetrs clapack_cgetri=clapack_cgetri clapack_cposv=clapack_cposv clapack_cpotrf=clapack_cpotrf clapack_cpotrs=clapack_cpotrs clapack_cpotri=clapack_cpotri clapack_clauum=clapack_clauum clapack_ctrtri=clapack_ctrtri clapack_zgesv=clapack_zgesv clapack_zgetrf=clapack_zgetrf clapack_zgetrs=clapack_zgetrs clapack_zgetri=clapack_zgetri clapack_zposv=clapack_zposv clapack_zpotrf=clapack_zpotrf clapack_zpotrs=clapack_zpotrs clapack_zpotri=clapack_zpotri clapack_zlauum=clapack_zlauum clapack_ztrtri=clapack_ztrtri kml_src/lib/SConscript000644 000765 000024 00000004143 10672121047 015722 0ustar00pawelmstaff000000 000000 # # win32 cblas.dll and cblas.lib construction script # Import( 'env' ) Import( 'arch_ext' ) Import('atlas_link_libs') Import('arch_flags') import os env.SharedLibrary('kml', ['svm_c.cpp'], SHCCFLAGS=arch_flags, LINKFLAGS=arch_flags, LIBS=atlas_link_libs) # # In case of a Windows platform, build the win32 cblas.dll file on the basis of a ATLAS installation # if env['PLATFORM'] == 'win32': import os.path gcc_bin = env.FindFile( 'gcc.exe', ['/mingw/bin','/cygwin/bin'] ) if gcc_bin == None: print "Could not find gcc.exe of a MinGW or Cygwin install, needed to" print "construct a DLL of ATLAS routines." else: env.AppendENVPath('PATH', os.path.dirname(gcc_bin.abspath) ) definition_file = env.Command( '#\lib\cblas_' + arch_ext + '.def', '#\lib\cblas.def', Copy( '$TARGET', '$SOURCE' ) ) dll_builder = Builder( action='gcc -mno-cygwin -shared -o $TARGET ' + \ definition_file[0].path + ' $SOURCES -Wl,--enable-auto-import -Wl,--no-whole-archive', suffix = '.dll', src_suffix = '.a' ) lib_builder = Builder( action='link /lib /machine:ix86 /def:$SOURCES /out:$TARGET', suffix = '.lib', src_suffix = '.def' ) env.Append( BUILDERS = {'DLL': dll_builder } ) env.Append( BUILDERS = {'LIB': lib_builder } ) atlas_root = '/atlas/ATLAS' listing = os.listdir( os.path.join( atlas_root, 'lib' ) ) if listing == None: print "Could not read contents of ATLAS_ROOT/lib. Please check your ATLAS installation." else: subdir = '' for entry in listing: if arch_ext in entry: subdir = entry break if subdir == '': print "Could not find an installed ATLAS library for this architecture (e.g., WinNT_P4SSE2)." else: final_path = atlas_root + "/lib/" + subdir + "/" atlas_files = [ final_path + 'liblapack.a', final_path + 'libcblas.a', final_path + 'libf77blas.a', final_path + 'libatlas.a' ] env.Depends( 'cblas_' + arch_ext + '.dll', definition_file ) env.DLL( 'cblas_' + arch_ext + '.dll', atlas_files ) env.LIB( 'cblas_' + arch_ext + '.lib', definition_file ) kml_src/lib/svm_c.cpp000644 000765 000024 00000051064 10755405704 015536 0ustar00pawelmstaff000000 000000 /***************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005 by Rutger W. ter Borg and Meredith L. Patterson * * * * This program is free software; you can redistribute it and/or * * modify it under the terms of the GNU Limited 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 Limited 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 * *****************************************************************************/ #ifndef _SVM_H #define _SVM_H #include #include #include #include #include #include #include #include #include #include "kml/svm_c.h" typedef std::vector input_type; typedef boost::tuple class_type; typedef boost::tuple rank_type; typedef boost::vector_property_map class_property_map; typedef boost::vector_property_map rank_property_map; typedef kml::classification class_prob; typedef kml::ranking rank_prob; typedef kml::gaussian gaussian_k; typedef kml::polynomial polynomial_k; typedef kml::linear linear_k; extern "C" { void* kml_new_class_double_gaussian(double k, double s) { boost::shared_ptr m(new class_property_map); kml::svm *v = new kml::svm(k, s, m); return (void *) v; } void* kml_copy_class_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; kml::svm* m1 = new kml::svm(*m); return (void *) m1; } void kml_delete_class_double_gaussian(void *v) { delete (kml::svm*) v; } void kml_learn_class_double_gaussian(void *v, double **p, int *t, int sz_row, int sz_col) { kml::svm* m = (kml::svm *) v; boost::shared_ptr data(new class_property_map); for (int j = 0; j < sz_row; ++j) { (*data)[j] = boost::make_tuple(std::vector(*p, (*p) + sz_col), *t); ++p; ++t; } m->set_data(data); m->learn(data->storage_begin(), data->storage_end()); } double kml_classify_double_gaussian(void *v, double *i, int sz) { kml::svm* m = (kml::svm *) v; if (m->operator()(std::vector(i, i+sz)) > 0) return 1; else return 0; // This way we can coerce to boolean trivially. Should try return (m->operator()(std::vector(i, i+sz)) > 0) though. } unsigned int kml_num_svs_class_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; std::vector > svs = m->get_svs(); return svs.size(); } unsigned int kml_sv_size_class_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; return (m->get_svs())[0].size(); } double kml_get_C_class_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; return m->get_C(); } double kml_get_gamma_class_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_gamma(); } void kml_get_alpha_class_double_gaussian(double **alpha, void *v) { kml::svm* m = (kml::svm *) v; std::vector a = m->get_alpha(); *alpha = (double*) malloc(sizeof(double) * a.size()); for (unsigned int i=0; i* m = (kml::svm *) v; std::vector > svs = m->get_svs(); *sv = (double*) malloc(sizeof(double) * svs[0].size()); for (unsigned int j=0; j m(new rank_property_map); return (void *) new kml::svm(k, s, m); } void* kml_copy_rank_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; return (void *) new kml::svm(*m); } void kml_learn_rank_double_gaussian(void *v, double **p, int *g, int *t, int sz_row, int sz_col) { kml::svm* m = (kml::svm *) v; boost::shared_ptr data(new rank_property_map); for (int j = 0; j < sz_row; ++j) { (*data)[j] = boost::make_tuple(std::vector(*p, (*p) + sz_col), *g, *t); ++p; ++g; ++t; } m->set_data(data); m->learn(data->storage_begin(), data->storage_end()); } double kml_rank_double_gaussian(void* v, double *i, int sz) { kml::svm* m = (kml::svm *) v; return (m->operator()(std::vector(i, i+sz))); } unsigned int kml_num_svs_rank_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; std::vector > svs = m->get_svs(); return svs.size(); } unsigned int kml_sv_size_rank_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; return (m->get_svs())[0].size(); } double kml_get_C_rank_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; return m->get_C(); } double kml_get_gamma_rank_double_gaussian(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_gamma(); } void kml_get_alpha_rank_double_gaussian(double **alpha, void *v) { kml::svm* m = (kml::svm *) v; std::vector a = m->get_alpha(); *alpha = (double*) malloc(sizeof(double) * a.size()); for (unsigned int i=0; i* m = (kml::svm *) v; std::vector > svs = m->get_svs(); *sv = (double*) malloc(sizeof(double) * svs[0].size()); for (unsigned int j=0; j(p, s, m); } void* kml_copy_class_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return (void *) new kml::svm(*m); } void kml_delete_class_double_polynomial(void *v) { delete (kml::svm*) v; } void kml_learn_class_double_polynomial(void *v, double **p, int *t, int sz_row, int sz_col) { kml::svm* m = (kml::svm *) v; class_property_map data; for (int j = 0; j < sz_row; ++j) { data[j] = boost::make_tuple(std::vector(*p, (*p) + sz_col), *t); ++p; ++t; } m->set_data(data); m->learn(data.storage_begin(), data.storage_end()); } double kml_classify_double_polynomial(void *v, double *i, int sz) { kml::svm* m = (kml::svm *) v; if (m->operator()(std::vector(i, i+sz)) > 0) return 1; else return 0; // This way we can coerce to boolean trivially. Should try return (m->operator()(std::vector(i, i+sz)) > 0) though. } unsigned int kml_num_svs_class_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; std::vector > svs = m->get_svs(); return svs.size(); } unsigned int kml_sv_size_class_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return (m->get_svs())[0].size(); } double kml_get_C_class_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->get_C(); } double kml_get_scale_class_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_scale(); } double kml_get_bias_class_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_bias(); } double kml_get_order_class_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_order(); } void kml_get_alpha_class_double_polynomial(double **alpha, void *v) { kml::svm* m = (kml::svm *) v; std::vector a = m->get_alpha(); *alpha = (double*) malloc(sizeof(double) * a.size()); for (unsigned int i=0; i* m = (kml::svm *) v; std::vector > svs = m->get_svs(); *sv = (double*) malloc(sizeof(double) * svs[0].size()); for (unsigned int j=0; j(p, s, m); } void* kml_copy_rank_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return (void *) new kml::svm(*m); } void kml_learn_rank_double_polynomial(void *v, double **p, int *g, int *t, int sz_row, int sz_col) { kml::svm* m = (kml::svm *) v; rank_property_map data; for (int j = 0; j < sz_row; ++j) { data[j] = boost::make_tuple(std::vector(*p, (*p) + sz_col), *g, *t); ++p; ++g; ++t; } m->set_data(data); m->learn(data.storage_begin(), data.storage_end()); } double kml_rank_double_polynomial(void* v, double *i, int sz) { kml::svm* m = (kml::svm *) v; return (m->operator()(std::vector(i, i+sz))); } unsigned int kml_num_svs_rank_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; std::vector > svs = m->get_svs(); return svs.size(); } unsigned int kml_sv_size_rank_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return (m->get_svs())[0].size(); } double kml_get_C_rank_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->get_C(); } double kml_get_scale_rank_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_scale(); } double kml_get_bias_rank_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_bias(); } double kml_get_order_rank_double_polynomial(void *v) { kml::svm* m = (kml::svm *) v; return m->kernel_function.get_order(); } void kml_get_alpha_rank_double_polynomial(double **alpha, void *v) { kml::svm* m = (kml::svm *) v; std::vector a = m->get_alpha(); *alpha = (double*) malloc(sizeof(double) * a.size()); for (unsigned int i=0; i* m = (kml::svm *) v; std::vector > svs = m->get_svs(); *sv = (double*) malloc(sizeof(double) * svs[0].size()); for (unsigned int j=0; j(linear_k(), s, m); } void* kml_copy_class_double_linear(void *v) { kml::svm* m = (kml::svm *) v; return (void *) new kml::svm(*m); } void kml_delete_class_double_linear(void *v) { delete (kml::svm*) v; } void kml_learn_class_double_linear(void *v, double **p, int *t, int sz_row, int sz_col) { kml::svm* m = (kml::svm *) v; class_property_map data; for (int j = 0; j < sz_row; ++j) { data[j] = boost::make_tuple(std::vector(*p, (*p) + sz_col), *t); ++p; ++t; } m->set_data(data); m->learn(data.storage_begin(), data.storage_end()); } double kml_classify_double_linear(void *v, double *i, int sz) { kml::svm* m = (kml::svm *) v; if (m->operator()(std::vector(i, i+sz)) > 0) return 1; else return 0; // This way we can coerce to boolean trivially. Should try return (m->operator()(std::vector(i, i+sz)) > 0) though. } unsigned int kml_num_svs_class_double_linear(void *v) { kml::svm* m = (kml::svm *) v; std::vector > svs = m->get_svs(); return svs.size(); } unsigned int kml_sv_size_class_double_linear(void *v) { kml::svm* m = (kml::svm *) v; return (m->get_svs())[0].size(); } double kml_get_C_class_double_linear(void *v) { kml::svm* m = (kml::svm *) v; return m->get_C(); } void kml_get_alpha_class_double_linear(double **alpha, void *v) { kml::svm* m = (kml::svm *) v; std::vector a = m->get_alpha(); *alpha = (double*) malloc(sizeof(double) * a.size()); for (unsigned int i=0; i* m = (kml::svm *) v; std::vector > svs = m->get_svs(); *sv = (double*) malloc(sizeof(double) * svs[0].size()); for (unsigned int j=0; j(linear_k(), s, m); } void* kml_copy_rank_double_linear(void *v) { kml::svm* m = (kml::svm *) v; return (void *) new kml::svm(*m); } void kml_learn_rank_double_linear(void *v, double **p, int *g, int *t, int sz_row, int sz_col) { kml::svm* m = (kml::svm *) v; rank_property_map data; for (int j = 0; j < sz_row; ++j) { data[j] = boost::make_tuple(std::vector(*p, (*p) + sz_col), *g, *t); ++p; ++g; ++t; } m->set_data(data); m->learn(data.storage_begin(), data.storage_end()); } double kml_rank_double_linear(void* v, double *i, int sz) { kml::svm* m = (kml::svm *) v; return (m->operator()(std::vector(i, i+sz))); } unsigned int kml_num_svs_rank_double_linear(void *v) { kml::svm* m = (kml::svm *) v; std::vector > svs = m->get_svs(); return svs.size(); } unsigned int kml_sv_size_rank_double_linear(void *v) { kml::svm* m = (kml::svm *) v; return (m->get_svs())[0].size(); } double kml_get_C_rank_double_linear(void *v) { kml::svm* m = (kml::svm *) v; return m->get_C(); } void kml_get_alpha_rank_double_linear(double **alpha, void *v) { kml::svm* m = (kml::svm *) v; std::vector a = m->get_alpha(); *alpha = (double*) malloc(sizeof(double) * a.size()); for (unsigned int i=0; i* m = (kml::svm *) v; std::vector > svs = m->get_svs(); *sv = (double*) malloc(sizeof(double) * svs[0].size()); for (unsigned int j=0; j #include namespace kml { /*! \brief Defines a classification problem. \param T the example type The example type should be a boost::tuple defining the input as the first element and the output as the second element. \sa regression, ranking \ingroup problem */ template class classification { public: typedef classification type; typedef T example_type; typedef typename boost::tuples::element<0,T>::type input_type; typedef typename boost::tuples::element<1,T>::type output_type; }; // Define templates is_classification so we can recognise the classification type of problems template struct is_classification: boost::mpl::bool_ {}; template struct is_classification >: boost::mpl::bool_ {}; } #endif kml_src/kml/design_matrix.hpp000644 000765 000024 00000007433 10377266147 017315 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef DESIGN_MATRIX_HPP #define DESIGN_MATRIX_HPP #include #include #include #include #include #include #include #include #include #include /*! Design matrix construction algorithm. Mostly referred to as matrix H. Source is an existing support vector set, which could be the output of a pre-processing step. However, mostly this is equal to target. Target are all input data points associated with the fitting problem. Changeable design matrix as well (can be later extended with data buffering, exchanging, etc.) Design matrix: - Sources - Targets Often, sources are a subset of the targets, but not necessarily always. It is quite a safe assumption to say that sources and targets are two seperate sets. Actions: - A point is added to the source set: a column is added to the design matrix - A point is added to the target set: a row is added to the design matrix For efficiency reasons, we do want the storage to be continuous, use matrix proxies in conjunction with ATLAS, and resizes should only take place once in a while. */ namespace atlas = boost::numeric::bindings::atlas; namespace ublas = boost::numeric::ublas; // TODO fix value types etc. namespace kml { template void design_matrix( Range const &source, Range const &target, Kernel const &kernel, double const bias_value, ublas::matrix &result ) { // FIXME the result should be resized already?? // do a non-preserving resize result.resize( boost::size(target), boost::size(source)+1, false ); // TODO check atlas additional functionality ublas::matrix_column > bias_col( result, 0 ); //atlas::set( bias_value, bias_col ); std::fill( boost::begin(bias_col), boost::end(bias_col), bias_value ); for( unsigned int s = 0; s < boost::size( source ); ++s ) { for( unsigned int t = 0; t < boost::size( target ); ++t ) { // or is [] usable already as well? result( t, s+1 ) = kernel( *(boost::begin(source) + s), *(boost::begin(target) + t) ); } } } } // namespace kml #endif kml_src/kml/detail/000755 000765 000024 00000000000 11676172345 015201 5ustar00pawelmstaff000000 000000 kml_src/kml/distance.hpp000644 000765 000024 00000012026 10377266147 016244 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef DISTANCE_HPP #define DISTANCE_HPP /*! -------> Old code, should be revised Basic functionality to compute the distance of scalar types and vector types. It automatically chooses an efficient implementation, on the basis of the HAVE_BOOST_NUMERIC_BINDINGS define, and the data type passed by the user. Available algorithms: - \b distance. Computes ||u-v||_2 - \b distance_square. Computes ||u-v||_2^2 Template metaprogramming is used to make one generic function work on both scalar and vector types. This should work on any kernel function. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace lambda = boost::lambda; // TODO use call_traits for best possible parameter and return type selection // however, compiler seems to complain (at a first try) namespace kml { namespace detail { template struct range_comp: public std::binary_function { bool operator()(Range const &u, Range const &v) { typename Range::const_iterator iter_u = u.begin(); typename Range::const_iterator iter_v = v.begin(); while( (iter_u != u.end()) && (*iter_u == *iter_v) ) { ++iter_u; ++iter_v; } if (iter_u == u.end()) return false; else return *iter_u < *iter_v; } }; template struct range_equal: public std::binary_function { bool operator()(Range const &u, Range const &v) { return ( distance_square( u,v) < 1e-6 ); } }; template struct has_NaNs: public std::unary_function { bool operator()(Range const &u) { typedef typename boost::range_value::type scalar_type; return (std::find_if( boost::begin(u), boost::end(u), lambda::bind( std::not_equal_to(),lambda::_1,lambda::_1) ) != u.end()); } }; struct scalar_square { template inline T operator()(const T& x) { return x * x; } }; struct scalar_distance_square { template static T compute(const T& x, const T& y) { static scalar_square ss; return ss(x-y); } }; struct vector_distance_square { template inline static typename boost::range_value::type compute( T const &u, T const &v ) { static scalar_square ss; typename boost::range_value::type result(0); for( typename boost::range_size::type i = 0; i < boost::size(u); ++i ) { result += ss(u[i]-v[i]); } return result; } }; } // namespace detail /*! distance_square function which works on both scalars and vectors. Complex numbers not taken into account :-) \ingroup helper */ template typename input_value::type distance_square( T const &u, T const &v ) { return mpl::if_< boost::is_scalar, detail::scalar_distance_square, detail::vector_distance_square >::type::compute( u, v ); } template struct closer_by: std::binary_function< T, T, bool > { closer_by(T const &c, Kernel &k): location(c), kernel(k) {} bool operator()( T const &a, T const &b ) { return (kernel(a,a)-2.0*kernel(location,a)) < (kernel(b,b)-2.0*kernel(location,b)); } T location; Kernel kernel; }; } // namespace kml #endif kml_src/kml/figueiredo.hpp000644 000765 000024 00000017560 10377266147 016604 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef FIGUEIREDO_HPP #define FIGUEIREDO_HPP #include #include "least_squares.h" #include #include #include namespace kml { /*! \brief Adaptive Sparseness using Jeffreys' prior \param I the input type \param O the output type \param K the kernel type Two update rules are computed here: - \f$ \sigma^2_{n+1} = \Vert Hx-y\Vert^2 / N \f$ - \f$ x_{n+1} = (\vert Ix^{-2}\vert H)^{-1}H^Ty \f$ The model is initialised with a ridge regression estimate. However, the original system of update equations has no computational problems at all, despite mentioned as such. Example: \code kml::figueiredo< ublas::vector, double, kml::gaussian > my_machine( 1.6 ); my_machine.learn( x, y ); \endcode \todo - Remove dependency of LAPACK, move to ATLAS' posv - Add a true probabilistic framework \section bibliography References -# Adaptive Sparseness using Jeffreys' prior Mario A.T. Figueiredo, 2003 */ template class K > class figueiredo: public probabilistic { public: typedef probabilistic base_type; typedef typename base_type::kernel_type kernel_type; typedef typename base_type::result_type result_type; typedef I input_type; typedef O output_type; typedef double scalar_type; typedef ublas::symmetric_matrix symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; /*! \param k the kernel construction parameter */ figueiredo( typename boost::call_traits::param_type k ): base_type(k) {} template void learn( IRange const &input, ORange const &output ) { learn( input, input, output ); } template void learn( IRange const &source, IRange const &target, ORange const &output ) { // create the kernel matrix (symmetric part) // initialise & compute H, Hty and HtH matrix_type H; // TODO traits form base_type::kernel!! design_matrix( source, target, base_type::kernel, 1.0, H ); // TODO use a less heavy call? vector_type Hty( source.size()+1 ); atlas::gemv( CblasTrans, 1.0, H, output, 0.0, Hty ); symmetric_type HtH( H.size2(), H.size2() ); inner_prod( H, HtH ); // indices <- 0,1,2,...,N-1 vector_type weight_vector( HtH.size1() ); std::vector indices( HtH.size1() ); iota( indices.begin(), indices.end(), 0 ); // Figueiredo's method should start with a least squares estimate or an ridge regression estimate // start with a ridge regression estimate (needed in case of exact data), with a value of // lambda which prevents singularities. // TODO figure out why this formulation solves the condition number thing. ridge_regression( HtH, weight_vector, Hty, std::numeric_limits::epsilon() * static_cast( Hty.size() * Hty.size() * Hty.size() ) ); // Figueiredo's method main loop // Stopping criterion: minimum change in log weight must be larger than 1e-6. // initialise the maximum difference with something that is larger than the stopping criterion scalar_type variance_estimate(0); scalar_type max_diff = static_cast(1); while( max_diff > static_cast(1e-6) ) { // discard active variables with a weight smaller than the machine epsilon prune_indices( indices, weight_vector ); // Estimate the variance // Since the variance is added to the diagonal of the system matrix, also do some // singularity prevention, by setting the minimum variance estimate to N^3 * machine epsilon // residual_sum_squares will become mean_dot( Hw - y ) variance_estimate = std::max( residual_sum_squares( H, weight_vector, indices, output ) / static_cast(output.size()), std::numeric_limits::epsilon() * static_cast( indices.size() * indices.size() * indices.size()) ); // TODO: improve naming scheme: index_sv, i_idx? A, B? indices? etc. // Lapack: requires column major matrices ublas::symmetric_matrix A( indices.size(), indices.size() ); ublas::matrix B( indices.size(), 1 ); // NOTE --> GENERIC: solve a dynamic ridge-like system (as in RVM) // A <- I*var*diag(weight^-2) + HtH // B <- Ht*y for( unsigned int i=0; i(0.0); for( unsigned int i=0; i max_diff) max_diff = diff; } } // that's all, folks! std::cout << "Adaptive Sparseness using Jeffreys Prior (Figueiredo, 2003)" << std::endl; std::cout << "Support vectors: " << indices.size() << std::endl; std::cout << "variance estimate: " << variance_estimate << std::endl; if ( indices.front() == 0 ) { base_type::bias = weight_vector(0); indices.erase( indices.begin() ); } else { base_type::bias = 0.0; } base_type::weight.resize( indices.size() ); base_type::support_vector.resize( indices.size() ); for( int i=0; i #include #include #include #include #include #include #include namespace kml { /*! \brief Gaussian kernel of the form \f$ f(x)=e^{-\gamma\|x - \mu\|} \f$ where \f$ \gamma = \frac{1}{\sigma^2} \f$ \param T defines the underlying input data type (distance_square must be defined, which is done for scalar and vector types in distance.hpp) This is a template class that creates a functor for the Gaussian kernel. Complexity: O(d+c), i.e., a little more time than needed for computing the dot product \ingroup kernels */ template class gaussian: public std::binary_function::type> { public: /*! Refinement of AdaptableBinaryFunction */ typedef T first_argument_type; typedef T second_argument_type; typedef typename input_value::type result_type; /*! Refinement of Kernel */ typedef gaussian type; // scalar type ... typedef typename input_value::type scalar_type; friend class boost::serialization::access; /*! Refinement of DefaultConstructible */ gaussian() { set_width(1.0); } /*! Refinement of CopyConstructible */ gaussian( type const &other ) { copy( other ); } /*! Refinement of Assignable */ type &operator=( type const &other ) { if (this != &other) { copy(other); } return *this; } /*! Construct a Gaussian kernel by providing a value for sigma \param sigma the width of the gaussian kernel */ gaussian( typename boost::call_traits::param_type sigma ) { set_width(sigma); } /*! Kernel constructor by providing TokenIterators */ template gaussian( TokenIterator const begin, TokenIterator const end ) { if (begin == end ) { // default value set_width( 1.0 ); } else { set_width( boost::lexical_cast( *begin ) ); } } /*! Returns the result of the evaluation of the Gaussian kernel for its arguments \param u input pattern u \param v input pattern v \return \f$ e^{-\gamma\|u - v\|} \f$ */ scalar_type operator()( T const &u, T const &v ) const { return std::exp( exp_factor * distance_square( u, v ) ); } /*! Sets \f$ \sigma \f$. */ void set_width( typename boost::call_traits::param_type sigma ) { assert( sigma > 0.0 ); width = sigma; exp_factor = -1.0 / (2.0*sigma*sigma); } /*! Returns \f$ \sigma \f$. */ scalar_type const get_width() const { return width; } /*! Sets \f$ \gamma \f$. */ void set_gamma( typename boost::call_traits::param_type gamma ) { set_scale_factor( gamma ); } /*! Sets \f$ \gamma \f$. */ void set_scale_factor( typename boost::call_traits::param_type gamma ) { assert( gamma > 0.0 ); width = std::sqrt(0.5 / gamma); exp_factor = -gamma; } /*! Returns \f$ \gamma \f$. */ scalar_type const get_gamma() const { return -exp_factor; } /*! Returns \f$ \gamma \f$. */ scalar_type const get_scale_factor() const { return -exp_factor; } /*! The dimension of the feature space */ scalar_type const dimension() const { return std::numeric_limits::infinity(); } /*! loading and saving capabilities */ template void serialize( Archive &archive, unsigned int const version ) { archive & width; archive & exp_factor; } // for debugging purposes friend std::ostream& operator<<(std::ostream &os, type const &k) { os << "Gaussian kernel (exp(-||u-v||^2/(2*" << k.width << "^2))" << std::endl; return os; } private: void copy( type const &other ) { width = other.width; exp_factor = other.exp_factor; } scalar_type width; scalar_type exp_factor; }; } // namespace kml namespace boost { namespace serialization { template struct tracking_level< kml::gaussian > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } } #endif kml_src/kml/hermitian.hpp000644 000765 000024 00000027503 10405312117 016415 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef HERMITIAN_HPP #define HERMITIAN_HPP #include #include #include #include #include #include #include #include #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace kml { namespace detail { /* \brief Statically computes any Hermite "factor". This compile-time function computes the constants present a Hermite polynomial H_n(x). \param N selects Hermite polynomial H_N \param I selects the I'th constant, those corresponding to lower powers of x^n first \return A static integer containing the corresponding Hermite "factor". */ template struct hermite_factor { static const int value = detail::power<-1,N/2-I>::value * (factorial::value / (factorial::value * factorial::value )) * power<2,N-2*(N/2-I)>::value; }; template struct hermite_eval { template static void precompute( T const factor, T const pow_x, T const dot_xx, T *buffer ) { *buffer = factor * hermite_factor::value * pow_x; hermite_eval::precompute( factor, pow_x * dot_xx, dot_xx, buffer+1 ); } template static T compute( T const *buffer, T const pow_x, T const dot_xx ) { return *buffer * pow_x + hermite_eval::compute( buffer+1, pow_x * dot_xx, dot_xx ); } }; template struct hermite_eval { template static void precompute( T const factor, T const pow_x, T const dot_xx, T *buffer ) { *buffer = factor * hermite_factor::value * pow_x; } template static T compute( T const *buffer, T const pow_x, T const dot_xx ) { return *buffer * pow_x; } }; // -1, for the case N==1 template struct hermite_eval { template static void precompute( T const factor, T const pow_x, T const dot_xx, T *buffer ) {} template static T compute( T const *buffer, T const pow_x, T const dot_xx ) { // should return 1.0, otherwise the result of this function is indeterminate: can // cause bugs. It is much better to not call this function ever at all (current case). return 1.0; } }; template struct hermitian_even { static typename input_value::type compute( typename input_value::type const *buffer, typename input_value::type const exp_factor, typename input_value::type const d_square, Input const &u, Input const &v ) { return ( *buffer + hermite_eval::compute( buffer+1,d_square,d_square )) * std::exp( exp_factor * d_square ); } }; template struct hermitian_uneven { static Input compute( typename input_value::type const *buffer, typename input_value::type const exp_factor, typename input_value::type const d_square, Input const &u, Input const &v ) { if (N==1) // at N==1, we should not unroll any loop: otherwise we call a termplate with J=-1 // and since hermite_eval returns a number (is not a void function), the behaviour // of this function is WRONG is this if-statement is not here (bug squashed). return *buffer * std::exp( exp_factor * d_square ) * (u-v); else return ( *buffer + hermite_eval::compute( buffer+1,d_square,d_square )) * std::exp( exp_factor * d_square ) * (u-v); } }; } //namespace detail /*! \brief Hermitian kernel \param Input defines the underlying input data type \param N defines the derivative order N, with default 0 This is a template class that creates a function for any derivative of the hermitian kernel. It will result in a functor callable by a vector type on which enough operations are defined. It uses template metaprogramming to perform loop unrollment for the initialisation of any order derivative kernel. Also, the evaluation is also programmed by loop unrollment. Luckily, size of the loop which is unrolled is only 0.5*O(N), with N derivative order. Example code: \code kml::hermitian< ublas::vector > kernel( 1.0 ); ublas::vector u(2); ublas::vector v(2); std::cout << kernel( u, v ) << std::endl; std::transform( my_data.begin(), my_data.end(), result.begin(), kernel ); std::transform( my_data.begin(), my_data.end(), result.begin(), kml::hermitian< ublas::vector,2 >(1.0) ); \endcode \todo - call the input type I - clean-up - finish documentation - complexity guarantees - loading and saving */ template class hermitian: public std::binary_function::type> { public: BOOST_SERIALIZATION_SPLIT_MEMBER() friend class boost::serialization::access; typedef typename input_value::type scalar_type; typedef typename mpl::int_::type derivative_order; /*! Construct an uninitialised hermitian kernel */ hermitian() {} /*! Construct a hermitian kernel \param sigma the width of the hermitian kernel */ hermitian( typename boost::call_traits::param_type sigma ) { set_width( sigma ); } /*! \param u input pattern u \param v input pattern v \return the result of the evaluation of the hermitian kernel for these points. The length of the result depends on the derivative order of the kernel, which is 1 for N even, and D for N odd, with D the length of the patterns u and v. */ typename power_value::type operator()( Input const &u, Input const &v ) const { return mpl::if_< mpl::is_even >, detail::hermitian_even, detail::hermitian_uneven >::type::compute( precomputed_factors, exp_factor, distance_square(u,v), u, v ); } void set_width( typename boost::call_traits::param_type sigma ) { assert( sigma > 0.0 ); width = sigma; exp_factor = -1.0 / (2.0*sigma*sigma); init(); } scalar_type const get_width() const { return width; } void set_scale_factor( typename boost::call_traits::param_type gamma ) { assert( gamma > 0.0 ); width = std::sqrt(0.5 / gamma); exp_factor = -gamma; init(); } scalar_type const get_scale_factor() const { return -exp_factor; } /*! Initialise the kernel; precompute all needed Hermite factors */ void init() { // precompute, the if statement will be removed by compile-time optimisations if ( mpl::is_even< mpl::int_ >::type::value ) { // herm_factor was: 1.0 / ( sqrt::sqrt(2.0 * sigma )) // total_factor was: pow( -herm_factor, N ) scalar_type total_factor = detail::power<-1,N/2>::value * std::pow( exp_factor, N/2 ); precomputed_factors[0] = total_factor * detail::hermite_factor::value; detail::hermite_eval::precompute( total_factor, -exp_factor, -exp_factor, precomputed_factors+1 ); } else { // total_factor was: pow( -herm_factor, N ) scalar_type total_factor = -std::pow( 1.0 / ( std::sqrt(2.0) * width ), N+1 ); precomputed_factors[0] = total_factor * detail::hermite_factor::value; detail::hermite_eval::precompute( total_factor, -exp_factor, -exp_factor, precomputed_factors+1 ); } } template void load( Archive &archive, unsigned int const version ) { archive & width; exp_factor = -1.0 / (2.0*width*width); init(); } template void save( Archive &archive, unsigned int const version ) const { archive & width; } private: scalar_type width; scalar_type exp_factor; scalar_type precomputed_factors[N/2+1]; }; // for efficiency reasons, a 0th order derivative specialisation template class hermitian:public std::binary_function::type> { public: BOOST_SERIALIZATION_SPLIT_MEMBER() friend class boost::serialization::access; typedef typename input_value::type scalar_type; typedef typename mpl::int_<0>::type derivative_order; /*! Construct an uninitialised hermitian kernel */ hermitian() {} hermitian( typename boost::call_traits::param_type sigma ) { set_width(sigma); } /*! \param u input pattern u \param v input pattern v \return the result of the evaluation of the hermitian kernel for these points */ typename power_value::type operator()( Input const &u, Input const &v ) const { return std::exp( exp_factor * distance_square( u, v ) ); } void set_width( typename boost::call_traits::param_type sigma ) { assert( sigma > 0.0 ); width = sigma; exp_factor = -1.0 / (2.0*sigma*sigma); } scalar_type const get_width() const { return width; } void set_scale_factor( typename boost::call_traits::param_type gamma ) { assert( gamma > 0.0 ); width = std::sqrt(0.5 / gamma); exp_factor = -gamma; } scalar_type const get_scale_factor() const { return -exp_factor; } /*! The dimension of the feature space */ scalar_type const dimension() const { return std::numeric_limits::infinity(); } template void load( Archive &archive, unsigned int const version ) { archive & width; exp_factor = -1.0 / (2.0*width*width); } template void save( Archive &archive, unsigned int const version ) const { archive & width; } private: scalar_type width; scalar_type exp_factor; }; } // namespace kml #endif kml_src/kml/incomplete_cholesky.hpp000644 000765 000024 00000025767 10671773164 020531 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef KML_INCOMPLETE_CHOLESKY_HPP #define KML_INCOMPLETE_CHOLESKY_HPP #include #include #include #include #include #include #include #include /*! This algorithm will construct a partial QR decomposition, similar to the the incomplete cholesky decomposition described in [1--2]. The naming of matrices is a bit different, because of a geometric interpretation of the algorithm done here. It is identical to an orthogonalisation procedure where the furthest vector is added to the basis. Additional documentation is a todo. Efficient SVM training using low-rank kernel representations Fine, Scheinberg http://jmlr.csail.mit.edu/papers/volume2/fine01a/fine01a.pdf Figure 2, Page 255 Predictive low-rank decomposition for kernel methods Bach, Jordan http://cmm.ensmp.fr/~bach/bach_jordan_csi.pdf Section 2.1 */ namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; using boost::tuples::get; namespace kml { template< typename Kernel, typename PropertyMap > class incomplete_cholesky { public: typedef Kernel kernel_type; typedef PropertyMap map_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; incomplete_cholesky( typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): basis_size(0), kernel_function(k), data(map) {} // after an orthogonalisation has finished, one may use this routine to compute the Q part // however, this only works for linear kernels, and, may be not as precise as the result of // an householder-based QR decomposition void compute_Q() { Q.resize( get<0>(data[pivot[0]]).size(), RT.size2() ); Q.clear(); // data model: column n of A is equal to data[n], A(1:m,i) = data[i] // A has n columns, vectors of length m // Q is m by n, with m the length of the vectos in A ublas::column( Q, 0 ) = get<0>(data[pivot[0]]) / RT.matrix(0,0); for( std::size_t i=1; i < basis_size; ++i ) { typedef ublas::matrix_vector_slice< ublas::matrix > range_type; range_type mvr( RT.matrix, ublas::slice( i, 0, i ), ublas::slice( 0, 1, i ) ); ublas::column( Q, i ) = ( get<0>(data[pivot[i]]) - ublas::prod( ublas::subrange( Q, 0, Q.size1(), 0, i ), mvr ) ) / RT.matrix(i,i); } } // // TODO: add an overloaded increment method in which you can provide precomputed kernel values // e.g., providing vectors such candidate_column as used in the online_svm.hpp // void add_to_basis( std::size_t index ) { // move some stuff around std::swap( pivot[ basis_size ], pivot[ index ] ); std::swap( squared_distance[ basis_size ], squared_distance[ index ] ); RT.swap_row( basis_size, index ); // resize the R^T matrix RT.grow_column(); double perpendicular_distance = std::sqrt( squared_distance[ basis_size ] ); // lookup the current key key_type current_key = pivot[ basis_size ]; // Clear the columns belonging to the other basis vectors, // these are orthogonal to this new basis vector and thus 0 for( std::size_t row = 0; row < basis_size; ++row ) { RT.matrix( row, basis_size ) = 0.0; } // record the current perpendicular distance; this also means that we are done // with computing for our new basis vector, all computations which are done next are for the remaining set RT.matrix( basis_size, basis_size ) = perpendicular_distance; // check whether we have to initialise the R matrix, or extend it if ( basis_size == 0 ) { for( std::size_t row = basis_size+1; row < pivot.size(); ++row ) { double value = kernel_function( get<0>(data[current_key]), get<0>(data[pivot[row]]) ) / perpendicular_distance; RT.matrix( row, basis_size ) = value; squared_distance[ row ] -= value * value; } } else { // Pass 1: Setup slices and views, and fire it through ATLAS // This basically performs a matrix-vector operation, and store it in a temporary vector typedef ublas::matrix_vector_slice > slice_type; ublas::matrix_range< ublas::matrix > RT_range( ublas::subrange( RT.matrix, basis_size+1, RT.size1(), 0, basis_size )); slice_type basis_range( RT.matrix, ublas::slice(basis_size, 0, basis_size), ublas::slice(0, 1, basis_size) ); ublas::vector target( RT.size1()-basis_size-1 ); atlas::gemv( RT_range, basis_range, target ); // Pass 2: finish the work we have just started, take the temporary vector, and make the update // R( i, new_basis_vec ) <- ( k( i, new_basis_vec ) - RT[new_basis_vec]^T RT[i] ) / d_perp for( std::size_t row = basis_size+1; row < pivot.size(); ++row ) { double value = ( kernel_function( get<0>(data[current_key]), get<0>(data[pivot[row]]) ) - target[row-basis_size-1] ) / perpendicular_distance; RT.matrix( row, basis_size ) = value; squared_distance[ row ] -= value * value; } } // To prevent rounding errors squared_distance[ basis_size ] = 0.0; // WARNING do not move this statement! ++basis_size; } // remove a vector from the basis, update the matrix RT void remove_from_basis( std::size_t index ) { // WARNING do not move this statement! --basis_size; } // adds the key to the data under consideration; // will compute its distance information, and update matrix RT // // TODO: add an overloaded increment method in which you can provide precomputed kernel values // e.g., providing vectors such as k_t and scalar k_tt as used in KRLS // void increment( key_type const &key ) { // increase the size of the matrix RT, and compute the resulting values in the // last row, which are associated to the key of this lastly added input RT.grow_row(); squared_distance.push_back( kernel_function(get<0>(data[key]),get<0>(data[key])) ); for( std::size_t i=0; i < basis_size; ++i ) { // Setup the views, and compute the (incrementally growing) inner product between row i and the last row, typedef ublas::matrix_vector_slice > slice_type; slice_type basis_range( RT.matrix, ublas::slice(i, 0, i), ublas::slice(0, 1, i) ); slice_type new_vector_range( RT.matrix, ublas::slice( pivot.size(), 0, i ), ublas::slice(0, 1, i) ); double value = ( kernel_function( get<0>(data[key]), get<0>(data[pivot[i]]) ) - atlas::dot( basis_range, new_vector_range ) ) / RT.matrix( i, i ); RT.matrix( pivot.size(), i ) = value; squared_distance.back() -= value * value; } // WARNING do not move this statement pivot.push_back( key ); } void decrement( key_type const &key ) { // check whether the key under consideration is in the basis; if it is, it takes // more work than when it is not // TODO! right now, does a POP RT.shrink_row(); pivot.pop_back(); squared_distance.pop_back(); } // rank could leave in the future template void compute_R( KeyIterator begin, KeyIterator end, std::size_t rank ) { // make sure we have a pivot table std::copy( begin, end, back_inserter( pivot ) ); // initialise the R matrix RT.reserve( pivot.size(), 0 ); // the order of our data should not have changed since the std::copy, three statements ago for( typename std::vector::iterator i = pivot.begin(); i != pivot.end(); ++i ) { squared_distance.push_back( kernel_function(get<0>(data[*i]),get<0>(data[*i])) ); } double max_distance = 1.0; // only a small number... // TODO: figure out a suitable stopping criterion while( basis_size < rank ) { //while( max_distance > 1e-6 ) { //while( (remaining_set.size() > 0) && ( max_pdsq > 1e-6 ) ) { max_distance = 0.0; int migrate_index = 0; for( std::size_t i = basis_size; i < squared_distance.size(); ++i ) { if ( squared_distance[i] > max_distance ) { max_distance = squared_distance[i]; migrate_index = i; } } if ( max_distance > 1e-6 ) { add_to_basis( migrate_index ); } else { //std::cout << "Basis could not be extended!" << std::endl; } } //std::cout << "Orthogonalisation finished, size of basis: " << basis_size << std::endl; } /* double distance( key_type const &key ) { } */ // this is the key lookup table; serves for pretty much everything std::vector< key_type > pivot; std::vector squared_distance; std::size_t basis_size; // QR decomposition, upper triangular matrix R, transposed kml::matrix_view< ublas::matrix > RT; // QR decomposition, orthogonal matrix Q ublas::matrix Q; // data and the kernel kernel_type kernel_function; PropertyMap const data; } ; // class incomplete cholesky } // namespace kml #endif kml_src/kml/input_value.hpp000644 000765 000024 00000003542 10377266147 017010 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef INPUT_VALUE_HPP #define INPUT_VALUE_HPP #include #include #include #include namespace mpl = boost::mpl; namespace kml { /*! determine the type of the input value scalar type -> scalar type vector type -> underlying scalar type \ingroup meta */ template struct input_value: mpl::eval_if,mpl::identity,boost::range_value > {}; } #endif kml_src/kml/io.hpp000644 000765 000024 00000061262 10671773164 015066 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef IO_HPP #define IO_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include // temp #include namespace kml { namespace io { enum problem_type { unknown, regression, classification, ranking }; /*! The .dst file format is very simple: comma delimited lines of text. Lines that start with "A" describe a variable, whose id number is the second field in the line. The third field in the line is either 101 (if the variable is a class label) or 1 (if the variable is not). For this benchmark, all you need to use is that variable id 1000 is the class label, while variable ids from 1001 to 1123 are input attributes. Lines that start with "C" indicate the start of a new training example. The rest of the line identifies the training example. Lines that start with "V" are attributes of the current example. The second field is the variable id (see "A" lines above), and the third field is the value of the variable. If a variable is not specified by a "V" line, its value defaults to 0. For example, in this benchmark, if an example has a line that says V,1000,0 it means that the example has a negative label. If the following line appears: V,1015,1 it means that input attribute #15 is true (1). If no such line appears before the next "C" line, it means that input attribute #15 is false (0). */ namespace dst { bool compatible( std::vector const &container ) { return ( (container[0][0]=='A') || (container[0][0]=='V') || (container[0][0]=='C') ); } problem_type problem_type( std::vector const &container ) { return classification; } template void read( std::vector const &container, io::problem_type p_type, PropertyMap &map, BackInsertionSequence &keys ) { typedef PropertyMap map_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; // should become some KML shortcut to do this... // should do a run-time specialisation per problem_type, as this is probably problem_type specific typedef typename boost::tuples::element<0,object_type>::type input_type; typedef typename boost::tuples::element<1,object_type>::type output_type; std::map id_mapping; unsigned int output_class_id(0); bool output_class_found(false); // first read format description std::vector::const_iterator i = container.begin(); boost::char_separator csv_separator(",\n\r"); unsigned int max_attributes = 0; while( (i!=container.end()) && ((*i)[0]=='A') ) { boost::tokenizer > values( *i, csv_separator ); boost::tokenizer >::iterator j = values.begin(); // skip past the A ++j; // read a possible class id unsigned int id = boost::lexical_cast< unsigned int >( *j++ ); if ( boost::lexical_cast< unsigned int >( *j ) == 101 ) { output_class_id = id; output_class_found = true; } else { id_mapping[ id ] = max_attributes++; } ++i; } if (!output_class_found) { std::cout << "Serious problem, could not find an output class id." << std::endl; } int example_counter(0); int current_example(0); output_type output(0); std::cout << "max attributes: " << max_attributes << std::endl; input_type attributes( max_attributes ); while(i!=container.end()) { boost::tokenizer > tokens( *i, csv_separator ); boost::tokenizer >::iterator j = tokens.begin(); switch( (*i)[0] ) { // the start of a new training example case 'C': { if ( current_example != example_counter ) { map[ current_example ] = boost::make_tuple( attributes, output ); keys.push_back( current_example ); } //std::cout << "new example..." << std::endl; current_example = example_counter; attributes.clear(); ++example_counter; break; } // attributes of the new training example case 'V': { // detect whether it is the output class type, or not... ++j; // skip the 'V' unsigned int id = boost::lexical_cast< unsigned int >( *j++ ); if ( id == output_class_id ) { if (boost::is_same::value) output = (boost::lexical_cast(*j) > 0); else output = boost::lexical_cast(*j); // set the output to something } else { attributes[ id_mapping[ id ] ] = boost::lexical_cast< double >( *j ); } break; } default: { //std::cout << "Error detected in input file." << std::endl; break; } } ++i; } } } /*! Read a data file also used in Joachims' SVM^{light} format For more details, see http://svmlight.joachims.org/ \param I a range over input examples \param O a range over output examples The routine performs two passes over the data file (mainly to preserve the maximum amount of memory needed): -1 Acquire statistics of the file - How many data samples are we dealing with? - What is the maximum number of nonzero attributes found in a sample? - What is the maximum index of attribute found in a sample? -2 Read and parse all values in the file \ingroup fileio The input file example_file contains the training examples. The first lines may contain comments and are ignored if they start with #. Each of the following lines represents one training example and is of the following format: .=. : : ... : # .=. +1 | -1 | 0 | .=. | "qid" .=. .=. The target value and each of the feature/value pairs are separated by a space character. Feature/value pairs MUST be ordered by increasing feature number. Features with value zero can be skipped. The string can be used to pass additional information to the kernel (e.g. non feature vector data). */ namespace svm_light { bool compatible( std::vector const &container ) { std::vector::const_iterator i = container.begin(); // check for .=. : : ... : boost::char_separator separator(" \t"); boost::tokenizer > first_line( *i, separator ); boost::tokenizer >::iterator j = first_line.begin(); // non-empty line is no good if ( j == first_line.end() ) return false; // skip the target ++j; // no feature data? if ( j == first_line.end() ) return false; // perform the following test: each token should contain a ':' bool format_ok = true; while( (j != first_line.end()) && format_ok ) { format_ok = std::find( boost::begin(*j), boost::end(*j), ':' ) != boost::end(*j); ++j; } return format_ok; } problem_type problem_type( std::vector const &container ) { // try to reject binary classification; each line should start with +1 or with -1 std::vector::const_iterator i = container.begin(); while( (i!=container.end()) && ((*i).size()>3) && ((*i)[1]=='1') && ( ((*i)[0]=='+') || ((*i)[0]=='-') ) ) ++i; if (i==container.end()) return io::classification; // try to reject ranking; each line should contain 'qid' i = container.begin(); bool found_qid = true; while ( i!=container.end() && found_qid ) { std::string::const_iterator q_loc = std::find( (*i).begin(), (*i).end(), 'q' ); found_qid = (((*i).end()-q_loc)>2) && (q_loc[1]=='i') && (q_loc[2]=='d'); ++i; } if (found_qid) return io::ranking; // no other tests available, default to regression return regression; } template void read( std::vector const &container, io::problem_type p_type, PropertyMap &map, BackInsertionSequence &keys ) { typedef PropertyMap map_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; typedef typename boost::tuples::element<0,object_type>::type input_type; typedef typename boost::tuples::element<1,object_type>::type output_type; // quick routine to figure out the maximum feature number std::vector::const_iterator iter = container.begin(); std::size_t max_attribute_nr = 0; // because the feature values are ordened by design, we only need the LAST feature value while( iter != container.end() ) { // start at the end of the line, backwards search for the first occurance of ":", // find the atrribute number of value in front of that typedef boost::range_const_reverse_iterator >::value_type>::type char_iter_type; char_iter_type char_iter = std::find( boost::const_rbegin(*iter), boost::const_rend(*iter), ':' ); ++char_iter; unsigned int attribute_nr = 0; unsigned int multiplier = 1; while( (*char_iter) != ' ' ) { attribute_nr += boost::lexical_cast< unsigned int >( *char_iter ) * multiplier; multiplier *= 10; ++char_iter; } if (attribute_nr > max_attribute_nr) max_attribute_nr = attribute_nr; ++iter; } //std::cout << "max attribute number: " << max_attribute_nr << std::endl; // these are the separators the input file will be split on: // space, tab, #, and : boost::char_separator separator(" \t#:"); // reset the data iterator iter = container.begin(); unsigned int sample_key = 0; while (iter != container.end()) { boost::tokenizer > tokens( *iter, separator ); boost::tokenizer >::iterator attribute_iter = tokens.begin(); output_type output(0); if (boost::is_same::value) output = (boost::lexical_cast(*attribute_iter++) > 0); else output = boost::lexical_cast< output_type >( *attribute_iter++ ); // create the input type, which is in this case (still) // assumed to be a dense vector (e.g., std::vector, or ublas::vector). // clear the input type, it could be uninitialised input_type attributes( max_attribute_nr ); std::fill( attributes.begin(), attributes.end(), 0.0 ); while( (attribute_iter != tokens.end()) && ((*iter)[0] != static_cast('#')) ) { // FIXME // ERROR: this is not in all cases a number, such as in case of a ranking problem // Figure out the attribute number. This is 1-based, so subtract 1 unsigned int attribute_nr = boost::lexical_cast< unsigned int >( *attribute_iter++ ) - 1; // read the input into the input container attributes[ attribute_nr ] = boost::lexical_cast< double >( *attribute_iter++ ); } map[ sample_key ] = boost::make_tuple( attributes, output ); keys.push_back( sample_key ); ++sample_key; ++iter; } } } /*! Read a data file also used in SVM Torch - train data file format in ASCII mode For more details, see http://www.idiap.ch/machine_learning.php?content=Torch/en_SVMTorch.txt \param I a range over input examples \param O a range over output examples Because you supply inputs AND outputs here, the SVM Torch Train data file format is assumed \ingroup fileio */ namespace svm_torch { bool compatible( std::vector const &container ) { boost::char_separator separator(" \t"); std::vector::const_iterator i = container.begin(); try { boost::tokenizer > first_line( *i, separator ); boost::tokenizer >::iterator j = first_line.begin(); if ( j == first_line.end() ) return false; // unsigned int samples = boost::lexical_cast( *j++ ); // unsigned int attributes = boost::lexical_cast( *j++ ); } catch( boost::bad_lexical_cast & ) { return false; } return true; } io::problem_type problem_type( std::vector const &container ) { boost::char_separator separator(" \t"); // try to detect the problem type // skip the first line std::vector::const_iterator i = container.begin(); ++i; bool classification_assumption = true; // try to reject binary classification while( classification_assumption && (i!=container.end()) ) { std::string::const_iterator j( (*i).end() ); // first, find a non-space character bool found = false; while( !found && (j != (*i).begin()) ) { --j; found = (*j != ' '); } std::string::const_iterator k( j ); ++k; // then, find the first space character found = false; while( !found && (j != (*i).begin()) ) { --j; found = (*j == ' '); } if (found) ++j; double value = boost::lexical_cast< double >( std::string(j,k) ); classification_assumption = ( (value==1.0) || (value==-1.0) ); ++i; } if (classification_assumption) return io::classification; // no other tests yet, return regression return io::regression; } template void read( std::vector const &container, io::problem_type p_type, PropertyMap &map, BackInsertionSequence &keys ) { typedef PropertyMap map_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; // should become some KML shortcut to do this... typedef typename boost::tuples::element<0,object_type>::type input_type; typedef typename boost::tuples::element<1,object_type>::type output_type; unsigned int number_of_samples; unsigned int number_of_attributes; // these are the separators the input file will be split on: // space and tab boost::char_separator separator(" \t"); std::vector::const_iterator iter = container.begin(); boost::tokenizer > first_line( *iter, separator ); boost::tokenizer >::iterator i=first_line.begin(); number_of_samples = boost::lexical_cast< unsigned int >( *i++ ); number_of_attributes = boost::lexical_cast< unsigned int >( *i ) - 1; std::cout << "nr of samples: " << number_of_samples << std::endl; std::cout << "nr of attributes: " << number_of_attributes << std::endl; // go to the next line... ++iter; // read the data unsigned int sample_index = 0; input_type my_attributes( number_of_attributes ); output_type output; while( iter != container.end() ) { // split the current line boost::tokenizer > tokens( *iter, separator ); i = tokens.begin(); // DENSE vector format for( unsigned int j=0; j( *i++ ); } if (boost::is_same::value) output = (boost::lexical_cast(*i) > 0.0); else output = boost::lexical_cast< output_type >( *i ); map[ sample_index ] = boost::make_tuple( my_attributes, output ); keys.push_back( sample_index ); ++sample_index; ++iter; } } } // namespace svm_torch // basic filetype: a data matrix, i.e., one example per line namespace data_matrix { // bool compatible( std::vector const &container ) { return true; } io::problem_type problem_type( std::vector const &container ) { return io::regression; } template struct line_reader {}; template struct line_reader { line_reader() { std::cout << "Not a tuple type..." << std::endl; } }; template struct line_reader { line_reader() { std::cout << "Tuple size = 1, instantiated." << std::endl; } }; template void read( std::vector const &container, io::problem_type p_type, PropertyMap &map, BackInsertionSequence &keys ) { typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; typedef typename boost::tuples::element<0,object_type>::type input_type; typedef typename boost::tuples::element<1,object_type>::type output_type; // std::cout << "starting to read the data matrix filetype..." << std::endl; // separate on a superset of a csv separator boost::char_separator separator(", \t\n\r"); std::vector::const_iterator i = container.begin(); // check properties of first line boost::tokenizer > first_line( *i, separator ); boost::tokenizer >::iterator line_tok = first_line.begin(); unsigned int nr_of_attributes = 0; std::vector process_column; while( line_tok != first_line.end() ) { ++line_tok; ++nr_of_attributes; } //std::cout << "nr of columns: " << nr_of_attributes << std::endl; input_type row( nr_of_attributes ); key_type sample_index = 0; while( i != container.end() ) { boost::tokenizer > values( *i, separator ); boost::tokenizer >::iterator j = values.begin(); int row_entry = 0; while( j != values.end() ) { try { row[row_entry++] = boost::lexical_cast(*j); } catch ( boost::bad_lexical_cast & ) { row[row_entry++] = std::numeric_limits::quiet_NaN(); } ++j; } map[ sample_index ] = boost::make_tuple( row, boost::lexical_cast(0.0) ); keys.push_back( sample_index ); ++sample_index; ++i; } } } // namespace data_matrix } // namespace kml::io class file { public: typedef boost::char_separator char_separator_type; typedef boost::tokenizer< char_separator_type, char* > char_tokenizer; file( std::string const &filename ) { // open the file std::ifstream input_file( filename.c_str(), std::ios::in ); if ( !input_file.is_open() ) { std::cout << "Could not open file " << filename << std::endl; } std::cout << "Reading " << filename << "..." << std::flush; std::string line_buffer; while( !input_file.eof() ) { std::getline( input_file, line_buffer ); // skip empty lines and lines that begin with a comment mark if ((line_buffer.size()>0) && (line_buffer[0]!='#')) { // strip comments (i.e., anything after '#') from these lines std::string::iterator my_end = std::find( line_buffer.begin(), line_buffer.end(), '#' ); buffer.push_back( std::string(line_buffer.begin(), my_end) ); } } std::cout << "read " << buffer.size() << " lines." << std::endl; input_file.close(); if ( buffer.size() == 0 ) { std::cout << "Could not read any contents from " << filename << std::endl; } if ( io::dst::compatible( buffer) ) { handler = dst_handler; //std::cout << "dst handler installed" << std::endl; } else if ( io::svm_light::compatible( buffer ) ) { handler = svm_light_handler; //std::cout << "svm light handler installed" << std::endl; } else if ( io::svm_torch::compatible( buffer ) ) { handler = svm_torch_handler; //std::cout << "svm torch handler installed" << std::endl; } else if ( io::data_matrix::compatible( buffer ) ) { handler = data_matrix_handler; //std::cout << "data matrix handler installed" << std::endl; } else std::cout << "unknown file format!" << std::endl; } io::problem_type problem_type() { switch( handler ) { case dst_handler: { return io::dst::problem_type( buffer ); break; } case svm_light_handler: { return io::svm_light::problem_type( buffer ); break; } case svm_torch_handler: { return io::svm_torch::problem_type( buffer ); break; } case data_matrix_handler: { return io::data_matrix::problem_type( buffer ); break; } } return io::unknown; } template void read( PropertyMap &map, BackInsertionSequence &keys ) { switch( handler ) { case dst_handler: { io::dst::read( buffer, io::classification, map, keys ); break; } case svm_light_handler: { io::svm_light::read( buffer, io::classification, map, keys ); break; } case svm_torch_handler: { io::svm_torch::read( buffer, io::classification, map, keys ); break; } case data_matrix_handler: { io::data_matrix::read( buffer, io::classification, map, keys ); break; } } } enum file_handler { dst_handler, svm_light_handler, svm_torch_handler, data_matrix_handler }; file_handler handler; std::vector buffer; }; // toy example of using bzip2 compression /* template void write( char* file_name, PatternMap &dataset ) { // open the file std::ofstream output_file( file_name, std::ios::out | std::ios::binary ); // define the output filter iostreams::filtering_ostream out; out.push( iostreams::bzip2_compressor() ); out.push( output_file ); // perform a test out << "Test!" << std::endl; // close everything out.pop(); output_file.close(); } */ } // namespace kml #endif kml_src/kml/kernel.hpp000644 000765 000024 00000003626 10732423347 015730 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef KML_KERNEL_HPP #define KML_KERNEL_HPP namespace kml { template< typename Input, typename Result, typename Super > class kernel: public std::binary_function { /*! Refinement of AdaptableBinaryFunction */ typedef Input first_argument_type; typedef Input second_argument_type; typedef Result result_type; inline Result operator()( Input const &u, Input const &v ) const { return Super::dot( u, v ); } inline Result dot_self( Input const &u ) { } }; } #endif kml_src/kml/kernel_machine.hpp000644 000765 000024 00000036637 11034710267 017420 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef KERNEL_MACHINE_HPP #define KERNEL_MACHINE_HPP #include #include #include #include #include #include #include #include #include #include // for the property traits #include #include //using boost::tuples::get; namespace lambda = boost::lambda; namespace kml { template< typename Problem, typename Kernel, typename PropertyMap, class Enable=void > class kernel_machine {} ; /*! \brief Regression kernel machine This is used as a base for various regression kernel machines, for example kml::rvm. \param Problem a regression problem type, for example kml::regression \param Kernel kernel to be used by the machine \ingroup kernel_machines */ template< typename Problem, typename Kernel, typename PropertyMap > class kernel_machine< Problem, Kernel, PropertyMap, typename boost::enable_if< is_regression >::type>: public std::unary_function< typename Problem::input_type, typename Problem::output_type > { public: typedef Kernel kernel_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; friend class boost::serialization::access; typedef typename std::vector< key_type >::size_type index_type; // FIXME make this something else... typedef double scalar_type; // Bug fixed: use call_traits instead of const&, so can be called with both reference and non-reference /*! \brief Initializes the kernel \param k parameter used to initialize the kernel */ kernel_machine( typename boost::call_traits::param_type k, PropertyMap const &map ): kernel_function(k), data(boost::cref(map)) {} // void set_data( PropertyMap const& map ) { // data = map; // } void set_kernel( kernel_type const &k ) { kernel_function = k; } inline input_type const& input( key_type const key ) const { return boost::tuples::get<0>(data.get()[key]); } inline output_type const& output( key_type const key ) const { return boost::tuples::get<1>(data.get()[key]); } typename kernel_type::result_type kernel( key_type const i, key_type const j ) { return kernel_function( input(i), input(j) ); } typename kernel_type::result_type kernel( input_type const &x1, key_type const j ) { return kernel_function( x1, input(j) ); } typename kernel_type::result_type kernel( input_type const &x1, input_type const &x2 ) { return kernel_function( x1, x2 ); } template void fill_kernel( input_type const &x, KeyIterator const begin, KeyIterator const end, OutputIterator out ) { KeyIterator i(begin); OutputIterator j(out); while (i!=end) { *j = kernel_function( x, input(*i) ); ++i; ++j; } } template void fill_kernel( key_type const key, KeyIterator const begin, KeyIterator const end, OutputIterator out ) { KeyIterator i(begin); OutputIterator j(out); while (i!=end) { *j = kernel_function( input(key), input(*i) ); ++i; ++j; } } template void kernel_matrix( KeyIterator const begin, KeyIterator const end, Matrix &out ) { // row by row filling KeyIterator i(begin); std::size_t row = 0; while( i != end ) { std::size_t col = 0; KeyIterator j(begin); while( j != end ) { out( row, col ) = kernel_function( input(*i), input(*j) ); ++col; ++j; } ++row; ++i; } } // to fill, e.g., a column of H, use the fill_kernel method // from boost documentation: // An algorithm that iterates through the range [m.begin1 (), m.end1 ()) will // pass through every row of m , an algorithm that iterates through the range [m.begin2 (), m.end2 ()) // will pass through every column of m . template void design_matrix( KeyIterator const begin, KeyIterator const end, Matrix &out ) { // row by row filling KeyIterator i(begin); std::size_t row = 0; while( i != end ) { out( row, 0 ) = 1.0; std::size_t col = 0; KeyIterator j(begin); while( j != end ) { out( row, ++col ) = kernel_function( input(*i), input(*j) ); ++j; } ++row; ++i; } } // loading and saving capabilities template void serialize( Archive &archive, unsigned int const version ) { // here we store whatever we want to store... archive & kernel_function; } private: /// kernel_function used by the machine kernel_type kernel_function; /// pointer to data container used by the machine boost::reference_wrapper< PropertyMap const > data; }; /*! \brief Classification kernel machine This is used as a base for various classification kernel machines. \param Problem a classification problem type, for example kml::classification \param Kernel kernel to be used by the machine \ingroup kernel_machines */ template< typename Problem, typename Kernel, typename PropertyMap > class kernel_machine >::type >: public std::unary_function< typename Problem::input_type, typename Problem::output_type > { public: typedef Kernel kernel_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; // FIXME make this something else... typedef double scalar_type; kernel_machine( typename boost::call_traits::param_type k, PropertyMap const &map ): kernel_function(k), data(boost::cref(map)) {} // kernel_machine( typename boost::call_traits::param_type k, // PropertyMap const &map ): // kernel_function(k), data(boostmap) { } kernel_machine(kernel_machine &k): kernel_function(k.kernel_function), data(k.data) { } inline input_type const& input( key_type const key ) const { return boost::tuples::get<0>(data.get()[key]); } inline output_type const& output( key_type const key ) const { return boost::tuples::get<1>(data.get()[key]); } typename kernel_type::result_type kernel( key_type const i, key_type const j ) { return kernel_function( input(i), input(j) ); } typename kernel_type::result_type kernel( input_type const &x1, key_type const j ) { return kernel_function( x1, input(j) ); } typename kernel_type::result_type kernel( input_type const &x1, input_type const &x2 ) { return kernel_function( x1, x2 ); } template void fill_kernel( input_type const &x, KeyIterator const begin, KeyIterator const end, OutputIterator out ) { KeyIterator i(begin); OutputIterator j(out); while (i!=end) { if ( data.get()[*i].get<1>() ) *j = kernel_function( x, input(*i) ); else *j = -kernel_function( x, input(*i) ); ++i; ++j; } } template void fill_kernel( key_type const key, KeyIterator const begin, KeyIterator const end, OutputIterator out ) { KeyIterator i(begin); OutputIterator j(out); if ( data.get()[key].get<1>() ) { while (i!=end) { if ( data.get()[*i].get<1>() ) *j = kernel_function( input(key), input(*i) ); else *j = -kernel_function( input(key), input(*i) ); ++i; ++j; } } else { while (i!=end) { if ( data.get()[*i].get<1>() ) *j = -kernel_function( input(key), input(*i) ); else *j = kernel_function( input(key), input(*i) ); ++i; ++j; } } } void set_kernel( kernel_type const &k ) { kernel_function = k; } // loading and saving capabilities template void serialize( Archive &archive, unsigned int const version ) { // here we store whatever we want to store... archive & kernel_function; } private: /// kernel_function used by the machine kernel_type kernel_function; /// pointer to data container used by the machine boost::reference_wrapper< PropertyMap const > data; }; /*! \brief Ranking kernel machine This is used as a base for various ranking kernel machines, for example kml::svm. \param Problem a ranking problem type, for example kml::ranking \param Kernel kernel to be used by the machine \ingroup kernel_machines */ template< typename Problem, typename Kernel, typename PropertyMap > class kernel_machine >::type >: public std::unary_function< typename Problem::input_type, typename Problem::output_type > { public: typedef Kernel kernel_type; typedef typename Problem::input_type input_type; typedef typename Problem::group_type group_type; typedef typename Problem::output_type output_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; // FIXME make this something else... typedef double scalar_type; kernel_machine( typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): kernel_function(k), data(&map) {} kernel_machine( typename boost::call_traits::param_type k, PropertyMap const &map ) : kernel_function(k), data(boost::cref(map)) {} typename kernel_type::result_type kernel( key_type const i, key_type const j ) { return kernel_function( (*data)[i].get<0>(), (*data)[j].get<0>() ); } typename kernel_type::result_type kernel( input_type const &x, key_type const j ) { return kernel_function( x, (*data)[j].get<0>() ); } typename kernel_type::result_type kernel(key_type const i, input_type const &x) { return kernel_function(data.get()[i].get<0>(), x); } template void fill_kernel( input_type const &x, KeyIterator const begin, KeyIterator const end, OutputIterator out ) { KeyIterator i(begin); OutputIterator j(out); while (i!=end) { if ( data.get()[*i].get<1>() ) *j = kernel_function( x, data.get()[*i].get<0>() ); else *j = -kernel_function( x, data.get()[*i].get<0>() ); ++i; ++j; } } template void fill_kernel( key_type const key, KeyIterator const begin, KeyIterator const end, OutputIterator out ) { KeyIterator i(begin); OutputIterator j(out); if ( data.get()[key].get<1>() ) { while (i!=end) { if ( data.get()[*i].get<1>() ) *j = kernel_function( data.get()[key].get<0>(), data.get()[*i].get<0>() ); else *j = -kernel_function( data.get()[key].get<0>(), data.get()[*i].get<0>() ); ++i; ++j; } } else { while (i!=end) { if ( data.get()[*i].get<1>() ) *j = -kernel_function( data.get()[key].get<0>(), data.get()[*i].get<0>() ); else *j = kernel_function( data.get()[key].get<0>(), data.get()[*i].get<0>() ); ++i; ++j; } } } void set_data( PropertyMap const &map ) { data = boost::shared_ptr(&map); } void set_data( PropertyMap const *map) { data = boost::shared_ptr(map); } void set_data( boost::shared_ptr map) { data = map; } // loading and saving capabilities template void serialize( Archive &archive, unsigned int const version ) { // here we store whatever we want to store... archive & kernel_function; } /// kernel_function used by the machine kernel_type kernel_function; /// pointer to data container used by the machine boost::reference_wrapper< PropertyMap const > data; }; } // namespace kml // set tracking to track never namespace boost { namespace serialization { template< typename Problem, typename Kernel, typename PropertyMap, typename Enable > struct tracking_level< kml::kernel_machine > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost #endif kml_src/kml/kernels.h000644 000765 000024 00000053544 10405312117 015544 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef KERNELS_H #define KERNELS_H // Boost uBLAS includes #include #include #include // Boost numeric bindings to e.g. ATLAS #include #include #include #include #include //#include #include #include #include #include #include #include #include #include #include #include #include // use like this: // Gaussian<2> kernel( 1.0 ); // Gaussian<4> kernel (1.0); // double inner_prod( a, b, kernel ); // gramm_matrix( X, X, kernel ); namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; //namespace lapack = boost::numeric::bindings::lapack; enum kernel_type { Gaussian_trait, polynomial_trait }; enum precomp_type { in_prod, sq_diff }; // Prune indices from some index vector, given a weight vector. // Indices will be pruned if weights are within the prune limit. // Weights will be cleared, i.e. set to zero exactly. // perhaps this can be done smarter, however, as it is, it is quite optimal // the longer series (indices vector) is copied to itself, and the "write head" // will only make progress if the index remains. So, the "read head" will in case // of deletion be ahead of its write counterpart. At the end, the remainder // is erased. template inline void prune_indices( VecI &indices, VecV &values ) { typedef typename VecV::value_type value_type; typename VecI::iterator it_read = indices.begin(); typename VecI::iterator it_write = indices.begin(); while( it_read != indices.end() ) { if ( kml::detail::is_zero( values[*it_read] ) ) values[ *it_read++ ] = 0.0; else (*it_write++) = (*it_read++); } indices.erase( it_write, it_read ); } // TO MOVE template inline Type const square( Type const &value ) { return value * value; } template inline void outer_prod( matX const &X, matR &result ) { if (X.size1()>X.size2()) { for (int col=0; col X_col( X, col ); atlas::spr( X_col, result ); } } else { for (int row=0; row X_row( X, row ); atlas::spr( X_row, result ); } } } template inline void inner_prod( MatX const &X, MatR &result ) { MatX temp( X.size2(), X.size2() ); atlas::gemm( ublas::trans(X), X, temp ); result.assign( temp ); } template inline void inner_prod( MatX const &X, MatX const &Y, MatR &result ) { MatX temp( X.size2(), X.size2() ); atlas::gemm( trans(X), Y, temp ); result.assign( temp ); } template inline void outer_norm2( matX const &X, matR &result ) { typedef typename matX::value_type Type; // result will contain pairwise ||x_i-x_j||^2 of all elements of X // use the identity ||u-v||^2 == (u-v)^T * (u-v) = u^T*u - 2 * u^T*v + v^T*v // start with the ordinary inner product kernel matrix call outer_prod( X, result ); //kernel_precomp::kernel_matrix( X, result ); // get the diagonal from result filled with self-inner products // create a vector filled with a constant ublas::vector diag(ublas::matrix_vector_range >(result, ublas::range(0, result.size1()), ublas::range(0, result.size1()))); ublas::vector one_vector( result.size1() ); atlas::set ( 1.0, one_vector ); // multiply the result, for the -2 in "u^T*u - 2 * u^T*v + v^T*v" // do this after the diagonal vector was assigned! result *= -2.0; // spr2: A <- x yT + y xT + A, A symmetric real matrix in packed format atlas::spr2( one_vector, diag, result ); } template void preserved_resize( MatT &M, typename MatT::size_type size1, typename MatT::size_type size2 ) { MatT temp( M ); M.resize( size1, size2, false ); //std::cout << "M is now of size " << M.size1() << " x " << M.size2() << std::endl; unsigned int range_size1 = std::min(temp.size1(),M.size1()); unsigned int range_size2 = std::min(temp.size2(),M.size2()); ublas::matrix_range temp_view( temp, ublas::range(0,range_size1), ublas::range(0,range_size2)); ublas::matrix_range M_view( M, ublas::range(0,range_size1), ublas::range(0,range_size2)); M_view.assign( temp_view ); //std::cout << "resize complete " << std::endl; } template void preserved_resize( VecT &v, typename VecT::size_type size ) { assert( size > v.size() ); VecT temp( v ); v.resize( size ); std::copy( temp.begin(), temp.end(), v.begin() ); } // shrink underlying matrix by eliminating the indexed columns and rows template void preserved_shrink( MatT &X, typename MatT::size_type index1, typename MatT::size_type index2 ) { MatT temp( X.size1()-1, X.size2()-1 ); typedef typename MatT::size_type size_type; // copy first part, and second part // NOTE extremely inefficient workaround size_type row_t=0; for( size_type row=0; row void remove_column( Matrix &X, typename Matrix::size_type index ) { typedef typename Matrix::size_type size_type; for( size_type i=index; i<(X.size2()-1); ++i ) { ublas::column(X,i).assign( ublas::column(X,i+1)); } X.resize( X.size1(), X.size2()-1); } // shrink underlying vector by eliminating the index from the vector template void preserved_shrink( VecT &v, typename VecT::size_type index ) { VecT temp( v.size()-1 ); typedef typename VecT::size_type size_type; // copy first part, and second part // NOTE extremely inefficient workaround size_type j=0; for( size_type i=0; i class order_weight { public: static const int value = (order == 0 ? 1 : 0); }; template class kernel_precomp { public: inline static Type inner_prod( std::vector u, std::vector v ); }; template class kernel_precomp { public: inline static Type inner_prod( std::vector u, std::vector v ) { // return the classic inner product of these two vectors return atlas::dot( u, v ); } inline static void kernel_matrix( ublas::matrix const &X, ublas::symmetric_matrix &result ) { // compute X * X^T, that's all there's to it here // if the number of rows is larger than the number of columns, iterate over columns, // else iterate over rows if (X.size1()>X.size2()) { for (int col=0; col const> X_col( X, col ); atlas::spr( X_col, result ); } } else { for (int row=0; row const> X_row( X, row ); atlas::spr( X_row, result ); } } } }; template class kernel_precomp { public: inline static Type inner_prod( std::vector u, std::vector v ) { // this is kind of not the best way?? Costs a lot of memory, and is inefficient.. // I can pass on the temporary vector in this case... (from the calling function) // ... std::vector temp(u); atlas::axpy(-1.0,v,temp); return atlas::dot( temp, temp ); } inline static void kernel_matrix( ublas::matrix const &X, ublas::symmetric_matrix &result ) {} } ; template Type inner_prod( std::vector const &u, std::vector const &v, KernelType const &kernel ) { // well, do this rather efficient & short, etc.. return kernel( kernel_precomp::inner_prod( u, v ) ); } // // compute the kernel matrix given the data in X and an instantiated kernel function // template void kernel_matrix( ublas::matrix const &X, KernelType const &kernel, ublas::symmetric_matrix &result ) { // the kernel matrix is symmetric result.resize( X.size1(), X.size1() ); result.clear(); // precompute a symmetric matrix with either inner products or squared norm2's kernel_precomp::kernel_matrix( X, result ); // apply the kernel function to all (1/2)*N^2 resulting matrix elements for (unsigned int row=0; row < result.size1(); ++row) for (unsigned int col=0; col <= row; ++col) result(row,col) = kernel( result(row,col) ); // result is a correct kernel matrix of N by N } // compute a generic gram matrix // inputs: matrix expressions, outputs: matrix expressions.... template void kernel_matrix( MatT const &X, MatT const &Y, Kernel const&k, MatT &result ) { // result <- t(X %*% t(Y)) with the inner product operator redefined // result(i,j) <- inner_prod( X[j,], Y[i,] ) // result will be of size M by N, with M=rows(Y), and N=rows(X) // this will result in a kernel matrix if X==Y result.resize( Y.size1(), X.size1() ); for( typename MatT::size_type i = 0; i < Y.size1(); ++i ) { for( typename MatT::size_type j = 0; j < X.size1(); ++j ) { ublas::matrix_row x_j( X, j ); ublas::matrix_row y_i( Y, i ); result( i, j ) = k( x_j, y_i ); } } } template void kernel_matrix( MatT const &X, VecT const &idx, KF const&k, ublas::matrix_range &result ) { // result <- t(X %*% t(Y)) with the inner product operator redefined // result(i,j) <- inner_prod( X[j,], Y[i,] ) // result will be of size M by N, with M=rows(Y), and N=rows(X) // this will result in a kernel matrix if X==Y // result must already be of the proper size!! for( unsigned int i = 0; i < idx.size(); ++i ) { for( unsigned int j = 0; j < idx.size(); ++j ) { ublas::matrix_row x_i( X, idx[i] ); ublas::matrix_row x_j( X, idx[j] ); result( i, j ) = k( x_i, x_j ); } } } template void kernel_matrix( MatT const &X, VecT const &idxX, VecT const &idxY, KF const&k, ublas::matrix_range &result ) { // result <- t(X %*% t(Y)) with the inner product operator redefined // result(i,j) <- inner_prod( X[j,], Y[i,] ) // result will be of size M by N, with M=rows(Y), and N=rows(X) // this will result in a kernel matrix if X==Y // result must already be of the proper size!! for( unsigned int i = 0; i < idxY.size(); ++i ) { for( unsigned int j = 0; j < idxX.size(); ++j ) { ublas::matrix_row x_j( X, idxX[j] ); ublas::matrix_row y_i( X, idxY[i] ); result( i, j ) = k( x_j, y_i ); } } } template void kernel_matrix( MatT const &X, VecY const &y, Kernel const&k, VecR &result ) { // result <- t(X %*% t(Y)) with the inner product operator redefined // result(i,j) <- inner_prod( X[j,], Y[i,] ) // result will be of size M by N, with M=rows(Y), and N=rows(X) // this will result in a kernel matrix if X==Y // sizes have to match!! assert( result.size() == X.size1() ); //result.resize( X.size1() ); for( typename MatT::size_type j = 0; j < X.size1(); ++j ) { ublas::matrix_row x_j( X, j ); result( j ) = k( x_j, y ); } } template void kernel_matrix( MatT const &X, VecY const &y, VecI const &idx, Kernel const&k, VecR &result ) { // result <- t(X %*% t(Y)) with the inner product operator redefined // result(i,j) <- inner_prod( X[j,], Y[i,] ) // result will be of size M by N, with M=rows(Y), and N=rows(X) // this will result in a kernel matrix if X==Y for( unsigned int i=0; i x_i( X, idx[i] ); result( i ) = k( x_i, y ); } } // TODO matrix type independance template void design_matrix( MatT const &X, MatT const &Y, Kernel const&k, MatR &result ) { // result <- t(X %*% t(Y)) with the inner product operator redefined // result(i,j) <- inner_prod( X[j,], Y[i,] ) // result will be of size M by N, with M=rows(Y), and N=rows(X) // this will result in a kernel matrix if X==Y result.resize( Y.size1(), X.size1() + 1 ); //ublas::matrix_column intercept( result, 0 ); // depends on the derivative order of the kernel type... atlas::set( static_cast(order_weight::value), ublas::column( result, 0 ) ); for( typename MatT::size_type i = 0; i < Y.size1(); ++i ) { for( typename MatT::size_type j = 0; j < X.size1(); ++j ) { ublas::matrix_row x_j( X, j ); ublas::matrix_row y_i( Y, i ); result( i, j+1 ) = k( x_j, y_i ); } } } // input: kernel matrix K. Output: inner product of design matrix t(H) %*% H, in packed symmetric form. // additional memory requirements: matrix of size K. // the non-symmetric case of H is much more straightforward, isn't it? template void packed_HtH( ublas::matrix const &H, ublas::symmetric_matrix &HtH ) { // compute H^T * H // create a copy of the kernel matrix K (needed) ublas::matrix temp( H ); ublas::symmetric_adaptor > temp_symm(temp); // compute it's own inner product, K^T K atlas::syrk( CblasTrans, 1.0, temp, 0.0, temp_symm ); // resize H^T H to the appropriate size (nr of columns of K+1) (although K is a symmetric matrix here, // it doesn't really matter, but it does when K is not symmetric) HtH.resize( H.size2()+1, H.size2()+1 ); // take everything but the first column and row ublas::matrix_range > HtH_KtK_part( HtH, ublas::range(1,HtH.size1()), ublas::range(1, HtH.size2()) ); // copy the right parts of K^T K to the H^T H matrix HtH_KtK_part.assign( temp_symm ); // as a final step: incorporate the intercept-column! ublas::vector one_vector( H.size1() ); ublas::vector first_row_and_col( HtH.size1() ); ublas::vector_range > part_of_froc( first_row_and_col, ublas::range(1, first_row_and_col.size()) ); atlas::set ( 1.0, one_vector ); // a part of this is a simple matrix-vector multiplication. atlas::spmv( H, one_vector, part_of_froc ); // inner product of the intercept term column equals its length, and that length // is the number of rows in K (which equals the number of rows in H). first_row_and_col(0) = H.size1(); // copy the result to H^T H ublas::matrix_column > HtH_column( HtH, 0 ); HtH_column.assign( first_row_and_col ); // CORRECT & VERIFIED!! // std::cout << "HtH is " << HtH << std::endl; } template void packed_Hty( ublas::symmetric_matrix const &K, ublas::vector const &y, vector_type &result ) { result.resize( K.size2()+1 ); // handle the intercept term ublas::vector one_vector( K.size1() ); atlas::set ( 1.0, one_vector ); result(0) = atlas::dot( one_vector, y ); // compute first part: Hty <- K y (K is symmetric, so doesn't matter) // then second part: y <- 1 y + y ublas::vector_range > part_of_Hty( result, ublas::range(1, result.size()) ); atlas::spmv( K, y, part_of_Hty ); } template void memory_Hty( MatT const &X, MatT const &Y, kernel_type const &k, vector_type const &y, vector_type result ) { // TODO: should an intercept term be used? // compute memory preserving t(H) %*% y result.clear(); vector_type H_col( X.size1() ); for( typename MatT::size_type j = 0; j < X.size1(); ++j ) { for( typename MatT::size_type i = 0; i < Y.size1(); ++i ) { ublas::matrix_row x_j( X, j ); ublas::matrix_row y_i( Y, i ); H_col( j ) = k( x_j, y_i ); } atlas::axpy( y(j), H_col, result ); } // now the result should contain t(H) %*% y } template Type variance_yHw( ublas::symmetric_matrix const &K, ublas::vector const &weight_vector, vector_type const &targets ) { // compute ||y-Halpha||^2 assert( K.size1() == targets.size() ); assert( (K.size2() + 1) == weight_vector.size() ); ublas::vector residuals( targets.size() ); // process the intercept term atlas::set ( -weight_vector(0), residuals ); atlas::xpy( targets, residuals ); // the second part: y - K alpha // spmv(a,A,x,b,y): y <- a A x + b y, A symmetric real matrix in packed format // skip weight[0] or alpha_0, a.k.a. the intercept term ublas::vector_range const> part_of_weights( weight_vector, ublas::range(1, weight_vector.size()) ); atlas::spmv( -1.0, K, part_of_weights, 1.0, residuals ); // done!. double result = atlas::nrm2( residuals ); return( result * result ); } // the residual sum of squares is this... residual_sum_of_squares... // compute the sum of squares, take an intercept term into account // sum_of_squares <- ||Ax-b||^2 // TODO: correctness check. template typename MatA::value_type residual_sum_squares( MatA const &A, VecA const &x, std::vector const &indices, VecB const &b ) { assert( A.size1() == b.size() ); assert( A.size2() == x.size() ); VecA residuals( b.size() ); atlas::copy( b, residuals ); atlas::scal( -1.0, residuals ); //VecA residuals( -b ); // only use the columns referenced by indices for( std::vector::const_iterator i=indices.begin(); i!=indices.end(); ++i ) { //ublas::matrix_column A_col( A, *i ); // TODO reintroduce atlas ublas::noalias(residuals) += x[*i] * ublas::column(A, *i); //atlas::axpy( x[*i], A_col, residuals ); } // done! typename MatA::value_type result = atlas::dot( residuals, residuals ); return result; } // in this version, the VecA doesn't contain zeros, i.e. isn't of full length template typename MatA::value_type residual_sum_of_squares_2( MatA const &A, VecA const &x, std::vector const &indices, VecB const &b ) { assert( A.size1() == b.size() ); assert( x.size() == indices.size() ); VecA residuals( -b ); // only use the columns referenced by indices for( unsigned int i=0; i #include #include #include #include #include #include #include #include #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace kml { /*! \brief Kernel Recursive Least Squares A preprocessing step is taken to absorb the bias term into the weight vector w, by redefining w as (w^T, b)^T and \f$\phi\f$ as (phi^T,1)^T. For details, see Engel et al, Sparse Online Greedy Support Vector Regression, below on page 3: \f$k(x,x')=k(x,x') + \lambda^2\f$, where \f$\lambda\f$ is a small, positive constant. Kernel matrix K is actually not needed by the algorithm and is therefore dropped. \section bibliography References -# Engel et al., 2003. Kernel Recursive Least Squares. */ template< typename Problem, typename Kernel, typename PropertyMap, class Enable = void> class krls: public kernel_machine< Problem, Kernel, PropertyMap > {} ; template< typename Problem, typename Kernel, typename PropertyMap > class krls< Problem, Kernel, PropertyMap, typename boost::enable_if< is_regression >::type>: public kernel_machine< Problem, Kernel, PropertyMap > { typedef kernel_machine< Problem, Kernel, PropertyMap > base_type; typedef typename base_type::kernel_type kernel_type; typedef double scalar_type; typedef symmetric_view< ublas::matrix > symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; friend class boost::serialization::access; public: krls( scalar_type tol, scalar_type l, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map), tolerance(tol), lambda_squared(l*l) {} template< typename TokenIterator > krls( TokenIterator const begin, TokenIterator const end, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map) { tolerance = 1e-1; // default value scalar_type lambda=1e-3; // default value TokenIterator token(begin); if ( token != end ) { tolerance = boost::lexical_cast( *token++ ); if ( token != end ) lambda = boost::lexical_cast( *token ); } lambda_squared=lambda*lambda; } output_type operator()( input_type const &x ) { vector_type temp_K( basis_key.size() ); fill_kernel( x, basis_key.begin(), basis_key.end(), temp_K.begin() ); for( unsigned int i=0; i < temp_K.size(); ++i ) temp_K[i] += lambda_squared; return atlas::dot( weight, temp_K ); } /*! learn the entire range of keys indicated by this range */ template void learn( KeyIterator begin, KeyIterator end ) { KeyIterator key_iterator(begin); while( key_iterator != end ) { increment( *key_iterator ); ++key_iterator; } } /*! \param key key of example in data */ void increment( key_type const &key ) { // calculate the base_type::kernel function on (x_t,x_t), needed later on scalar_type k_tt = kernel( key, key ) + lambda_squared; // check whether dictionary is still not initialised if ( basis_key.empty() ) { // there is no dictionary yet, so initialise all variables // resize the inverse matrix R, and matrix P to 1 x 1 R.grow_row_column(); P.grow_row_column(); // and use values as stated in the paper R.matrix(0,0) = 1.0 / k_tt; P.matrix(0,0) = 1.0; // add to weight vector weight.push_back( output(key) / k_tt ); // add to support vector set basis_key.push_back( key ); } else { // KRLS already initialised, continue vector_type a_t( basis_key.size() ); vector_type k_t( basis_key.size() ); // fill vector k_t fill_kernel( key, basis_key.begin(), basis_key.end(), k_t.begin() ); for( typename vector_type::size_type i=0; i > R_range( R.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_view( R_range ); atlas::symv( R_view, k_t, a_t ); scalar_type delta_t = k_tt - atlas::dot( k_t, a_t ); // Perform Approximate Linear Dependency (ALD) test // If the ALD is larger than some previously set tolerance, add the input to // the dictionary (or basis vector set) if (delta_t > tolerance) { // add x_t to support vector set, adjust all needed variables std::size_t old_size = basis_key.size(); // update inverse matrix R (equation 14) scalar_type factor = static_cast(1) / delta_t; atlas::syr( factor, a_t, R_view ); R.grow_row_column(); ublas::matrix_vector_slice< ublas::matrix > R_row_part( R.shrinked_row(old_size) ); atlas::scal( -factor, a_t ); R_row_part.assign( a_t ); R.matrix( old_size, old_size ) = factor; // update permutation matrix P (equation 15) // assign unit vector with 1 on last element. P.grow_row_column(); ublas::matrix_vector_slice< ublas::matrix > P_row_part( P.shrinked_row(old_size) ); atlas::set( 0.0, P_row_part ); P.matrix( old_size, old_size ) = 1.0; // adjust weight vector alpha (equation 16) factor = output(key) - atlas::dot(k_t,weight); atlas::axpy( factor, a_t, weight ); // add new weight to the weight vector weight.push_back( factor / delta_t ); // add support vector to the set basis_key.push_back( key ); } else { // support vector set unchanged (see algorithmic on page 4 of paper) // adjust weight vector and permutation matrix P // P_a <- P_t-1 %*% a_t vector_type P_a( basis_key.size() ); // spmv(A,x,y) y <- A x ublas::matrix_range< ublas::matrix > P_range( P.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > P_view( P_range ); atlas::symv( P_view, a_t, P_a ); // 1 / (1 + a_t %*% P_(t-1) %*% a_t) scalar_type factor = 1.0 / (1.0 + atlas::dot( a_t, P_a )); // update weights (equation 13) atlas::symv( factor* output(key) - atlas::dot(k_t,weight), R_view, P_a, static_cast(1), weight ); // update permutation matrix (equation 14) atlas::syr( -factor, P_a, P_view ); } } } // loading and saving capabilities template void serialize( Archive &archive, unsigned int const version ) { archive & boost::serialization::base_object(*this); archive & tolerance; archive & lambda_squared; archive & basis_key; archive & weight; archive & R; archive & P; } private: scalar_type tolerance; // ALD tolerance parameter scalar_type lambda_squared; // kernel function addition std::vector< key_type > basis_key; // a vector containing basis vector keys std::vector< scalar_type > weight; // weights associated with the basis vectors symmetric_type R; // inverse of kernel matrix K symmetric_type P; // permutation matrix P }; } // namespace kml namespace boost { namespace serialization { template< typename Problem, typename Kernel, typename PropertyMap, typename Enable > struct tracking_level< kml::krls > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost #endif kml_src/kml/least_squares.h000644 000765 000024 00000016227 10377266147 016774 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef LEAST_SQUARES_H #define LEAST_SQUARES_H #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; //namespace atlas = boost::numeric::bindings::atlas; namespace lapack = boost::numeric::bindings::lapack; /*! least squares solve Ax=b, where A is a positive definite matrix \ingroup helper */ template void least_squares( MatT const &A, VecT &x, VecT const &b ) { // define a matrix type (flexible for future changes) // has to be column major, otherwise lapack bindings can choke on it typedef ublas::matrix matrix_type; typedef ublas::symmetric_matrix symmetric_type; // assert some stuff assert( x.size() == b.size() ); assert( A.size1() == x.size() ); // copy the matrix, needed because it is also a work space matrix symmetric_type symm_work( A ); // the rhs (right-hand-side) matrix has to be at least as large as the number of columns in H, because the // result of lapack::gelsd will be placed there. Therefore, rhs has to be as "tall" as the // weight vector matrix_type B( x.size(), 1 ); ublas::matrix_column B_col( B, 0 ); B_col.assign( b ); // perform the actual least squares fit lapack::ppsv( symm_work, B ); // copy the answer to the weight vector x.assign( B_col ); } /*! perform ridge regression solve (A+I*\lambda)x=b, where A is a positive definite matrix \ingroup helper */ template void ridge_regression( MatT const &A, VecT &x, VecT const &b, typename MatT::value_type const &lambda ) { // define a matrix type (flexible for future changes) // has to be column major, otherwise lapack bindings can choke on it typedef typename MatT::value_type value_type; typedef ublas::matrix matrix_type; typedef ublas::symmetric_matrix symmetric_type; // all dimensions must be equal assert( x.size() == b.size() ); assert( A.size1() == x.size() ); // create matrix, only 0.5N^2 memory will be used. // add the small value /lambda to the diagonal of the work matrix symmetric_type symm_work( A ); for( unsigned int i=0; i B_col( B, 0 ); B_col.assign( b ); // perform the actual least squares (or least norm) fit lapack::ppsv( symm_work, B ); // copy the answer to the weight vector x.assign( B_col ); } /*! perform roughness penalty regression solve (A+lambda*L)x=b \ingroup helper */ template void roughness_penalty_regression( MatT const &A, MatT const &L, VecT &x, VecT const &b, typename MatT::value_type const &lambda ) { // define a matrix type (flexible for future changes) // has to be column major, otherwise lapack bindings can choke on it typedef typename MatT::value_type value_type; typedef ublas::matrix matrix_type; typedef ublas::symmetric_matrix symmetric_type; // all dimensions must be equal assert( x.size() == b.size() ); assert( A.size1() == x.size() ); // create matrix, only 0.5N^2 memory will be used. // add the small value /lambda to the diagonal of the work matrix symmetric_type symm_work( A + lambda * L ); // the rhs (right-hand-side) matrix has to be at least as large as the number of columns in H, because the // result of lapack::gelsd will be placed there. Therefore, rhs has to be as "tall" as the // weight vector matrix_type B( x.size(), 1 ); ublas::matrix_column B_col( B, 0 ); B_col.assign( b ); // perform the actual least squares (or least norm) fit lapack::ppsv( symm_work, B ); // copy the answer to the weight vector x.assign( B_col ); } template void generalised_least_squares( MatT const &A, MatT const &B, VecT const &c, VecT const &d, VecT &x ) { } /* old code: // create a view in the matrix (everything except the intercept), and copy the symmetric // kernel matrix into that. Also, create a vector view of the intercept term, and assign it 1's // (atlas::set does not work in this case) ublas::matrix_range H_part( H, ublas::range(0,H.size1()), ublas::range(1, H.size2()) ); ublas::matrix_column intercept( H, 0 ); H_part.assign( K ); std::fill( intercept.begin(), intercept.end(), 1.0 ); // the rhs (right-hand-side) matrix has to be at least as large as the number of columns in H, because the // result of lapack::gelsd will be placed there. Therefore, rhs has to be as "tall" as the // weight vector matrix_type rhs( weight_vector.size(), 1 ); ublas::matrix_column rhs_col(rhs, 0); ublas::vector_range > rhs_view( rhs_col, ublas::range(0, targets.size()) ); rhs_view.assign( targets ); // perform the actual least squares fit lapack::gelsd( H, rhs ); // copy the answer to the weight vector weight_vector.assign( rhs_col ); */ #endif kml_src/kml/linear.hpp000644 000765 000024 00000014116 10732422760 015714 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef LINEAR_HPP #define LINEAR_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace mpl = boost::mpl; /*! Linear kernel Template metaprogramming is used to make one generic function work on both scalar and vector types. \todo - ensure the atlas-specific implementation is not deployed on non-supported types */ namespace kml { namespace detail { class scalar_inner_prod { public: template static T compute( T const &x, T const &y ) { return (x * y); } }; class vector_inner_prod { public: template static typename boost::range_value::type compute( T const &u, T const &v ) { return atlas::dot( u, v ); } }; template class power_even { public: template static typename boost::range_value::type compute( T const &x ) { return std::pow( inner_product(x,x), N>>1 ); } }; template class power_uneven { public: template static T compute( T const &x ) { return power_even::compute(x) * x; } }; } // namespace detail /*! \brief Linear kernel \param T defines the argument type The linear kernel is the basic Eucledian inner product. */ template struct linear: public std::binary_function::type> { /*! Refinement of AdaptableBinaryFunction */ typedef T first_argument_type; typedef T second_argument_type; typedef typename input_value::type result_type; /*! Refinement of Kernel ? */ typedef linear type; typedef typename input_value::type scalar_type; friend class boost::serialization::access; /*! Refinement of DefaultConstructible */ linear() {} /*! Refinement of CopyConstructible */ linear( type const &other ) {} /*! Refinement of Assignable */ type &operator=( type const &other ) { return *this; } /*! Kernel constructor by providing TokenIterators */ template linear( TokenIterator const begin, TokenIterator const end ) {} /*! Returns the result of the evaluation of a linear kernel on two input patters of type T \param u input pattern u \param v input pattern v \return u^T v */ inline scalar_type operator()( T const &u, T const &v ) const { return mpl::if_, detail::scalar_inner_prod, detail::vector_inner_prod >::type::compute( u, v ); } // loading and saving capabilities // basically a dummy; we don't need to load or save anything template void serialize( Archive &archive, unsigned int const version ) {} // for debugging purposes friend std::ostream& operator<<(std::ostream &os, type const &) { os << "Linear kernel (u^T * v)" << std::endl; return os; } }; template struct power_return_type: mpl::eval_if< mpl::is_even< mpl::int_ >, boost::range_value, mpl::identity > {} ; template typename power_return_type::type power( Vector const &x ) { return mpl::if_< mpl::is_even< mpl::int_ >, detail::power_even, detail::power_uneven >::type::compute( x ); } /* Define templates is_linear so we can recognise the linear kernel in use when we need to, e.g. in ranking SVMs */ /* I think this is not the right way to go about it; read Josuttis at home */ template struct is_linear : boost::mpl::bool_ {}; template struct is_linear > : boost::mpl::bool_ {}; } // namespace kml namespace boost { namespace serialization { template struct tracking_level< kml::linear > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost #endif kml_src/kml/m_tree.hpp000644 000765 000024 00000037640 10732423626 015726 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef KML_M_TREE_HPP #define KML_M_TREE_HPP //#include // for now, consider Eucledian distance #include #include /*! M-tree: An Efficient Access Method for Similarity Search in Metric Spaces Two types of entities are used: Nodes and object. Two types of nodes: - leaf nodes: store all indexed object, either the key or the features of the data - internal nodes: store so-called routing object. It has an associated pointer to the root of a subtree called the covering tree of the routing object. It also keeps a covering radius, and the distance and pointer to its parent node. In other words: Lead nodes keep the vast majority of object in the tree, whereas the internal nodes keep one single object for routing reasons. Split strategy that I will use: Gonzales' algorithm The m_tree is capable of doing the following: It maps a key_value (that from the data container) to -# weight? in an edge? -# It also allows for a search given certain criteria. This m_tree keeps a reference to the container, so the lifetime of the container must be the same to that of this tree. --> good doc http://www.boost.org/libs/graph/doc/bundles.html // distance to parent? \section References -# M-tree: An Efficient Access Method for Similarity Search in Metric Spaces -# Revisiting the M-tree -# The Slim-Tree -# The PM-tree -# The Anchor's Hierarchy */ #include #include #include #include #include #include #include #include #include #include namespace kml { template class m_tree { public: typedef PropertyMap map_type; typedef m_tree this_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; // define the node structure struct node { // clear the radius on construction node(): radius(0) {} // the distance to some other points could very well be 0 // so, either the sorting on the object (close-by to far-away) should be // done by excluding the centroid, or a separate entry to the centroid // should be kept. key_type centroid; // type should be deducted somehow! (value_type of the object_type? // -- no -- depends on kernel on object_type::input_type double radius; // == distance( centroid, object.back ) // sorted on distance to the centroid! // vector actually is a good model for this storage: becuase it is sorted, a very fast split will // be possible. typedef typename std::vector::iterator object_iter; typedef typename std::vector object_container; std::vector object; }; // internal tree representation // TODO ajust the adjacency_list ... typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS, node > graph_type; typedef typename boost::graph_traits< graph_type >::vertex_iterator vertex_iter; typedef typename boost::graph_traits< graph_type >::out_edge_iterator out_edge_iter; typedef typename boost::graph_traits< graph_type >::vertex_descriptor vertex_descriptor; struct closer_by: std::unary_function< key_type const&, bool > { closer_by( key_type const &c1, key_type const &c2, PropertyMap *p_map ): centroid_1(c1), centroid_2(c2), map(p_map) {} bool operator()( key_type const &key ) { return distance_square( (*map)[key], (*map)[ centroid_1 ] ) < distance_square( (*map)[key], (*map)[ centroid_2 ] ); } key_type centroid_1, centroid_2; PropertyMap *map; }; //typedef tree > tree_type; //typedef typename tree >::iterator tree_iterator_type; m_tree( map_type map ): pattern_map(map) { // keep a reference to the property map std::cout << "m_tree constructor called..." << std::endl; std::cout << "Creating the (first) root node ... " << std::endl; root = boost::add_vertex( m_graph ); } void insert( key_type const &key ) { std::cout << "inserting key " << key << " into the M-tree... " << std::endl; std::cout << "data at key " << key << " is " << pattern_map[ key ] << std::endl; // should look for the most appropriate node to put this point in std::cout << "Looking for possible node to insert this object..." << std::endl; vertex_descriptor result = single_way( root, key ); // suppose we get returned the new vertex... if ( result != root ) { std::cout << "creating a new root node..." << std::endl; vertex_descriptor old_root = root; root = boost::add_vertex( m_graph ); std::cout << "creating edge " << root << "->" << old_root << std::endl; std::cout << "creating edge " << root << "->" << result << std::endl; boost::add_edge( root, old_root, m_graph ); boost::add_edge( root, result, m_graph ); } print_vertices(); } // greedy search to nearest centroid: to a depth-first search to the centroids closest by // see Revisiting M-tree ... /*! This is the original way of inserting an object into the M-tree. - TODO Minimise the increase in covering radius - DONE Choose the centroid clostest by, and descend the tree (greedy search) in M-tree momenclature, routing object equals centroid of the child!! but I don't want a vector of centroids of the childs. I store a radius one level lower than in the original paper for the same reasons no bookkeeping of the radius until the tree has more than 1 node? root node does not have a centroid! * use the BGL properly: use a visitor class * first, a down pass (single way), to find the leaf node where to put the object in (use a predecessor recorder) * then, an upward pass (using the predecessor recordings) to update the tree. * of course, i.e., the centroid of a node _is_ the node's location (was the same in the recursive gonzales) * so indeed: a inner node has a centroid: but that centroid is a centroid of a node. * all objects are in the ground level. * n-ary tree? ... */ // see section 3.3, at the insert pseudo-code vertex_descriptor single_way( vertex_descriptor const &node, key_type const &key ) { // if N is not a leaf then if ( boost::out_degree( node, m_graph ) > 0 ) { // do we have child nodes _in which_ this node could reside? // NO, we do not have child nodes _in which_ this node could reside. // Choose the one with minimum radius // Adjust radius of child node // there are child nodes, visit these if possible double min_dist = 1e99; vertex_descriptor min_node; typedef typename boost::graph_traits< graph_type >::adjacency_iterator adj_iter; for( std::pair child = boost::adjacent_vertices(node, m_graph); child.first != child.second; ++child.first ) { std::cout << "processing a child node... " << std::endl; double dist2node = distance_square( pattern_map[key], pattern_map[ m_graph[ *child.first ].centroid ] ); std::cout << "distance: " << dist2node << std::endl; if ( dist2node < min_dist) { min_dist = dist2node; min_node = *child.first; } } vertex_descriptor result = single_way( min_node, key ); std::cout << "returned from recursive call.." << std::endl; if ( result == min_node ) // nothing happened return node; else { // tie this new node to the current node. (no inner node splits yet) // overflow on node level right here! std::cout << "creating edge " << node << "->" << result << std::endl; boost::add_edge( node, result, m_graph ); if( boost::out_degree( node, m_graph ) > 2 ) { split_inner_node( node ); } return node; } } else { std::cout << "At a leaf node, inserting object..." << std::endl; m_graph[ node ].object.push_back( key ); std::cout << "# of keys in node: " << m_graph[ node ].object.size() << std::endl; if ( m_graph[ node ].object.size() > 5 ) return split_ground_node( node ); else return node; } } vertex_descriptor nearest_centroid( vertex_descriptor const &node, key_type const &key, double &min_dist ) { std::cout << "dist2centroid " << distance_square( pattern_map[key], pattern_map[ m_graph[ node ].centroid ] ) << std::endl; std::cout << "min_dist: " << min_dist << std::endl; if ( boost::out_degree( node, m_graph ) > 0 ) { // there are child nodes, visit these if possible typedef typename boost::graph_traits< graph_type >::adjacency_iterator adj_iter; for( std::pair child = boost::adjacent_vertices(node, m_graph); child.first != child.second; ++child.first ) { std::cout << "processing a child node... " << std::endl; // check a few conditions... // is this node within the radius of this node, or doesn't that matter? // no, should not matter. // expected minimum distance can be computed! ... ( dsitance - radius ) std::cout << "visiting " << *child.first << std::endl; nearest_centroid( *child.first, key, min_dist ); } } // else { double dist = distance_square( pattern_map[key], pattern_map[ m_graph[ node ].centroid ] ); return node; //} } void add_to_node( vertex_descriptor const &node, key_type const &key ) { } // the split procedure, works bottom-up, starting at node vertex_descriptor split_ground_node( vertex_descriptor const &node ) { // ---> the centroid of "node", if it had one, will be ignored // alright, a new node will be added to the tree. // split the current node std::cout << "split algorithm called. " << std::endl; // the object which has the _largest_ distance to the centroid will become the new centroid of the new node. // enhancements later on... now, just pick the last point and promote that to a node vertex_descriptor new_node = boost::add_vertex( m_graph ); std::cout << "created a new vertex..." << new_node << std::endl; // perform 2-center... // should be an algorithm chosen for simplicity. // pick a "random" 1st center. typename node::object_iter i( m_graph[node].object.begin() ); key_type centroid_1 = *i++; key_type centroid_2 = *i++; two_center( centroid_1, centroid_2 ); double max_dist = distance_square( pattern_map[centroid_1], pattern_map[centroid_2] ); // can also be 2 aribtrarily random points! // search for the point furthest away for( ; i != m_graph[node].object.end(); ++i ) { double dist = distance_square( pattern_map[centroid_1], pattern_map[ *i ] ); std::cout << "distance to point: " << dist << std::endl; if ( dist > max_dist ) { max_dist = dist; centroid_2 = *i; } } // TODO // try to iteratively improve these found centroids ... // TODO // right now, it is 0 1 2 centroid 0, but centroid 1 and 4 are better // 3 4 5 centroid 5 // partition the objects based on these centroids (rather efficient!) // first..middle belongs to centroid_1, and middle..end belongs to centroid 2 // TODO use a functor to store the radii of the nodes. typename node::object_iter middle = std::partition( m_graph[node].object.begin(), m_graph[node].object.end(), closer_by(centroid_1,centroid_2,pattern_map) ); //boost::bind( &this_type::closer_by,boost::ref(*this),centroid_1,centroid_2,_1) ); // move the appropriate objects to the other node std::copy( middle, m_graph[node].object.end(), std::back_inserter( m_graph[new_node].object ) ); m_graph[node].object.erase( middle, m_graph[node].object.end() ); std::cout << "Centroid 1 " << centroid_1 << std::endl; std::cout << "Centroid 2 " << centroid_2 << std::endl; // assign centroids m_graph[ node ].centroid = centroid_1; m_graph[ new_node ].centroid = centroid_2; return new_node; } void two_center( key_type const &begin, key_type const &end ) { // TODO put in tree global memory // for splits at 6 boost::uniform_int<> int_dist(0,5); boost::variate_generator< boost::mt19937&,boost::uniform_int<> > node_picker(rng,int_dist); // pick a center at random unsigned int nr = node_picker(); std::cout << "Picked centroid 1 to be " << nr << std::endl; //std::partition( begin, end, closer_by( )); } void split_inner_node( vertex_descriptor const &node ) { std::cout << "Split inner node called.." << std::endl; // so, this is about the out-edges... vertex_descriptor new_node = boost::add_vertex( m_graph ); std::cout << "created a new vertex..." << new_node << std::endl; // just pick 2 edges ... to be improved std::pair edges = boost::out_edges( node, m_graph ); key_type centroid_1 = m_graph[boost::target(*edges.first,m_graph)].centroid; key_type centroid_2 = m_graph[boost::target(*(edges.second-1),m_graph)].centroid; std::cout << "centroid 1 is " << centroid_1 << std::endl; std::cout << "centroid 2 is " << centroid_2 << std::endl; // alright, now split the nodes to these centroids //out_edge_iter middle = std::partition( edges.first, edges.second, // closer_by(centroid_1,centroid_2,pattern_map) ); } void erase( key_type const &key ) { std::cout << "removing key " << key << " from the m-tree..." << std::endl; } void print_vertices() { // TODO use a DFS visitor std::cout << std::endl << "Tree configuration:" << std::endl << std::endl; std::cout << " root: " << root << std::endl; std::pair vp; for( vp = boost::vertices(m_graph); vp.first != vp.second; ++vp.first ) { std::cout << "-- id: " << *vp.first << std::endl; std::cout << " centroid: " << m_graph[*vp.first].centroid << std::endl; std::cout << " radius: " << m_graph[*vp.first].radius << std::endl; std::cout << " objects: "; std::copy( m_graph[*vp.first].object.begin(), m_graph[*vp.first].object.end(), std::ostream_iterator(std::cout, " ") ); std::cout << std::endl; } boost::print_graph( m_graph ); } void slim_down() { // perhaps local_iterative_improvement is a better name. Or something like that. // this is equal to the algorithm for k-means, but then applied for // k-center. However, an improvement is only an improvement if _BOTH_ // radii decrease (i.e. not min_max). } // The (tree) graph structure, and the iterator of the root node. graph_type m_graph; vertex_descriptor root; // pattern_map PropertyMap pattern_map; // a random number generator boost::mt19937 rng; }; } //namespace kml #endif kml_src/kml/matrix_view.hpp000644 000765 000024 00000032152 10513642232 016773 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef MATRIX_VIEW_HPP #define MATRIX_VIEW_HPP #include #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace atlas = ::boost::numeric::bindings::atlas; namespace kml { /*! \brief A view of a dense matrix. \param M underlying dense matrix class This class provides a view in a dense matrix, and performs efficient memory management by cutting down the number of calls to .resize() of the underlying matrix. If we consider a matrix that grows by one row or column at a time, a naive resize strategy would cost O(N) memory allocation calls. It will become quadratically more expensive to copy the content of the matrix as it grows in size. Because of this, memory management is done in a similar way as that of std::vector. If needed, the size of the underlying matrix is doubled in the number of rows or in the number of columns. This takes O(log N) memory allocation calls only, delivering a considerable speedup over the naive approach. It is assumed matrix view changes by 1 row or 1 column (or both) at a time, for which member functions are available. It can be directly used in conjunction with calls to atlas bindings, as shown below. \code kml::matrix_view< ublas::matrix > A; // view in matrix A ublas::vector x; // vector x ublas::vector b; // result vector b atlas::gemv( A.view(), x, b ); // compute b <- Ax \endcode */ template class matrix_view { public: friend class boost::serialization::access; typedef ublas::vector vector_type; typedef M matrix_type; typedef typename M::size_type size_type; matrix_view() { // 1 by 1, for fast growth determination later on (i.e. use size * 2) matrix.resize(1,1,false); view_rows=0; view_cols=0; } unsigned int find_pow2_neighbour( unsigned int n ) { unsigned int answer = 1; while ( n > 0 ) { answer <<= 1; n >>= 1; } return answer; } // if you have some pre-knowledge, or want to pre-reserve memory // does not preserve the matrix!! void reserve( size_type rows, size_type cols ) { view_rows = rows; view_cols = cols; matrix.resize( find_pow2_neighbour(rows), find_pow2_neighbour(cols), false ); } /*! Increase the number of columns in the matrix view by one. */ void grow_column() { if ( view_cols == matrix.size2() ) matrix.resize( matrix.size1(), matrix.size2() << 1 ); ++view_cols; } void shrink_column() { --view_cols; } void grow_row() { if ( view_rows == matrix.size1() ) matrix.resize( matrix.size1() << 1, matrix.size2() ); ++view_rows; } void shrink_row() { --view_rows; } void grow_row_column() { if ( view_rows == matrix.size1() ) matrix.resize( matrix.size1() << 1, matrix.size2() << 1 ); ++view_rows; ++view_cols; } /*! Remove a column from the current matrix view at a given column index. \param index the n'th column, first column is located at 0. This operation preserves the order of columns, which means that all columns to the right of the column at index will have to be moved to the left. This is not the most efficient strategy in removing a column, it will cost O(0.5NM) on average. */ void remove_column( int index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); for( int i=index; i<(view_cols-1); ++i ) { ublas::matrix_column< ublas::matrix_range > cur_col( matrix_view, i); ublas::matrix_column< ublas::matrix_range > next_col( matrix_view, i+1); atlas::copy( next_col, cur_col ); } --view_cols; } /*! Remove a column from the current matrix view at a given column index. \param index the n'th column, first column is located at 0. The last column will be swapped with the column at index, after which the size of the view of the matrix will be reduced by 1 column. This is the most efficient way of removing a column from a dense matrix, it costs O(M). */ void swap_remove_column( size_type index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); ublas::matrix_column< ublas::matrix_range > last_col( matrix_view, view_cols-1); ublas::matrix_column< ublas::matrix_range > index_col( matrix_view, index ); atlas::copy( last_col, index_col ); --view_cols; } /*! Remove a row from the current matrix view at a given row index. \param index the m'th row, first row is located at 0. This operation preserves the order of rows, so all rows have to be moved upwards. This is not the most efficient strategy in removing a row, with cost of O(0.5NM) on average. */ void remove_row( int index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); for( int i=index; i<(view_rows-1); ++i ) { ublas::row(matrix_view,i).assign( ublas::row(matrix_view,i+1)); } --view_rows; } /*! Remove a row from the current matrix view at a given row index. \param index the n'th row, first row is located at 0. The last row will be swapped with the row at index, after which the size of the view of the matrix will be reduced by one row. It costs O(N). */ void swap_remove_row( int index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); ublas::matrix_row< ublas::matrix_range > last_row( matrix_view, view_rows-1); ublas::matrix_row< ublas::matrix_range > index_row( matrix_view, index); atlas::copy( last_row, index_row ); --view_rows; } void swap_row( int index1, int index2 ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); ublas::matrix_row< ublas::matrix_range > index1_row( matrix_view, index1 ); ublas::matrix_row< ublas::matrix_range > index2_row( matrix_view, index2 ); atlas::swap( index1_row, index2_row ); } void remove_row_col( int index ) { remove_column(index); remove_row(index); } // work for: row_major matrix with a symmetric view adaptor (row major as well) // warning: sensitive code void swap_remove_row_col( int index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); int index_last = view_rows-1; // perhaps this is an overkill for 1 atlas-op. // perhaps can be done with 2 matrix vector slices? ublas::matrix_row< ublas::matrix_range > last_row( matrix_view, index_last ); ublas::matrix_row< ublas::matrix_range > index_row( matrix_view, index ); ublas::vector_range< ublas::matrix_row< ublas::matrix_range > > last_row_part_1( last_row, ublas::range(0,index) ); ublas::vector_range< ublas::matrix_row< ublas::matrix_range > > index_row_part_1( index_row, ublas::range(0,index) ); atlas::copy( last_row_part_1, index_row_part_1 ); // and a difficult element copy, in same direction. can be atlasified // note that index_last is one less than the matrix size for( int i=index+1; i index,index matrix( index, index ) = matrix( index_last, index_last ); --view_rows; --view_cols; } void flush() { matrix.resize( view_rows, view_cols, true ); } size_type const size1() const { return view_rows; } size_type const size2() const { return view_cols; } inline ublas::matrix_range const view() { return ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); } // also provide shrinked views: this is very useful for the inverted matrix updates // i.e. the matrix is resized first, and then an algorithm computes the updated inverse inline ublas::matrix_range const shrinked_view() const { return ublas::matrix_range(matrix, ublas::range(0,view_rows-1),ublas::range(0,view_cols-1)); } // also provide a shrunken column view (view_rows x view_cols-1) inline ublas::matrix_range const shrinked_column_view() const { return ublas::matrix_range(matrix,ublas::range(0,view_rows),ublas::range(0,view_cols-1)); } inline ublas::matrix_vector_slice const row( int nr ) { return ublas::matrix_vector_slice( matrix, ublas::slice( nr, 0, view_cols ), ublas::slice( 0, 1, view_cols ) ); } // inline ublas::matrix_row< ublas::matrix_range > const row( int nr ) { // return ublas::row( ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)), nr ); // } inline ublas::matrix_row< ublas::matrix_range > const shrinked_row( int nr ) { return ublas::row( ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols-1)), nr ); } inline ublas::matrix_column< ublas::matrix_range > const column( int nr ) { return ublas::column( ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)), nr ); } inline ublas::matrix_column< ublas::matrix_range > const shrinked_column( int nr ) { return ublas::column( ublas::matrix_range(matrix, ublas::range(0,view_rows-1),ublas::range(0,view_cols)), nr ); } // loading and saving capabilities template void save( Archive &archive, unsigned int const version ) const { // make a copy of the view and save that part only M matrix_copy( ublas::subrange(matrix, 0, view_rows, 0, view_cols )); archive << matrix_copy; } template void load( Archive &archive, unsigned int const version ) { // restore the copy of the view archive >> matrix; // store the view size view_rows = matrix.size1(); view_cols = matrix.size2(); // find the value of the MSB of the view_rows, that multiplied by 2 should equal pow2_rows unsigned int find_pow2_rows = view_rows; unsigned int pow2_rows = 1; while( find_pow2_rows > 0 ) { find_pow2_rows >>= 1; pow2_rows <<= 1; } // find the value of the MSB of the view_cols, that multiplied by 2 should equal pow2_cols unsigned int find_pow2_cols = view_cols; unsigned int pow2_cols = 1; while( find_pow2_cols > 0 ) { find_pow2_cols >>= 1; pow2_cols <<= 1; } // (preserved) resize of the matrix to sizes that are powers of 2 matrix.resize( pow2_rows, pow2_cols, true ); } // a convenience macro to auto-create the serialize() member function BOOST_SERIALIZATION_SPLIT_MEMBER() // internal memory is a (dense) UBLAS matrix M matrix; private: size_type view_rows; size_type view_cols; }; } // namespace kml namespace boost { namespace serialization { template struct tracking_level< kml::matrix_view > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } } #endif kml_src/kml/newton.hpp000644 000765 000024 00000010577 10377266147 015775 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef NEWTON_HPP #define NEWTON_HPP #include #include template class newton: public std::unary_function { public: newton( UnaryOp1 f, UnaryOp2 Df ): function(boost::cref(f)), derivative_function(boost::cref(Df)) {} typedef typename boost::range_value::type scalar_type; Point operator()(Point const &x0) { //std::cout << "finding root for " << x0; Point root(x0); Point step(x0.size()); for( int i=0; i std::numeric_limits::epsilon()) ) { // && (std::fabs(derivative_function.get()(root)) > 1e-3) ) { // std::cout << "step*step " << kml::inner_product( step,step) << std::endl; // std::cout << "root: " << root << std::endl; // std::cout << "f(root): " << function.get()(root) << std::endl; // std::cout << "Df(root): " << derivative_function.get()(root) << std::endl; step = (1.0 / derivative_function.get()(root)) * function.get()(root); root -= step; //double func_1 = 1.0 / f(root); //double func_2 = derivative_function.get()(root); //root -= function.get()(root); } // int qq; // std::cin >> qq; std::cout << " --> root found: " << root << std::endl; return root; } boost::reference_wrapper function; boost::reference_wrapper derivative_function; }; template class newton_uneven: public std::unary_function { public: newton_uneven( UnaryOp1 f, UnaryOp2 Df ): function(boost::cref(f)), derivative_function(boost::cref(Df)) {} typedef typename boost::range_value::type scalar_type; Point operator()(Point const &x0) { //std::cout << "finding root for " << x0; Point root(x0); Point step(2); step(0) = 1.0; step(1) = 1.0; while( (kml::inner_product( step,step) > std::numeric_limits::epsilon()) ) { // && (std::fabs(derivative_function.get()(root)) > 1e-3) ) { // std::cout << "root: " << root << std::endl; // std::cout << "f(root): " << function.get()(root) << std::endl; // std::cout << "Df(root): " << derivative_function.get()(root) << std::endl; step = derivative_function.get()(root); // for( int i=0; i<2; ++i) step[i] = 1.0 / step[i]; root -= function.get()(root) * step; //double func_1 = 1.0 / f(root); //double func_2 = derivative_function.get()(root); //root -= function.get()(root); } // int qq; // std::cin >> qq; std::cout << " --> root found: " << root << std::endl; return root; } boost::reference_wrapper function; boost::reference_wrapper derivative_function; }; #endif kml_src/kml/old_rvm.hpp000644 000765 000024 00000022137 10377266147 016120 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef OLD_RVM_HPP #define OLD_RVM_HPP #include #include #include #include #include #include #include #include // TODO fix old and kludgy algorithms from kernels.h #include "kernels.h" // include AFTER enough traits have been included, of course... (?) #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace lapack = boost::numeric::bindings::lapack; /*! Classic RVM algorithm */ namespace kml { template class Kernel,class Enable = void> class old_rvm: public kernel_machine {}; template class Kernel> class old_rvm >::type>: public kernel_machine { public: typedef kernel_machine base_type; typedef typename base_type::kernel_type kernel_type; typedef typename base_type::result_type result_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef double scalar_type; typedef ublas::symmetric_matrix symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; /*! \param k the kernel construction parameter */ old_rvm( typename boost::call_traits::param_type k ): base_type(k) {} template void learn( IRange const &input, ORange const &output ) { // create the kernel matrix (symmetric part) // initialise & compute HtH, Hty matrix_type H; design_matrix( input, input, base_type::kernel, 1.0, H ); vector_type Hty( input.size()+1 ); atlas::gemv( CblasTrans, 1.0, H, output, 0.0, Hty ); symmetric_type HtH( H.size2(), H.size2() ); inner_prod( H, HtH ); // explanation of variables, following Tipping (1999) // theta = 1 / alpha std::vector indices( HtH.size1() ); // fill indices with 0,1,2,3,...,N-1. This is not in standard C++, but an SGI extension. iota( indices.begin(), indices.end(), 0 ); vector_type weight_vector( HtH.size1() ); vector_type theta( HtH.size2() ); // theta is 1/alpha, as in Ralf Herbrich's R implementation // since near-zero values are better defined than "very large" values atlas::set ( 1.0, theta ); atlas::set ( 1.0, weight_vector ); variance_estimate = 0.1; scalar_type max_diff = 1.0; // RVM's main loop while( max_diff > 1e-3 ) { // Prepare the not-yet-inverted part of matrix sigma, and // the non-multiplied part of vector mu // NOTE not this anymore, changed to more efficient formulation // see above // sigma_inv <- (HtH*(1/var)+A) (part of eq. 5) // mu <- Hty (part of eq. 6) ublas::symmetric_matrix sigma_inverted( indices.size(), indices.size() ); vector_type mu( indices.size() ); for( unsigned int i=0; i sigma( indices.size(), indices.size() ); // temporary workaround for boost non-compileness stuff. //ublas::matrix sigma( ublas::identity_matrix( indices.size() ) ); sigma.clear(); for( unsigned int i=0; i > sigma_symm( sigma ); lapack::ppsv( sigma_inverted, sigma ); // FIXME weird behaviour of atlas when doing this multiply with 2 mu's in there // TODO just multiply with the right part of Hty; do not copy this to mu first // TODO atlas-ify //atlas::gemv( sigma, mu, mu ); mu = ublas::prod( sigma, mu ); // update theta vector // compute sum_i gamma_i scalar_type gamma_summed = static_cast(0); max_diff = static_cast(0); for( unsigned int i=0; i max_diff ) max_diff=diff; } // std::cout << "vector gamma: " << gamma << std::endl; // std::cout << "vector theta: " << theta << std::endl; variance_estimate = residual_sum_squares( H, weight_vector, indices, output ) / (static_cast(output.size()) - gamma_summed ); // prune support vectors on the basis of the theta vector prune_indices( indices, theta ); } if (debug ) { std::cout << "Relevance Vector Machine (Tipping, 1999)" << std::endl; std::cout << "support vectors: "; std::copy( indices.begin(), indices.end(), std::ostream_iterator(std::cout, " ") ); std::cout << std::endl; std::cout << "variance estimate: " << variance_estimate << std::endl; std::cout << std::endl; } // std::cout << "weights: " << std::endl; // for( unsigned int i=0; i> qq; } public: static const bool debug = false; // locally stored scalar_type variance_estimate; }; } // namespace kml #endif kml_src/kml/online_gp.hpp000644 000765 000024 00000023341 10457437640 016423 0ustar00pawelmstaff000000 000000 /*************************************************************************** * Sparse Online Gaussian Processes * * Part of the Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef KML_ONLINE_GP_HPP #define KML_ONLINE_GP_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace mpl = boost::mpl; namespace kml { /* Description References Csató and Opper, 2002, Sparse Online Gaussian Processes NOTE: the implementation is not finished yet, and may be subject to numerous changes. ----------------------------- symbol translation guide ----------------------------- here paper(s), website matlab code weight alpha net.w k_tt k^star_{t+1} kk k_t k_t kX delta_t gamma_{t+1}, q^star gamma a_t \hat{e}_{t+1} hatE s_t s_{t+1} tVector R K^inv_t; Q_t net.KBinv C C net.C .D1() q^{t+1} K1 .D2() r^{t+1} K2 */ class gaussian_noise { public: void operator()( double y, double f_y, double cov_t ) { m_d2 = -1.0 / cov_t; m_d1 = (y - f_y) / cov_t; } double D1() { return m_d1; } double D2() { return m_d2; } private: double m_d1; double m_d2; }; /* On-line Gaussian Processes. */ template< typename Problem, typename Kernel, typename PropertyMap, class Enable = void> class online_gp: public kernel_machine {}; // // // REGRESSION ALGORITHM // // template< typename Problem, typename Kernel, typename PropertyMap > class online_gp< Problem, Kernel, PropertyMap, typename boost::enable_if< is_regression >::type>: public kernel_machine< Problem, Kernel, PropertyMap > { public: typedef kernel_machine< Problem, Kernel, PropertyMap > base_type; typedef typename base_type::kernel_type kernel_type; typedef typename base_type::result_type result_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef double scalar_type; typedef boost::tuple tuple_type; typedef symmetric_view< ublas::matrix > symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; //friend class boost::serialization::access; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; online_gp( scalar_type const tol, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map), tolerance(tol) {} two_moments operator()( input_type const &x ) { vector_type temp_K( basis_key.size() ); fill_kernel( x, basis_key.begin(), basis_key.end(), temp_K.begin() ); ublas::matrix_range< ublas::matrix > C_range( C.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > C_view( C_range ); vector_type temp_vector( basis_key.size() ); atlas::symv( C_view, temp_K, temp_vector ); // noise is model dependent return two_moments( atlas::dot( weight, temp_K ), atlas::dot( temp_vector, temp_K ) + kernel( x, x ) + variance_estimate ); } template< typename KeyIterator > void learn( KeyIterator begin, KeyIterator end ) { KeyIterator iter(begin); while( iter != end ) { increment( *iter++ ); } } void increment( key_type const &key ) { variance_estimate = sqrt(0.2); // calculate the base_type::kernel function on (x_t,x_t), needed later on scalar_type k_tt = kernel( key, key ); // fill vector k_t k_t.resize( basis_key.size() ); fill_kernel( key, basis_key.begin(), basis_key.end(), k_t.begin() ); // a_t <- R %*% k_t // this version of symv overwrites everything in a_t a_t.resize( basis_key.size() ); ublas::matrix_range< ublas::matrix > R_range( R.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_view( R_range ); atlas::symv( R_view, k_t, a_t ); // s_t <- C %*% k_t (will be further updated according to code path) // this version of symv overwrites everything in s_t ublas::matrix_range< ublas::matrix > C_range( C.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > C_view( C_range ); atlas::symv( C_view, k_t, s_t ); // update the first and second order derivatives of the loglikelihood // sigma_0: ?? // Gaussian case: see above Equation 31, page 9 // sigma_0 = prior variance estimate (?) ... scalar_type cov_t = variance_estimate + k_tt + atlas::dot( k_t, s_t ); // TODO -- make this noise-model dependent likelihood( output(key), atlas::dot( k_t, weight ), cov_t ); // delta_t <- k_tt - k_t %*% K %*% k_t == k_tt - k_t %*% a_t (see Equation 23) scalar_type delta_t = k_tt - atlas::dot( k_t, a_t ); // Perform Approximate Linear Dependency (ALD) test // If the ALD is larger than some previously set tolerance, add the input to // the dictionary (or basis vector set) if ( delta_t > tolerance ) { // add x_t to support vector set, adjust all needed variables std::size_t old_size( basis_key.size() ); // update matrix C; Equation 9, middle equation atlas::syr( likelihood.D2(), s_t, C_view ); C.grow_row_column(); ublas::matrix_vector_slice< ublas::matrix > C_row_part( C.shrinked_row(old_size) ); atlas::scal( likelihood.D2(), s_t ); atlas::copy( s_t, C_row_part ); C.matrix( old_size, old_size ) = likelihood.D2(); // update inverse matrix R; Appendix D scalar_type factor = static_cast(1) / delta_t; atlas::syr( factor, a_t, R_view ); R.grow_row_column(); ublas::matrix_vector_slice< ublas::matrix > R_row_part( R.shrinked_row(old_size) ); atlas::scal( -factor, a_t ); atlas::copy( a_t, R_row_part ); R.matrix( old_size, old_size ) = factor; // further estimate s_t; Equation 9, bottom equation s_t.push_back( 1.0 ); // adjust the weight vector; Equation 9, top equation weight.push_back( 0.0 ); atlas::axpy( likelihood.D1(), s_t, weight ); // add this key to the basis vector set basis_key.push_back( key ); } else { // further estimate s_t; Equations 11, 16 atlas::xpy( a_t, s_t ); // compute the scalar eta_{t+1} double eta = 1.0 / ( 1.0 + delta_t * likelihood.D2() ); // adjust weight vector; Equation 88, thesis, top equation atlas::axpy( likelihood.D1() * eta, s_t, weight ); // update permutation matrix (equation 14) atlas::syr( likelihood.D2() * eta, s_t, C_view ); } } // increment method // these are the parameters gaussian_noise likelihood; scalar_type tolerance; // the ALD tolerance parameter scalar_type variance_estimate; // the variance estimate symmetric_type R; // this is the inverse of the {gram/kernel} matrix symmetric_type C; // this is the C matrix std::vector< scalar_type > k_t; // a vector with evaluated kernel values for each basis vector std::vector< scalar_type > a_t; // a_t <- K %*% k_t std::vector< scalar_type > s_t; // depends on reestimate or add_to_basis; s_t <- C %*% k_t + "depends" std::vector< key_type > basis_key; // a vector containing basis vector keys std::vector< scalar_type > weight; // weights associated with the basis vectors }; } // namespace kml #endif kml_src/kml/online_greedy_svm.hpp000644 000765 000024 00000021156 10377266147 020166 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef ONLINE_GREEDY_SVM_HPP #define ONLINE_GREEDY_SVM_HPP #include #include namespace kml { /*! \brief Sparse On-line Greedy Support Vector Regression \param I the input type \param O the output type \param K the kernel type A preprocessing step is taken to absorb the bias term into the weight vector w, by redefining w as (w^T, b)^T and phi as (phi^T,1)^T. For details, see Engel et al, Sparse Online Greedy Support Vector Regression, below on page 3: k(x,x')=k(x,x') + lambda^2, where lambda is a small, positive constant. changes to algorithm: - removed gamma from the algorithm, and introduced the matrix inversion from KRLS - weight is defined as alpha_star - alpha \todo - online greedy SVM classifier - Optimal values of nu, nu_star can be analytically derived? \section bibliography References -# Yaakov Engel, Shie Mannor, and Ron Meir. Sparse On-line Greedy Support Vector Regression (SOG-SVR). European Conference on Machine Learning (ECML) 2002, pages 84--96. */ template class K> class online_greedy_svm: public online_greedy_determinate { typedef online_greedy_determinate base_type; typedef typename base_type::kernel_type kernel_type; typedef double scalar_type; typedef ublas::symmetric_matrix symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; typedef I input_type; typedef O output_type; public: /*! \param k the kernel construction parameter \param param_eps parameter epsilon (width of the regression tube in SVM regression) \param param_C parameter C (the maximum weight per support vector) \param n parameter nu, used by the approximate linear dependency test to check whether or not to add a new pattern to the support vector set. Smaller values means more support vectors. \param l parameter lambda. This is the constant added to each kernel function to mimick the bias term */ online_greedy_svm( typename boost::call_traits::param_type k, scalar_type param_eps=0.1, scalar_type param_C=10.0, scalar_type n=1e-1, scalar_type l=1e-3 ): base_type(k), epsilon(param_eps), C(param_C), nu(n), lambda_squared(l*l) { // for now, set etas to 0.01 eta = 1e-2; eta_star = 1e-2; } /*! \param x_t an input pattern \param y_t an output pattern */ void push_back( vector_type const &x_t, scalar_type const &y_t ) { // calculate the base_type::kernel function on (x_t,x_t), needed later on scalar_type k_tt = base_type::kernel( x_t, x_t ) + lambda_squared; // check if init is needed if (base_type::support_vector.size() == 0) { base_type::weight.push_back( y_t / k_tt ); base_type::support_vector.push_back( x_t ); H.resize(1); R.resize(1); H(0,0) = k_tt; R(0,0) = static_cast(1) / k_tt; AtA.resize(1); AtA(0,0) = static_cast(1); Ate.resize(1); Ate(0) = static_cast(1); Aty.resize(1); Aty(0) = y_t; } else { vector_type k_t( H.size1() ); vector_type a_t( H.size1() ); for( int i=0; i nu ) { unsigned int old_size = H.size1(); unsigned int new_size = old_size + 1; // update matrix H preserved_resize( H, new_size, new_size ); ublas::matrix_vector_slice H_row_part( H, ublas::slice(old_size,0,old_size), ublas::slice(0,1,old_size) ); H_row_part.assign( k_t ); H( old_size, old_size ) = k_tt; // update matrix R (code stolen from HRLS code) scalar_type factor = static_cast(1) / delta_t; atlas::spr( factor, a_t, R ); preserved_resize( R, new_size, new_size ); ublas::matrix_vector_slice R_row_part( R, ublas::slice(old_size,0,old_size), ublas::slice(0,1,old_size) ); atlas::scal( -factor, a_t ); R_row_part.assign( a_t ); R( old_size, old_size ) = factor; // update matrix AtA preserved_resize( AtA, new_size, new_size ); ublas::matrix_vector_slice AtA_row_part( AtA, ublas::slice(old_size,0,old_size), ublas::slice(0,1,old_size) ); //AtA_row_part.clear(); // FIXME TODO fast reset right here.. std::for_each( AtA_row_part.begin(), AtA_row_part.end(), _1 = 0.0 ); AtA(old_size,old_size) = 1.0; // FIXME // STL vectors? (ie use push_back) preserved_resize( Ate, new_size ); preserved_resize( Aty, new_size ); Ate( old_size ) = 1.0; Aty( old_size ) = y_t; base_type::weight.push_back( 0.0 ); // add support vector to the set, add 1 row base_type::support_vector.push_back( x_t ); } else { // dictionary remains unchanged atlas::xpy( a_t, Ate ); atlas::axpy( y_t, a_t, Aty ); atlas::spr( a_t, AtA ); } vector_type Atf( H.size1() ); vector_type work( H.size1() ); // Step 4. Update alpha and alpha_star // Atf = AtAH(alpha_star-alpha) atlas::spmv( H, base_type::weight, work ); atlas::spmv( AtA, work, Atf ); // Update alphas atlas::copy( Aty, work ); atlas::axpy( -1.0, Atf, work ); // update base_type::weight. Presume eta_star = eta, so the (-eta*+eta)epsilonAte=0, // which does not need to be computed then. atlas::axpy( eta_star + eta, work, base_type::weight ); // truncation function: u = max(-C,min(C,u)). (see end of section 4.2) for( unsigned int i=0; i(-C, std::min(C, base_type::weight[i])); } } // dictionary size > 0 } // void predict( matrix_type const &X, VecT &result ) { // matrix_type temp_H; // kernel_matrix( support_vectors, X, base_type::kernel, temp_H ); // if (base_type::kernel.order==0) { // for( int i = 0; i #include #include #include #include #include #include #include #include //#include #include #include #include #include #include #include #include #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace mpl = boost::mpl; namespace kml { /*! \brief On-line Support Vector Machine. \param Problem the problem type \param Kernel the kernel type Training a Support Vector Machine (SVM) normally requires solving a quadratic programming problem (QP) in a number of coefficients equal to the number of training examples. For very large data sets, QP methods become infeasible. Algorithms are available to do incremental and decremental support vector learning, for both classiciation and regression. Abilities: Incremental, decremental and update of a data set. See online determinate class description for specifics about memory requirements. Example code: \code kml::gaussian< ublas::vector > my_kernel( 1.6 ); kml::online_svm< ublas::vector, double, kml::gaussian > my_machine( my_kernel, 0.1, 10 ); my_machine.train( my_input, my_output ); \endcode In general, we have training input vectors x. In binary SVM classification, the optimal seperating function is given by \f$ f(x)=\sum_j \alpha_j y_j k(x_j,x) + b \f$ with labels \f$ y_i=\pm 1 \f$. In SVM regression, the function is similar, \f$ f(x)=\sum_j \alpha_j k(x_j,x) + b \f$. One of the differences between classification and regression algorithms is the composition of the matrix Q and R as referred to in [1-3], and hence the \e coefficient \e sensitivities and the \e margin \e sensitivities differ. Regression: \f$ Q_{ij}=k(x_i,x_j) \f$ Classification: \f$ Q_{ij}= y_i y_j k(x_i,x_j) \f$ \bug - Fix stability of the regression algorithm against noiseless data. At the moment, this is a largest instability issue. \todo - small: introduce a margin-star set, this prevents a test in the algorithm - fix documentation - removal of points from the actual set (decremental algorithm(s)) - updates of points in the actual set (update, use a different stopping criterion) \section bibliography References -# Junshui Ma et al., 2003. Accurate On-Line Support Vector Regression. \e Neural \e Computation, pp. 2700-2701. http://tinyurl.com/5g2bb -# Mario Martin, 2002. On-line Support Vector Machine for Function Approximation. Technical report LSI-02-11-R, Universitat Politecnica de Catalunya http://tinyurl.com/48y9n \ingroup kernel_machines */ template< typename Problem, typename Kernel, typename PropertyMap, class Enable = void> class online_svm: public kernel_machine {} ; // // // REGRESSION ALGORITHM // // template< typename Problem, typename Kernel, typename PropertyMap > class online_svm< Problem, Kernel, PropertyMap, typename boost::enable_if< is_regression >::type>: public kernel_machine< Problem, Kernel, PropertyMap > { public: typedef kernel_machine< Problem, Kernel, PropertyMap > base_type; typedef typename base_type::kernel_type kernel_type; typedef typename base_type::result_type result_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef double scalar_type; typedef ublas::symmetric_matrix symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; friend class boost::serialization::access; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; // Bug fixed: use call_traits instead of const&, so can be called with both reference and non-reference /*! \param k the kernel construction parameter \param tube_width the error-insensitive tube width, parameter \f$ \epsilon \f$ of Vapnik's e-insensitive loss function \param max_weight the maximum weight assigned to any support vector, support vector machine's parameter C */ online_svm( typename boost::call_traits::param_type max_weight, typename boost::call_traits::param_type tube_width, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map), C(max_weight), epsilon(tube_width) {} template< typename TokenIterator > online_svm( TokenIterator const begin, TokenIterator const end, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map) { C = 10.0; epsilon = 0.1; TokenIterator token( begin ); if ( token != end ) { C = boost::lexical_cast( *token++ ); if ( token != end ) epsilon = boost::lexical_cast( *token ); } } result_type operator()( input_type const &x ) { result_type result = bias; // temp_K[i], not temp_K[i+1] if (!margin_set.empty()) { vector_type temp_K( margin_set.size() ); fill_kernel( x, margin_key.begin(), margin_key.end(), temp_K.begin() ); result += atlas::dot( temp_K, weight ); } if (!error_set.empty()) { result_type temp_K(0); //vector_type temp_K( error_set.size() ); for( unsigned int i=0; i < error_set.size(); ++i ) temp_K += kernel( x, every_key[error_set[i]] ); result += C * temp_K; } if (!error_star_set.empty()) { result_type temp_K(0); for( unsigned int i=0; i < error_star_set.size(); ++i ) temp_K += kernel( x, every_key[error_star_set[i]] ); result -= C * temp_K; } return result; } /*! learn the entire range of keys indicated by this range */ template void learn( KeyIterator begin, KeyIterator end ) { // batch learning algorithm(s) right here... KeyIterator key_iterator(begin); while( key_iterator != end ) { increment( *key_iterator ); ++key_iterator; } } /*! call the incremental algorithm */ void increment( key_type const key ) { // index: * the corresponding row in the design matrix // * the corresponding location in the margin sense vector // key: * the corresponding location in the data container std::size_t index = every_key.size(); every_key.push_back( key ); // record prediction error if (debug) { std::cout << "Starting AOSVR incremental algorithm for key " << key << std::endl; std::cout << " the associated index is " << index << std::endl; } // important: the sign of the residual is used below residual.push_back( output( key ) - operator()( input( key ) ) ); // add to support vector buffer // preserved_resize( all_vectors, index+1, x_t.size() ); // row( all_vectors, index ).assign( x_t ); // preserved_resize( h, index+1 ); if ( index == 0 ) { // first point, initialise machine if (debug) std::cout << "Initialising the Accurate Online Support Vector Regression machine" << std::endl; residual.back() = 0.0; bias = output(key); // put this first point (with index 0) in the remaining set remaining_set.push_back( index ); // initialise the inverse matrix with a zero only R.grow_row_column(); R.matrix(0,0) = 0.0; // initialise design matrix with bias column H.grow_row_column(); // in case of regression: initialise design matrix with bias column H.matrix(0,0) = 1.0; // in case of classification: } else { // resize (view in) design matrix H.grow_row(); if (debug) std::cout << "H is now " << H.size1() << " by " << H.size2() << std::endl; // fill last row of design matrix with this input sample // TODO this should be an otimised function call ublas::matrix_row >::iterator j = ublas::row( H.matrix, index ).begin(); *j++ = 1.0; fill_kernel( key, margin_key.begin(), margin_key.end(), j ); if ( std::fabs(residual.back()) <= epsilon ) { if (debug) std::cout << "Adding index " << index << " to remaining set." << std::endl; remaining_set.push_back( index ); } else { if (debug) std::cout << "re-establishing KKT conditions..." << std::endl; if ( residual[ index ] < 0.0 ) satisfy_KKT_conditions< incremental_type, mpl::int_<-1> >( index, key, 0.0 ); else satisfy_KKT_conditions< incremental_type, mpl::int_<1> >( index, key, 0.0 ); } } } // define types for different actions struct incremental_type { typedef mpl::bool_ increment; typedef mpl::bool_ decrement; }; struct decremental_type { typedef mpl::bool_ increment; typedef mpl::bool_ decrement; }; // this template function switches the direction of a compare operation // on the basis of the direction type template inline bool switch_compare( scalar_type const a, scalar_type const b ) { if ( mpl::equal_to >::type::value ) return a < b; else return a > b; } // this template function switches the operation done on two scalars // on the basis of the direction type template inline scalar_type switch_add_sub( scalar_type const a, scalar_type const b ) { if ( mpl::equal_to >::type::value ) return a - b; else return a + b; } // scalar_type qm = detail::sign(q*margin_sense(idx)); // + qm * epsilon template inline scalar_type inline_qm( scalar_type const ms, scalar_type const b ) { if ( mpl::equal_to >::type::value ) return ( ms < static_cast(0) ? -b : b ); else return ( ms < static_cast(0) ? b : -b ); } // change the weight of a new or existing sample, in such way that // the KKT conditions will be met. The action type can be either add or remove, // this depends on whether a new or existing point's weight is modified. // The direction is the direction of the change of weight. template inline void satisfy_KKT_conditions( std::size_t index, key_type key, double init_weight ) { // with an enum, or with a source= and destination= type of handling? // perhaps the latter, because it seems to be a more elegant solution // enum { end_to_margin, end_to_error, end_to_remaining, // margin_to_remaining, margin_to_error, margin_to_error_star, // remaining_to_margin, error_to_margin, error_star_to_margin } action_enum; vector_type margin_sense( every_key.size() ); //vector_type maximum_values( margin_sense.size() ); vector_type coef_sense; scalar_type weight_t = init_weight; // create a candidate column of the design matrix; this column also includes the // point under consideration vector_type candidate_column( every_key.size() ); fill_kernel( key, every_key.begin(), every_key.end(), candidate_column.begin() ); if (debug) std::cout << "index: " << index << std::endl; int migrate_action = 99; while( migrate_action > 2 ) { if (debug) std::cout << "weight_t -------> " << weight_t; if (debug) std::cout << " direction: " << direction::value << std::endl; // compute all coefficient sensitivities coef_sense.resize( margin_set.size()+1, false ); ublas::matrix_range< ublas::matrix > R_range( R.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_view( R_range ); atlas::symv( R_view, H.row(index), coef_sense ); // for( int i=0; i> qqq; } // // Check for cases 1 and 2: end case for the incremental algorithm // if ( action_type::increment::value ) { // current point directly to the margin set? // -> INCREMENTAL ALGORITHM delta_weight_t = switch_add_sub(residual[index],epsilon) / margin_sense[index]; if (debug) std::cout << margin_sense[index] << std::endl; if (debug) std::cout << residual[index] << std::endl; if (debug) std::cout << switch_add_sub(residual[index],epsilon) << std::endl; migrate_action = 0; migrate_index = 0; migrate_index_2 = index; // current point directly to the error or error star set? // -> INCREMENTAL ALGORITHM if ( mpl::equal_to >::type::value ) max_var = C - weight_t; else max_var = -C - weight_t; if (switch_compare(max_var,delta_weight_t)) { migrate_action = 1; delta_weight_t = max_var; migrate_index = 0; migrate_index_2 = index; } // std::cout << "looked at the last point" << std::endl; } // -> DECREMENTAL ALGORITHM if ( action_type::decrement::value ) { max_var = -weight_t; if (switch_compare(max_var,delta_weight_t)) { //if ( max_var < delta_weight_t ) { migrate_action = 2; delta_weight_t = max_var; migrate_index = 0; migrate_index_2 = index; } } // Check for migration from margin set to any of the other sets (remainder,error,error-star) for( unsigned int i=0; i < margin_set.size(); ++i ) { if ( switch_compare( 0.0, coef_sense[i+1] )) { if (weight[i]<0.0) { // Check for migration from margin set to remainder set max_var = -weight[i] / coef_sense[i+1]; if (switch_compare(max_var,delta_weight_t)) { migrate_action = 3; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = margin_set[i]; } } else { // Check for migration from margin set to error set max_var = (C-weight[i]) / coef_sense[i+1]; if (switch_compare(max_var,delta_weight_t)) { migrate_action = 4; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = margin_set[i]; } } } else { if (weight[i]>0.0) { // Check for migration from margin set to remainder set max_var = -weight[i] / coef_sense[i+1]; if (switch_compare(max_var,delta_weight_t)) { migrate_action = 3; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = margin_set[i]; } } else { // Check for migration from margin set to error-star set max_var = (-C-weight[i]) / coef_sense[i+1]; if (switch_compare(max_var,delta_weight_t)) { migrate_action = 5; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = margin_set[i]; } } } } // Check for migration from error set to margin set for( unsigned int i=0; i( 0.0, margin_sense[idx] )) { max_var = (residual[idx] - epsilon) / margin_sense[idx]; if (debug) if (max_var==0.0) std::cout << "MAX VAR ==0 " << std::endl; if ( switch_compare(max_var,delta_weight_t) ) { migrate_action = 6; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = error_set[i]; } } } // Check for migration from error-star set to margin set for( unsigned int i=0; i( margin_sense[idx], 0.0 )) { max_var = (residual[idx] + epsilon) / margin_sense[idx]; if (switch_compare(max_var,delta_weight_t)) { migrate_action = 7; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = error_star_set[i]; } } } // Check for migration from the remainder set to the margin set for( unsigned int i=0; i(margin_sense[idx],epsilon)) / margin_sense[idx]; if (switch_compare(max_var,delta_weight_t)) { migrate_action = 8; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = remaining_set[i]; } } if (debug) std::cout << "delta weight_t: " << delta_weight_t << std::endl; if (debug) std::cout << "Migration action chosen: " << migrate_action << std::endl; if (debug) std::cout << "Affected index: " << migrate_index << std::endl; if (debug) std::cout << "Affected index 2: " << migrate_index_2 << std::endl; if (debug) std::cout << "Next candidate for weight: " << weight_t + delta_weight_t << std::endl; if (debug) if (delta_weight_t == 0.0 ) { std::cout << "DELTA WEIGHT == 0! " << std::endl; int qqq; std::cin >> qqq; } weight_t += delta_weight_t; // std::cout << "update weight_t to " << weight_t << std::endl; // update weight vector // it should have more than 0 elements if (weight.size() > 0) atlas::axpy( delta_weight_t, ublas::vector_range(coef_sense,ublas::range(1,coef_sense.size())), weight ); // update bias bias += coef_sense(0) * delta_weight_t; // update residual vector atlas::axpy( -delta_weight_t, margin_sense, residual ); // TODO give the cases names instead of these numbers switch( migrate_action ) { // Stopping criteria: case 0 and case 1 case 0: { // End-condition reached. The point under consideration is // added to the margin set, and the algorithm will terminate. // new sample -> margin set add_to_margin( index ); weight.push_back( weight_t ); if (debug) std::cout << "moved " << index << " to the margin set" << std::endl; break; } case 1: { // End-condition reached. The point under consideration is added // to the error set or error star set, and the algorithm will terminate. // new sample -> error/error-star set if ( mpl::equal_to >::type::value ) { error_set.push_back( index ); if (debug) std::cout << "moved " << index << " to the error set" << std::endl; } else { error_star_set.push_back( index ); if (debug) std::cout << "moved " << index << " to the error-star set" << std::endl; } break; } case 2: { // Decremental algorithm end condition reached. The point under consideration // is removed from the margin set and added to the remaining set. // At this point, it is alreay removed from the margin set. std::cout << "not much to do... " << std::endl; // we're at the end-point of the decremental algorithm! // we could do all kinds of stuff: remove it from the all_vectors, // from the residual and H matrix. // yet to decide on break; } case 3: { // A sample has to migrate from the margin set to the // remaining set (weight=0) remove_from_margin( migrate_index ); remaining_set.push_back(migrate_index_2); if (debug) std::cout << "moved " << migrate_index_2 << " from the margin set to the remaining set" << std::endl; break; } case 4: { // A sample has to migrate from the margin set to the error set (weight=C) remove_from_margin( migrate_index ); error_set.push_back(migrate_index_2); if (debug) std::cout << "moved " << migrate_index_2 << " from the margin set to the error set" << std::endl; break; } case 5: { // A sample has to migrate from the margin set to the error star set (weight=-C) remove_from_margin( migrate_index ); error_star_set.push_back(migrate_index_2); if (debug) std::cout << "moved " << migrate_index_2 << " from the margin set to the error-star set" << std::endl; break; } case 6: { // A sample has to migrate from the error set to the margin set, while // temporarily keeping its weight (=C) // error set -> margin set add_to_margin( migrate_index_2 ); // quick (constant time) removal: swap with latest element in vector error_set[ migrate_index ] = error_set.back(); error_set.pop_back(); weight.push_back( C ); if (debug) std::cout << "moved " << migrate_index_2 << " from the error set to the margin set" << std::endl; break; } case 7: { // A sample has to migrate from the error star set to the margin set, while // temporarily keeping its weight (=-C) // error star set -> margin set add_to_margin( migrate_index_2 ); // quick (constant time) removal: swap with latest element in vector error_star_set[ migrate_index ] = error_star_set.back(); error_star_set.pop_back(); weight.push_back( -C ); if (debug) std::cout << "moved " << migrate_index_2 << " from the error-star set to the margin set" << std::endl; break; } case 8: { // A sample has to migrate from the remaining set to the margin set, while // temporarily keeping its weight (=0) // remaining set -> margin set add_to_margin( migrate_index_2 ); // quick (constant time) removal: swap with latest element in vector remaining_set[ migrate_index ] = remaining_set.back(); remaining_set.pop_back(); weight.push_back( 0.0 ); if (debug) std::cout << "moved " << migrate_index_2 << " from the remaining set to the margin set" << std::endl; break; } default: { std::cout << "BUG IN AOSVR ROUTINE!!!" << std::endl; int qqq; std::cin >> qqq; break; } } } if (debug) std::cout << std::endl; } // if a point is added to the margin set, additional actions have to be taken // the inverse matrix has to be updated // the system/design matrix has to be updated void add_to_margin( int index ) { std::size_t old_size = R.size1(); std::size_t new_size = old_size + 1; key_type key = every_key[ index ]; // adjust inverse matrix if (new_size==2) { // initialise the R matrix R.grow_row_column(); R.matrix(0,0) = kernel( key, key ); R.matrix(1,0) = -1.0; R.matrix(1,1) = 0.0; } else { // grow the R matrix R.grow_row_column(); // fetch a view into the matrix _without_ the new row and columns ublas::matrix_range< ublas::matrix > R_range( R.shrinked_view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_symm_view( R_range ); // fetch a view into the last row of the matrix of the _old_ size ublas::matrix_vector_slice< ublas::matrix > R_row_part( R.shrinked_row(old_size) ); // compute the unscaled last row of R (similar to the coefficient sensitivities) atlas::symv( R_symm_view, H.row(index), R_row_part ); // compute the scaling factor // BAIL OUT HERE IF NECESSARY double divisor = kernel( key, key ) + atlas::dot( H.row(index), R_row_part ); if (std::fabs( divisor ) < 1e-12 ) { // from http://bach.ece.jhu.edu/pub/gert/slides/kernel.pdf // When the incremental inverse jacobian is (near) ill conditioned, a direct L1-norm minimisation // of the \alpha coefficients yields an optimally sparse solution std::cout << std::endl; std::cout << "k_tt + dot( H.row(index), R_row_part ) = " << divisor << std::endl; std::cout << "Problem detected, algorithm will get stuck real soon now." << std::endl; std::cout << "Point to be added to the margin set: " << index << std::endl; std::cout << H.row(index) << std::endl; std::cout << R_row_part << std::endl; for( unsigned int i=0; i> qqq; //atlas::set( 0.0, R_row_part ); //R.matrix( old_size, old_size ) = 0.0; } // the divisor is within acceptable bounds; increase the R matrix as usual R.matrix(old_size,old_size) = -1.0 / divisor; // perform a rank-1 update of the R matrix atlas::syr( R.matrix(old_size,old_size), R_row_part, R_symm_view ); // scale the last row with the scaling factor atlas::scal( R.matrix(old_size,old_size), R_row_part ); } // adjust "design" matrix // NOTE has to be done AFTER the update of the R matrix!! (to check ... ) // because a row of the "old" design matrix is used in the determination of "delta", see above. H.grow_column(); //ublas::matrix_column >::iterator fill_kernel( key, every_key.begin(), every_key.end(), ublas::column( H.matrix, old_size ).begin() ); // for( unsigned int i=0; i > R_range( R.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_view( R_range ); vector_type R_row( row(R_view, idx+1) ); atlas::syr( -1.0/R.matrix(idx+1,idx+1), R_row, R_view ); // efficient removal from inverse matrix R R.swap_remove_row_col( idx+1 ); } // constant time removal from margin set index vector margin_set[ idx ] = margin_set.back(); margin_set.pop_back(); // constant time removal from margin set key vector margin_key[ idx ] = margin_key.back(); margin_key.pop_back(); // constant time removal from weight vector weight[ idx ] = weight.back(); weight.pop_back(); } // loading and saving capabilities of the online SVM algorithm template void serialize( Archive &archive, unsigned int const version ) { archive & boost::serialization::base_object(*this); archive & C; archive & epsilon; archive & bias; archive & every_key; archive & residual; archive & margin_set; archive & margin_key; archive & weight; archive & error_set; archive & error_star_set; archive & remaining_set; archive & H; archive & R; } // local memory static const bool debug = false; matrix_view< ublas::matrix > H; // (part of) design matrix H symmetric_view< ublas::matrix > R; // matrix inverse std::vector residual; // in some sense, the history of outputs scalar_type C; scalar_type epsilon; scalar_type bias; // bias of the regression function std::vector< key_type > every_key; // a vector containing all (learnt) keys typedef typename base_type::index_type index_type; /*! A vector containing the indices into key_lookup of the margin vectors (-C < weight < C) */ std::vector< index_type > margin_set; /*! A vector containing the keys of the margin vectors (-C < weight < C) */ std::vector< key_type > margin_key; /*! weights associated with the margin vectors */ std::vector< scalar_type > weight; /*! A vector containing the indices into key_lookup of the error vectors (weight > C)*/ std::vector< index_type > error_set; /*! A vector containing the indices into key_lookup of the error-star vectors (weight < -C)*/ std::vector< index_type > error_star_set; /*! A vector containing the indices into key_lookup of the remaining vectors (weight == 0)*/ std::vector< index_type > remaining_set; }; /*! On-line SVM classification algorithm. Duplicate data points (we're not yet discussing linear dependent points) cause the original algorithm to malfunction. This could be solved by introducing a weight per point, with the weight the number of times a point is present the data set. Of course, the remaining points could be never measured at all: so we don't know (or care) whether duplicates are present in that kind of points. The original algorithm will crash only when a duplicate point enters the margin_set The algorithm will be able to detect whether a duplicate is being entered when it runs the satisfy_KKT_conditions; the distance between a new point and an existing point will be 0. In case of duplicate points, a weight of a prior point could be increased by 1 to represent that point. In case of linear dependent points; the weight of a number of prior points could be increased by the projection weights (and that linear dependent point can be left out). \todo - introduce weighted examples - be able to process contradicting examples (weight==0, then answer indeterminate or something) - Unlearning of examples \section bibliography2 References -# Gert Cauwenberghs and Tomaso Poggio. Incremental and Decremental Support Vector Machine Learning. In Todd Leen and Thomas Dietterich and Volker Tresp, editors, Advances in Neural Information Processing Systems (NIPS'00). http://tinyurl.com/7cydn */ template< typename Problem, typename Kernel, typename PropertyMap > class online_svm< Problem, Kernel, PropertyMap, typename boost::enable_if< is_classification >::type >: public kernel_machine< Problem, Kernel, PropertyMap > { public: typedef kernel_machine< Problem, Kernel, PropertyMap > base_type; typedef typename base_type::kernel_type kernel_type; typedef typename base_type::result_type result_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef typename Problem::example_type example_type; typedef double scalar_type; typedef ublas::symmetric_matrix symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; friend class boost::serialization::access; online_svm( typename boost::call_traits::param_type max_weight, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map), C(max_weight) {} template< typename TokenIterator > online_svm( TokenIterator const begin, TokenIterator const end, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map) { C = 10.0; TokenIterator token( begin ); if ( token != end ) { C = boost::lexical_cast( *token++ ); } } output_type operator()( typename boost::call_traits::param_type x ) { return (evaluate_f(x) >= 0.0); } // a non-classifying prediction function // is needed to compute condition figures scalar_type evaluate_f( typename boost::call_traits::param_type x ) { scalar_type result(bias); // temp_K[i], not temp_K[i+1] if (margin_set.size()>0) { vector_type temp_K( margin_set.size() ); fill_kernel( x, margin_key.begin(), margin_key.end(), temp_K.begin() ); result += atlas::dot( temp_K, weight ); } if (error_set.size()>0) { scalar_type temp_K(0); for( unsigned int i=0; i < error_set.size(); ++i ) { key_type key = every_key[error_set[i]]; if ( output(key) ) temp_K += kernel( x, key ); else temp_K -= kernel( x, key ); } result += C * temp_K; } return result; } /*! learn the entire range of keys indicated by this range */ template void learn( KeyIterator begin, KeyIterator end ) { KeyIterator key_iterator(begin); while( key_iterator != end ) { increment(*key_iterator); ++key_iterator; } } float bool_to_float( bool const value ) { return ( value ? 1.0 : -1.0 ); } /*! \param input an input pattern of input type I \param output an output pattern of output type O */ void increment( key_type const key ) { debug = false; std::size_t index = every_key.size(); every_key.push_back( key ); // record prediction error if (debug) { std::cout << "Starting AOSVR incremental algorithm for key " << key << std::endl; std::cout << " the associated index is " << index << std::endl; } //if (index > 581) debug=true; if (debug) std::cout << "Starting incremental SVM classification algorithm with " << index << " prior points" << std::endl; //if (index > 615 ) debug = true; else debug = false; //if (debug) // record condition figure if ( output(key) ) condition.push_back( evaluate_f( input(key) ) - 1.0 ); else condition.push_back( -evaluate_f( input(key) ) - 1.0 ); // store the input and output //base_type::support_vector.push_back( input ); //outputs.push_back( output ); /* std::cout << "Predicting history..." << std::endl; for( int i=0; i >::iterator j = ublas::row( H.matrix, index ).begin(); *j++ = bool_to_float( output(key) ); fill_kernel( key, margin_key.begin(), margin_key.end(), j ); // std::cout << "Filled H to "; // std::cout << H.view() << std::endl; if (debug) std::cout << "condition[index] is " << condition.back() << std::endl; if ( condition.back() >= 0.0 ) { if (debug) std::cout << "adding to remaining set..." << std::endl; remaining_set.push_back( index ); if (debug) std::cout << std::endl; } else { if (debug) std::cout << "Satisfying KKT conditions... " << std::endl; satisfy_KKT_conditions( index, key, 0.0 ); } } /* std::cout << "Predicting history..." << std::endl; for( int i=0; i> qqq; } } inline void satisfy_KKT_conditions( int index, key_type key, double init_weight ) { scalar_type weight_t = init_weight; // create a candidate COLUMN of design matrix H; this column also includes the point under consideration // // TODO // TODO Duplicate detection can be done right here (distance function using kernels etc.) // TODO // vector_type candidate_column( every_key.size() ); fill_kernel( key, every_key.begin(), every_key.end(), candidate_column.begin() ); // if ( (*base_type::data)[key].get<1>() ) { // for( unsigned int i=0; i() ) // std::cout << kernel( key, every_key[i] ) << std::endl; // else // std::cout << -kernel( key, every_key[i] ) << std::endl; // } else { // for( unsigned int i=0; i() ) // std::cout << -kernel( key, every_key[i] ) << std::endl; // else // std::cout << kernel( key, every_key[i] ) << std::endl; // } if (debug) std::cout << "Computed candidate column" << std::endl; // if (debug) // std::cout << "Candidate column is " << candidate_column << std::endl; // initialise the margin and coefficient sensitivity vectors vector_type margin_sense( every_key.size() ); vector_type coef_sense; int migrate_action = 99; while( migrate_action > 2 ) { // Equation 10: compute all coefficient sensitivities coef_sense.resize( margin_set.size()+1, false ); ublas::matrix_range< ublas::matrix > R_range( R.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_view( R_range ); atlas::symv( R_view, H.row(index), coef_sense ); // if (debug) // std::cout << "Coefficient sensitivities: " << coef_sense << std::endl; // // Equation 12: compute all margin sensitivities atlas::gemv( H.view(), coef_sense, margin_sense ); atlas::xpy( candidate_column, margin_sense ); // if (debug) // std::cout << "Margin sensitivities: " << margin_sense << std::endl; // if (debug) { // std::cout << "Condition numbers: "; // for( unsigned int i=0;i " << weight_t << std::endl; // TODO // BUG!! Use adult-1a.data to get this bug to work // TODO if ( margin_sense[index] < 0.0 ) { std::cout << "Something seems to be wrong, algorithm will get stuck now" << std::endl; std::cout << "Current index: " << index << std::endl; std::cout << "Matrix R: " << R.view() << std::endl; int qqq; std::cin >> qqq; } // CHECK END CONDITIONS OF CURRENT POINT // -> INCREMENTAL ALGORITHM // current point directly to the margin set? delta_weight_t = -condition[index] / margin_sense[index]; if (debug) std::cout << "point -> margin: " << delta_weight_t << std::endl; migrate_action = 0; migrate_index = 0; migrate_index_2 = index; // current point directly to the error set? max_var = C - weight_t; if (debug) std::cout << "point -> error: " << max_var << std::endl; if (max_var < delta_weight_t) { migrate_action = 1; delta_weight_t = max_var; migrate_index = 0; migrate_index_2 = index; } // Check for migration from margin set to any of the other sets (remainder,error) for( unsigned int i=0; i < margin_set.size(); ++i ) { if ( coef_sense[i+1] < 0.0 ) { // Check for migration from margin set to remaining set max_var = -weight[i] / coef_sense[i+1]; if (debug || max_var > 1e10) std::cout << "margin -> remaining: " << max_var << std::endl; if (max_var < delta_weight_t) { migrate_action = 3; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = margin_set[i]; } } else { // Check for migration from margin set to error set max_var = (C-weight[i]) / coef_sense[i+1]; if (debug || max_var > 1e10) std::cout << "margin -> error: " << max_var << std::endl; if (max_var < delta_weight_t) { migrate_action = 4; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = margin_set[i]; } } } // Check for migration from error set to margin set for( unsigned int i=0; i 0.0 ) { max_var = -condition[idx] / margin_sense[idx]; if (debug || max_var > 1e10) std::cout << "error -> margin: " << max_var << std::endl; if ( max_var < delta_weight_t) { migrate_action = 6; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = error_set[i]; } } } // Check for migration from the remaining set to the margin set for( unsigned int i=0; i 1e10) std::cout << "remaining -> margin: " << max_var << std::endl; if (max_var < delta_weight_t) { migrate_action = 8; delta_weight_t = max_var; migrate_index = i; migrate_index_2 = remaining_set[i]; } } } if (debug) std::cout << "delta weight_t: " << delta_weight_t << std::endl; if (debug) std::cout << "Migration action chosen: " << migrate_action << std::endl; if (debug) std::cout << "Affected index: " << migrate_index << std::endl; if (debug) std::cout << "Affected index 2: " << migrate_index_2 << std::endl; if (debug) std::cout << "Next candidate for weight: " << weight_t + delta_weight_t << std::endl; // Update the weight of the point under consideration weight_t += delta_weight_t; // Equation 8: update bias using its coefficient sensitivities and the change in the weight_t bias += delta_weight_t * coef_sense[0]; // Equation 9: update weight vector using the coefficient sensitivities and the change in the weight_t atlas::axpy( delta_weight_t, ublas::vector_range(coef_sense,ublas::range(1,coef_sense.size())), weight ); if (debug) { std::cout << "Updated weights to: "; for( unsigned int i=0; i margin set add_to_margin( index ); weight.push_back( weight_t ); if (debug) std::cout << "moved " << index << " to the margin set" << std::endl; break; } case 1: { // End-condition reached. The point under consideration is added // to the error set or error star set, and the algorithm will terminate. // new sample -> error set error_set.push_back( index ); if (debug) std::cout << "moved " << index << " to the error set" << std::endl; break; } case 3: { // A sample has to migrate from the margin set to the // remaining set (weight=0) remove_from_margin( migrate_index ); remaining_set.push_back(migrate_index_2); if (debug) std::cout << "moved " << migrate_index_2 << " from the margin set to the remaining set" << std::endl; break; } case 4: { // A sample has to migrate from the margin set to the error set (weight=C) remove_from_margin( migrate_index ); error_set.push_back(migrate_index_2); if (debug) std::cout << "moved " << migrate_index_2 << " from the margin set to the error set" << std::endl; break; } case 6: { // A sample has to migrate from the error set to the margin set, while // temporarily keeping its weight (=C) // error set -> margin set add_to_margin( migrate_index_2 ); // quick (constant time) removal: swap with latest element in vector error_set[ migrate_index ] = error_set.back(); error_set.pop_back(); weight.push_back( C ); if (debug) std::cout << "moved " << migrate_index_2 << " from the error set to the margin set" << std::endl; //std::cout << delta_weight_t << std::endl; break; } case 8: { // A sample has to migrate from the remaining set to the margin set, while // temporarily keeping its weight (=0) // remaining set -> margin set add_to_margin( migrate_index_2 ); // quick (constant time) removal: swap with latest element in vector remaining_set[ migrate_index ] = remaining_set.back(); remaining_set.pop_back(); weight.push_back( 0.0 ); if (debug) std::cout << "moved " << migrate_index_2 << " from the remaining set to the margin set" << std::endl; break; } default: { std::cout << "BUG IN Incremental SVM ROUTINE!!!" << std::endl; int qqq; std::cin >> qqq; break; } } // if (debug) { // int qqq; // std::cin >> qqq; // // } //migrate_action = 0; } if (debug) std::cout << std::endl; } // if a point is added to the margin set, additional actions have to be taken // the inverse matrix has to be updated // the system/design matrix has to be updated void add_to_margin( int idx ) { unsigned int old_size = R.size1(); unsigned int new_size = old_size + 1; //std::cout << "associated key is " << every_key[idx] << std::endl; // if a point moves to the margin set, by definition, its condition equals 0. condition[ idx ] = 0.0; // adjust inverse matrix if (new_size==2) { // initialise the R matrix R.grow_row_column(); // this is correct: Q_ii == K(x_i,x_i) R.matrix(0,0) = kernel( every_key[idx], every_key[idx] ); // NEGATED bool_to_float (!!) R.matrix(1,0) = -bool_to_float( output( every_key[idx] ) ); R.matrix(1,1) = 0.0; } else { // grow the R matrix R.grow_row_column(); // fetch a view into the matrix _without_ the new row and columns ublas::matrix_range< ublas::matrix > R_range( R.shrinked_view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_symm_view( R_range ); // fetch a view into the last row of the matrix of the _old_ size //ublas::matrix_row< ublas::matrix_range< ublas::matrix > > R_row_part( R.shrinked_row(old_size) ); ublas::matrix_vector_slice< ublas::matrix > R_row_part( R.shrinked_row(old_size) ); // compute the unscaled last row of R (similar to the coefficient sensitivities) atlas::symv( R_symm_view, H.row(idx), R_row_part ); // compute the scaling factor // BAIL OUT HERE IF NECESSARY double divisor = kernel( every_key[idx], every_key[idx] ) + atlas::dot( H.row(idx), R_row_part ); // Pseudoinverse of a SVD: // in this case: fill that part of R with zeros! // see http://kwon3d.com/theory/jkinem/svd.html // for values on the diagonal // if w_i > epsilon, then w_i = 1/w_i // else w_i = 0 // i.e. infinity is replaced with 0. // So, that row (and column) of R should become 0. // --->>> Sample 65 is identical to 582!! // So, their distance is 0. // So, the max_weight of 65 = 2C?!! // At the moment, let the algorithm crash, because adding 0 to R is not a final solution (although it works!). if (std::fabs( divisor ) < 1e-12 ) { // from http://bach.ece.jhu.edu/pub/gert/slides/kernel.pdf // When the incremental inverse jacobian is (near) ill conditioned, a direct L1-norm minimisation // of the \alpha coefficients yields an optimally sparse solution std::cout << std::endl; std::cout << "k_tt + dot( H.row(idx), R_row_part ) = " << divisor << std::endl; std::cout << "Problem detected, algorithm will get stuck real soon now." << std::endl; std::cout << "Point to be added to the margin set: " << idx << std::endl; std::cout << H.row(idx) << std::endl; std::cout << R_row_part << std::endl; for( unsigned int i=0; i> qqq; //atlas::set( 0.0, R_row_part ); //R.matrix( old_size, old_size ) = 0.0; } // the divisor is within acceptable bounds; increase the R matrix as usual R.matrix(old_size,old_size) = -1.0 / divisor; // perform a rank-1 update of the R matrix atlas::syr( R.matrix(old_size,old_size), R_row_part, R_symm_view ); // scale the last row with the scaling factor atlas::scal( R.matrix(old_size,old_size), R_row_part ); } // std::cout << "R is now: "<< R.view() << std::endl; // adjust "design" matrix // NOTE has to be done AFTER the update of the R matrix!! (to check ... ) // because a row of the "old" design matrix is used in the determination of "delta", see above. H.grow_column(); fill_kernel( every_key[idx], every_key.begin(), every_key.end(), ublas::column( H.matrix, old_size ).begin() ); // std::cout << H.view() << std::endl; // if ( (*base_type::data)[every_key[idx]].get<1>() ) { // for( unsigned int i=0; i() ) // std::cout << kernel( every_key[idx], every_key[i] ) << std::endl; // else // std::cout << -kernel( every_key[idx], every_key[i] ) << std::endl; // } else { // for( unsigned int i=0; i() ) // std::cout << -kernel( every_key[idx], every_key[i] ) << std::endl; // else // std::cout << kernel( every_key[idx], every_key[i] ) << std::endl; // } /* if ( outputs[idx] ) { for( unsigned int i=0; i> qqq; } ublas::matrix_range< ublas::matrix > R_range( R.view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > R_view( R_range ); vector_type R_row( row(R_view, idx+1) ); atlas::syr( -1.0/divisor, R_row, R_view ); // efficient removal from inverse matrix R R.swap_remove_row_col( idx+1 ); } // constant time removal from margin set index vector margin_set[ idx ] = margin_set.back(); margin_set.pop_back(); // constant time removal from margin set key vector margin_key[ idx ] = margin_key.back(); margin_key.pop_back(); // constant time removal from weight vector weight[ idx ] = weight.back(); weight.pop_back(); } template void serialize( Archive &archive, unsigned int const version ) { archive & boost::serialization::base_object(*this); archive & C; archive & bias; archive & condition; archive & H; archive & R; archive & every_key; archive & margin_set; archive & margin_key; archive & weight; archive & error_set; archive & remaining_set; } //static const bool debug = false; bool debug; matrix_view< ublas::matrix > H; // "design matrix" Q (not as in the paper!) symmetric_view< ublas::matrix > R; // matrix inverse scalar_type bias; std::vector every_key; std::vector weight; /*! vector "g" containing condition numbers for associated (indexed) vectors */ std::vector condition; /*! maximum weight */ scalar_type C; /*! A vector containing the indices of the margin vectors (y_i f(x_i) == 1) */ std::vector margin_set; /*! A vector containing the keys of the margin vectors ((y_i f(x_i) == 1) */ std::vector margin_key; /*! A vector containing the indices of the error vectors (exceeding the margin) */ std::vector error_set; /*! A vector containing the indices of the remaining vectors (within the margin) */ std::vector remaining_set; }; // ON-LINE SVM RANKING ALGORITHM // template // class online_svm >::type >: // public kernel_machine { // // typedef kernel_machine base_type; // typedef typename kernel_type kernel_type; // typedef typename base_type::result_type result_type; // typedef typename Problem::input_type input_type; // typedef typename Problem::output_type output_type; // typedef double scalar_type; // typedef ublas::symmetric_matrix symmetric_type; // typedef ublas::matrix matrix_type; // typedef ublas::vector vector_type; // // typedef typename boost::range_value::type point_type; // typedef typename output_type::const_iterator const_output_iterator; // typedef typename std::vector::const_iterator const_svec_iterator; // // online_svm(typename boost::call_traits::param_type k, // typename boost::call_traits::param_type max_weight): // base_type(k), C(max_weight), inner_machine(k, max_weight) { } // // /*! \param input an input pattern of input type I // \param output an output pattern of output type O */ // // // // void push_back(input_type const &input, output_type const &output) { // /* Here's how it works as you push a new vector in: // // 1. Compare the vector, i, and its output to each pair we've already // stored. This set could, of course, be empty. // 2. For each vector j in our stored set which has an output not identical to ours, // create a difference vector and add that difference vector to a new input set. // 3. Call push_back on our internal classification SVM for each difference vector. */ // // const_output_iterator y = ys.begin(); // // for (const_svec_iterator i = base_type::support_vector.begin(); // *y != ys.end() && i != base_type::support_vector.end(); // ++y, ++i) { // if (*y != output) { // input_type diff_vec; // std::transform(input.begin(), input.end(), i->begin(), // diff_vec.begin(), std::minus()); // inner_machine.push_back(diff_vec, (output > *y)); // } // } // base_type::support_vector.push_back(input); // ys.push_back(output); // } // std::vector ys; // scalar_type C; // // typedef classification inner_problem; // online_svm inner_machine; // }; } //namespace kml namespace boost { namespace serialization { template< typename Problem, typename Kernel, typename PropertyMap, typename Enable > struct tracking_level< kml::online_svm > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost #endif kml_src/kml/polynomial.hpp000644 000765 000024 00000012147 10426606710 016626 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef POLYNOMIAL_HPP #define POLYNOMIAL_HPP #include #include #include #include #include #include #include namespace kml { /*! \brief polynomial kernel \param T defines the argument type This is a template class that creates a functor for the polynomial kernel. \ingroup kernels */ template class polynomial: public std::binary_function::type> { public: /*! Refinement of AdaptableBinaryFunction */ typedef T first_argument_type; typedef T second_argument_type; typedef typename input_value::type result_type; /*! Refinement of Kernel ? */ typedef polynomial type; // scalar type.. typedef typename input_value::type scalar_type; friend class boost::serialization::access; /*! Refinement of DefaultConstructible */ polynomial(): scale(1.0), bias(0.0), order(3.0) {} /*! Refinement of CopyConstructible */ polynomial( type const &other ) { copy( other ); } /*! Refinement of Assignable */ type &operator=( type const &other ) { if (this != &other) { copy(other); } return *this; } /*! Construct a polynomial kernel by providing values for gamma, lambda, and degree \param gamma the scale of the inner product \param lambda the bias of the inner product \param degree the order of the polynomial kernel */ polynomial( typename boost::call_traits::param_type gamma, typename boost::call_traits::param_type lambda, typename boost::call_traits::param_type degree ): scale(gamma), bias(lambda), order(degree) {} /*! Construct a polynomial kernel by providing TokenIterators */ template polynomial( TokenIterator const begin, TokenIterator const end ) { // set default values scale = 1.0; bias = 0.0; order = 3.0; TokenIterator token(begin); if ( token != end ) scale = boost::lexical_cast( *token++ ); if ( token != end ) bias = boost::lexical_cast( *token++ ); if ( token != end ) order = boost::lexical_cast( *token ); } /*! Returns the result of the evaluation of the polynomial kernel for these points \param u input pattern u \param v input pattern v \return \f$ (\gamma * u^T v + \lambda)^d \f$ */ scalar_type operator()( T const &u, T const &v ) const { return std::pow( scale * linear()(u,v) + bias, order ); } // loading and saving capabilities template void serialize( Archive &archive, unsigned int const version ) { archive & scale; archive & bias; archive & order; } // for debugging purposes friend std::ostream& operator<<(std::ostream &os, type const &k) { os << "Polynomial kernel (" << k.scale << "+" << k.bias << ")^" << k.order << std::endl; return os; } private: void copy( type const &other ) { scale = other.scale; bias = other.bias; order = other.order; } scalar_type scale; scalar_type bias; scalar_type order; }; } // namespace kml namespace boost { namespace serialization { template struct tracking_level< kml::polynomial > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost #endif kml_src/kml/power_value.hpp000644 000765 000024 00000003225 10377266147 017003 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef POWER_VALUE_HPP #define POWER_VALUE_HPP #include #include namespace kml { template struct power_value: mpl::eval_if< mpl::is_even< mpl::int_ >, input_value, mpl::identity > {}; } #endif kml_src/kml/ranking.hpp000644 000765 000024 00000004545 10413644554 016103 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2005, 2006 by Meredith L. Patterson * * Copyright (C) 2005, 2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef RANKING_HPP #define RANKING_HPP #include #include namespace kml { /*! \brief Defines a ranking problem. \param T the example type The example type should be a boost::tuple defining the input as the first element, the group as the second element, and the output as the third element. \sa regression, classification \ingroup problem */ template class ranking { public: typedef ranking type; typedef T example_type; typedef typename boost::tuples::element<0,T>::type input_type; typedef typename boost::tuples::element<1,T>::type group_type; typedef typename boost::tuples::element<2,T>::type output_type; }; // Define templates is_ranking so we can recognise the ranking type of problems template struct is_ranking: boost::mpl::bool_ {}; template struct is_ranking >: boost::mpl::bool_ {}; } #endif kml_src/kml/regression.hpp000644 000765 000024 00000005114 10377266147 016632 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef REGRESSION_HPP #define REGRESSION_HPP #include #include namespace kml { /*! \brief Defines a regression problem. \param I the input type \param O the output type \section example Examples \code typedef kml::regression< ublas::vector, double > problem; \endcode The problem defined as above can then be used as a template parameter in defining kernel machines: \code kml::rvm< problem, kml::gaussian > my_machine( 1.6 ); \endcode \sa classification, ranking \ingroup problem */ // template // class regression { // public: // typedef regression type; // typedef I input_type; // typedef O output_type; // }; template class regression { public: typedef regression type; typedef T example_type; typedef typename boost::tuples::element<0,T>::type input_type; typedef typename boost::tuples::element<1,T>::type output_type; }; // define is_regression so we can recognise the regression type of problems // for (partial) specialisations template struct is_regression: boost::mpl::bool_ {}; template struct is_regression >: boost::mpl::bool_ {}; } #endif kml_src/kml/rvm.hpp000644 000765 000024 00000066125 10515104666 015256 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef RVM_HPP #define RVM_HPP #include #include #include #include #include #include #include // TODO fix old algorithms from kernels.h #include "kernels.h" // include AFTER enough traits have been included, of course... (?) #include #include #include #include #include #include namespace kml { /*! \brief Relevance Vector Machine \param I the input type \param O the output type \param K the kernel type Implementation of the Fast RVM [1]. \todo - Cleanup code - Classification algorithm - Fix the HtH algorithms \section bibliography References -# Michael Tipping and Anita Faul. Fast marginal likelihood maximisation for sparse bayesian models. In Cristopher Bishop and Brendan Frey, editors, Proceedings of the Ninth International Workshop on Artificial Intelligence and Statistics, January 3-6 2003, Key West, Florida, 2003. ISBN 0-9727358-0-1. */ template< typename Problem, typename Kernel, typename PropertyMap, class Enable = void> class rvm: public kernel_machine< Problem, Kernel, PropertyMap > {} ; template< typename Problem, typename Kernel, typename PropertyMap > class rvm< Problem, Kernel, PropertyMap, typename boost::enable_if< is_regression >::type>: public kernel_machine< Problem, Kernel, PropertyMap > { public: typedef kernel_machine< Problem, Kernel, PropertyMap > base_type; typedef typename base_type::kernel_type kernel_type; typedef typename base_type::result_type result_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef double scalar_type; typedef ublas::symmetric_matrix symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; friend class boost::serialization::access; /*! \param k a construction parameter for the kernel type */ rvm( typename boost::call_traits::param_type var, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map), variance_estimate(var) {} /*! Construct a RVM using TokenIterators */ template< typename TokenIterator > rvm( TokenIterator const begin, TokenIterator const end, typename boost::call_traits::param_type k, typename boost::call_traits::param_type map ): base_type(k,map) { // default parameter setting variance_estimate = 0.1; TokenIterator token(begin); if ( token != end ) variance_estimate = boost::lexical_cast( *token ); } result_type operator()( input_type const &x ) { } /*! learn the entire range of keys indicated by this range */ template void learn( KeyIterator begin, KeyIterator end ) { bool debug = true; if (debug) std::cout << "Computing H..." << std::flush; std::size_t problem_size( end-begin ); H.resize( problem_size, problem_size + 1 ); base_type::design_matrix( begin, end, H ); if (debug) std::cout << "done." << std::endl; if (debug) std::cout << "computing Hty..." << std::flush; vector_type m_output( problem_size ); KeyIterator key_iter( begin ); for( std::size_t i = 0; i(ublas::trans(H)), m_output, Hty ); if (debug) std::cout << "done." << std::endl; std::cout << "computing HtH..." << std::flush; matrix_type HtH( problem_size + 1, problem_size + 1 ); atlas::gemm( static_cast(ublas::trans(H)), H, HtH ); std::cout << "done." << std::endl; vector_type diag_HtH( HtH.size1() ); for( unsigned int i=0; i active_set; std::vector inactive_set( problem_size + 1 ); for( std::size_t i=0; i s_i does not hold. This fixes a bug that occured. unsigned int max_idx; double max_dl = 0.0; for( unsigned int i=0; i max_dl) { max_idx = i; max_dl = delta_l; } } if (debug) std::cout << "starting with point number " << max_idx << "." << std::endl; active_set.push_back( max_idx ); inactive_set.erase( inactive_set.begin() + max_idx ); theta( max_idx ) = ((Hty(max_idx)*Hty(max_idx)) / HtH(max_idx,max_idx) - variance_estimate) / HtH(max_idx,max_idx); vector_type S( problem_size + 1 ); vector_type Q( problem_size + 1 ); vector_type mu; vector_type residuals( problem_size ); int best_action = add ; // set to add action (?? ... ) // // MAIN LOOP // while( best_action != unknown ) { /* std::cout << "active support vectors: "; std::copy( active_set.begin(), active_set.end(), std::ostream_iterator(std::cout, " ") ); std::cout << std::endl; // << "inactive support vectors: ";*/ // std::copy( inactive_set.begin(), inactive_set.end(), std::ostream_iterator(cout, " ") ); // std::cout << std::endl; // variance changed... recompute sigma and mu // TODO don't fully recompute the sigma and mu if the variance did not change enough // TODO NEVER recompute the sigma and mu? // Prepare the not-yet-inverted part of matrix sigma, and // the non-multiplied part of vector mu // sigma_inv <- (HtH*(1/var)+A) (part of eq. 5) // mu <- Hty (part of eq. 6) scalar_type beta = static_cast(1) / variance_estimate; matrix_type sigma_inv( active_set.size(), active_set.size() ); ublas::symmetric_adaptor< matrix_type > sigma_inv_symm( sigma_inv ); mu.resize( active_set.size() ); vector_type Hty_cache( active_set.size() ); matrix_type HtH_cache( HtH.size1(), active_set.size() ); matrix_type H_cache( H.size1(), active_set.size() ); for( unsigned int i=0; i(1) / theta(index_1); // temporary solution: copy Hty elements to Hty_cache // while this should be done with e.g. swap operations Hty_cache[i] = Hty[index_1]; // temporary solution: copy column from HtH to HtH_cache ublas::column(HtH_cache,i) = ublas::column(HtH,index_1); // temporary solution: copy column from HtH to HtH_cache ublas::column(H_cache,i) = ublas::column(H,index_1); } // Invert matrix to form matrix sigma and compute vector mu // sigma <- (HtH*(1/var)+A)^-1 (equation 5, Tipping, 1999) // mu <- (1/var)*sigma*Hty (equation 6, Tipping, 1999) // TODO symmetric adaptor can go if upper or lower is known (other call to symv) // NOTE recip. variance is probably not most efficient like this. // create a unit matrix of size active_set.size() matrix_type sigma( active_set.size(), active_set.size() ); sigma.clear(); for( unsigned int i=0; i sigma_symm( sigma ); atlas::posv( sigma_inv_symm, sigma ); // update mu vector // sigma_symm is active_set.size() by active_set.size() // Hty_cache is problem_size by active_set.size() // mu is active_set size atlas::symv( sigma_symm, Hty_cache, mu ); atlas::scal( beta, mu ); /* COMPUTATIONS DONE TO ESTIMATE THE NEXT BASIS VECTOR */ // work matrix will be HtH.size1() by active_set.size (equals HtH_part size) matrix_type work_mat( HtH.size1(), active_set.size() ); atlas::symm( HtH_cache, sigma_symm, work_mat ); // compute ALL S(i)'s and Q(i)'s (quite efficient) for( unsigned int i=0; is_i ? (q_i_2-s_i) / (s_i*s_i) : 0.0 ); //std::cout << "theta estimate is " << theta_i << std::endl; if ( q_i_2 > s_i ) { // reestimate a basis function (equation 32) scalar_type delta_theta = theta_i - theta(i); scalar_type delta_l = (Q(i) * Q(i)) / ( S(i) + 1.0 / delta_theta) - std::log( 1.0 + S(i) * delta_theta ); // if (debug) // std::cout << "reestimating " << i << " had delta l of " << delta_l << std::endl; if ( delta_l > delta_l_max ) { best_action = reestimate; delta_l_max = delta_l; action_index = as_i; theta_l_max = theta_i; } // observe stopping criterion right here (see 4.4 in paper) // std::cout << "delta log alpha " << std::log(theta(i)) - std::log( theta_i ) << std::endl; } else { // delete a basis function (equation 37) scalar_type delta_l = (Q(i) * Q(i)) / (S(i)-1.0/theta(i)) - std::log( 1.0 - S(i) * theta(i) ); // if (debug) // std::cout << "deleting " << i << " had delta l of " << delta_l << std::endl; if ( delta_l > delta_l_max ) { best_action = remove ; delta_l_max = delta_l; action_index = as_i; theta_l_max = theta_i; } } } // add? for( unsigned int as_i=0; as_i s_i ) { // change in log likelihood, equation 27 scalar_type delta_l = (q_i_2-s_i)/s_i + std::log( s_i / q_i_2 ); // if (debug) // std::cout << "adding " << i << " had delta l of " << delta_l << std::endl; if ( delta_l > delta_l_max ) { best_action = add ; ; delta_l_max = delta_l; action_index = as_i; theta_l_max = theta_i; } } } //if (delta_l_max < std::numeric_limits::epsilon() ) { // TODO check this limit! if (delta_l_max < 1e-6 ) { best_action = unknown; } if (debug) std::cout << "best action was: " << best_action << " with delta_l of " << delta_l_max << std::endl; if (debug) std::cout << "index was " << action_index << " and theta was " << theta_l_max << std::endl; /* BASIS VECTOR HAS BEEN SELECTED; UPDATE REMAINING VALUES */ // alright, efficiently estimate the new sigma AND mu through update equations // on the basis of then newly acquired variance estimate, determine whether we // have to recompute sigma and mu switch( best_action ) { case remove : { // REMOVE, use update equations 38 and 39 unsigned int i = active_set[ action_index ]; active_set.erase( active_set.begin() + action_index ); inactive_set.push_back( i ); /* ublas::matrix_column > sigma_j( sigma, action_index );*/ ublas::matrix_column< matrix_type > sigma_j( sigma, action_index ); atlas::axpy( -mu[action_index] / sigma(action_index,action_index), sigma_j, mu ); atlas::syr( -1.0/sigma(action_index,action_index), sigma_j, sigma_symm ); // NOTE TODO VERY inefficient! preserved_shrink( mu, action_index ); preserved_shrink( sigma, action_index, action_index ); theta(i) = 0.0; // also remove from H cache remove_column( H_cache, action_index ); // also remove from HtH cache... remove_column( HtH_cache, action_index ); // also remove from the Hty cache preserved_shrink( Hty_cache, action_index ); if (debug) std::cout << "Deleted " << i << " from the active set " << std::endl; break; } case reestimate: { // RE-ESTIMATE, use update equations 33 and 34 unsigned int i = active_set[ action_index ]; scalar_type kappa = 1.0 / (sigma(action_index,action_index) + (1.0 / (1.0/theta_l_max - 1.0/theta(i)))); /* ublas::matrix_column > sigma_j( sigma, action_index );*/ ublas::matrix_column< matrix_type > sigma_j( sigma, action_index ); atlas::axpy( -kappa * mu[action_index], sigma_j, mu ); // FIXED! BUG!! kappa -> -kappa. atlas::syr( -kappa, sigma_j, sigma_symm ); theta(i) = theta_l_max; if (debug) std::cout << "Reestimated " << i << std::endl; break; } case add : { // CAUSE OF BUG: used row(work_mat, action_index) instead of row(work_mat,i) // CAUSE OF BUG: used Q(action_index) instead of Q(i) // ADD, use update equations 28 and 29 unsigned int i = inactive_set[ action_index ]; inactive_set.erase( inactive_set.begin() + action_index ); active_set.push_back( i ); // determine the sizes unsigned int old_size = sigma.size1(); unsigned int new_size = old_size + 1; // NOTE unclear whether theta_l_max may be used in this case; since at A.2. the // alpha_i is _not_ denoted with a tilde. However, otherwise sigma_ii would always // have value 0. scalar_type sigma_ii = 1.0 / (1.0 / theta_l_max + S(i)); scalar_type mu_i = sigma_ii * Q(i); // std::cout << "sigma_ii " << sigma_ii << std::endl; /* std::cout << "sigma before: " << sigma << std::endl;*/ // perform update of Sigma (equation 28) // TODO FIXME remove beta from the updated matrix? In that case, we don't need to ever // recompute the kernel matrix. atlas::syr( sigma_ii * beta * beta, row(work_mat,i), sigma_symm ); preserved_resize( sigma, new_size, new_size ); ublas::matrix_vector_slice< matrix_type > sigma_row_part( sigma, ublas::slice(old_size,0,old_size), ublas::slice(0,1,old_size)); noalias(sigma_row_part) = -beta * beta * sigma_ii * row(work_mat,i); sigma(old_size,old_size) = sigma_ii; // std::cout << "sigma after: " << sigma << std::endl; // perform update of mu (equation 29) atlas::axpy( -mu_i*beta, row(work_mat,i), mu ); preserved_resize( mu, new_size ); mu[old_size] = mu_i; theta(i) = theta_l_max; // increase the design matrix // H_cache.resize( H_cache.size1(), H_cache.size2() + 1 ); // if( i==0 ) // for( unsigned int r=0; r(active_set.size()); for ( unsigned int i=0; i(m_output.size()) - trace_Sigma_HtH ) << std::endl; //scalar_type heuh2 = residual_sum_of_squares_2( H, mu, active_set, output ) / (static_cast(output.size()) - trace_Sigma_HtH ); atlas::gemv( H_cache, mu, residuals ); atlas::axpy( -1.0, m_output, residuals ); if (debug) std::cout << "rss: " << atlas::dot( residuals, residuals ) << std::endl; scalar_type heuh2 = atlas::dot( residuals, residuals) / (static_cast(m_output.size()) - trace_Sigma_HtH ); // std::cout << "variance could be: " << heuh2 << std::endl; // std::cout << "abs-diff-log var: "; // std::cout << std::abs( log(variance_estimate) - log(heuh2) ) << std::endl; // NOTE: TODO right here, make decisions about whether or not to recompute the sigma and mu vectors variance_estimate = heuh2; if (debug) std::cout << "variance is now: " << variance_estimate << std::endl; // TODO fit a function to the variance estimate after a number of points? // TODO can this be made on-line? // std::cout << "newly estimated mu: " << mu << std::endl; // on the basis of abs(diff(log(var))), consider recomputing sigma and mu (and work_mat), or not. if (debug) { // int qq; // std::cin >> qq; } } if (debug) { std::cout << "Relevance Vector Machine (Tipping, 2003)" << std::endl; std::cout << "Support vectors: " << active_set.size() << std::endl; std::cout << "Variance estimate: " << variance_estimate << std::endl; } /* std::copy( active_set.begin(), active_set.end(), std::ostream_iterator(std::cout, " ") ); std::cout << std::endl;*/ std::vector::iterator bias_loc = std::find( active_set.begin(), active_set.end(), static_cast(0) ); // copy bias to machine if ( bias_loc != active_set.end() ) { bias = mu( bias_loc - active_set.begin() ); preserved_shrink( mu, bias_loc - active_set.begin() ); active_set.erase( bias_loc ); } else { bias = 0.0; } // copy support vectors to base type //base_type::support_vector.resize( active_set.size() ); //base_type::weight.resize( active_set.size() ); //for( unsigned int i=0; i X_row( X, active_set[i]-1 ); // -1 for bias // ublas::matrix_row support_vectors_row( support_vectors, i ); // support_vectors_row.assign( X_row ); // weights( i ) = mu( i ); //base_type::weight[i] = mu( i ); //base_type::support_vector[i] = source[ active_set[i]-1 ]; //} } void add_to_basis( std::size_t index ) { } void remove_from_basis( std::size_t index ) { } // loading and saving capabilities template void serialize( Archive &archive, unsigned int const version ) { archive & boost::serialization::base_object(*this); archive & bias; archive & variance_estimate; } enum { unknown=0, add , reestimate, remove }; // RVM variables scalar_type bias; scalar_type variance_estimate; // the design matrix matrix_type H; } ; // class rvm } // namespace kml namespace boost { namespace serialization { template< typename Problem, typename Kernel, typename PropertyMap, typename Enable > struct tracking_level< kml::rvm > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost #endif kml_src/kml/scale.hpp000644 000765 000024 00000007162 10377266147 015546 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef SCALE_HPP #define SCALE_HPP #include #include #include namespace kml { namespace detail { template class linear_transform: public std::unary_function { public: linear_transform( T const &a, T const &m ): add(a), mult(m) {} inline T operator()(T const &x) const { return prod_element( mult, x+add ); } T add; T mult; }; } // namespace detail /*! Scale a range of data, with mean to mean (default 0) and standard deviation to sd (default 1) \param x a range of scalars x_i \pre length of range > 1 (to compute standard deviation) \pre standard_deviation(range) > machine epsilon (to be able to devide by standard deviation) \returns x_i = (x_i - mean(x)) / sd(x) If a standard deviation happens to be (too close to) zero, it is forced to be 1. The mean will be subtracted in that case, so that element will be 0 for all samples. */ template void scale_mean_sd( Range &x ) { typedef typename boost::range_value::type value_type; // to compute the standard deviation, we need at least two samples if (boost::size(x)>1) { std::transform( boost::begin(x), boost::end(x), boost::begin(x), detail::linear_transform(-mean(x), detail::reciprocal_element(standard_deviation(x))) ); } } /*! Scale a range of data, with minimum to min (default 0) and maximum to max (default 1) \param x a range of scalars x_i or vectors x_i \pre length of range > 1 (to have different minimum and maximum) \pre standard_deviation(range) > machine epsilon (to be able to devide by difference in max and min) \returns x_i = (x_i - min(x)) / (max(x)-min(x)) */ template void scale_min_max( Range &x ) { typedef typename boost::range_value::type value_type; // to get a different a minimum and maximum, we need at least two samples if (boost::size(x)>1) { value_type min(minimum(x)); std::transform( boost::begin(x), boost::end(x), boost::begin(x), detail::linear_transform(-min, detail::reciprocal_element(maximum(x)-min) )); } } } // namespace kml #endif kml_src/kml/sigmoid.hpp000644 000765 000024 00000011327 10426606710 016075 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef SIGMOID_HPP #define SIGMOID_HPP #include #include #include #include #include #include #include #include #include namespace kml { /*! \brief Sigmoid kernel \ingroup kernels */ template class sigmoid: public std::binary_function::type> { public: /*! Refinement of AdaptableBinaryFunction */ typedef T first_argument_type; typedef T second_argument_type; typedef typename input_value::type result_type; /*! Refinement of Kernel? */ typedef sigmoid type; // scalar type.. typedef typename input_value::type scalar_type; friend class boost::serialization::access; /*! Refinement of DefaultConstructible */ sigmoid(): scale(1.0), bias(0.0) {} /*! Refinement of CopyConstructible */ sigmoid( type const &other ) { copy( other ); } /*! Refinement of Assignable */ type &operator=( type const &other ) { if (this != &other) { destroy(); copy(other); } return *this; } /*! Construct a sigmoid kernel by providing a values for gamma and lambda \param gamma the scale of the inner product \param lambda the bias of the inner product */ sigmoid( typename boost::call_traits::param_type gamma, typename boost::call_traits::param_type lambda ): scale(gamma), bias(lambda) {} /*! Kernel constructor by providing TokenIterators */ template sigmoid( typename boost::tokenizer::iterator const begin, typename boost::tokenizer::iterator const end ) { scale = 1.0; bias = 0.0; typename boost::tokenizer::iterator iter(begin); if ( iter != end ) scale = boost::lexical_cast( *iter++ ); if ( iter != end ) bias = boost::lexical_cast( *iter ); } /*! Returns the result of the evaluation of the sigmoid kernel for its arguments \param u input pattern u \param v input pattern v \return \f$ tanh( \gamma * u^T v + \lambda) \f$ */ scalar_type operator()( T const &u, T const &v ) const { return std::tanh( scale * linear()(u,v) + bias ); } // loading and saving capabilities template void serialize( Archive &archive, unsigned int const version ) { archive & scale; archive & bias; } // for debugging purposes friend std::ostream& operator<<(std::ostream &os, type const &k) { os << "Sigmoid kernel tanh(" << k.scale << "+" << k.bias << ")" << std::endl; return os; } private: void copy( type const &other ) { scale = other.scale; bias = other.bias; } scalar_type scale; scalar_type bias; }; } // namespace kml namespace boost { namespace serialization { template struct tracking_level< kml::sigmoid > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost #endif kml_src/kml/srvm.hpp000644 000765 000024 00000064157 10377266147 015455 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef SRVM_HPP #define SRVM_HPP #include #include // #include "traits.hpp" // #include "kernels.h" #include // #include #include /*namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas;*/ namespace lapack = boost::numeric::bindings::lapack; namespace kml { /*! \brief Smooth Relevance Vector Machine \param I the input type \param O the output type \param K the kernel type This class implements a reformulation of the classic Relevance Vector Machine to use a roughness penalty as well. This results in a function which will have derivatives that "behave well", i.e. are continuous up to some order. \section bibliography References -# Rutger ter Borg and Leon Rothkrantz. Smooth Bayesian Kernel Machines. */ template class K > class srvm: public determinate { public: typedef determinate base_type; typedef typename base_type::kernel_type kernel_type; typedef typename base_type::result_type result_type; typedef I input_type; typedef O output_type; typedef double scalar_type; typedef ublas::symmetric_matrix symmetric_type; typedef ublas::matrix matrix_type; typedef ublas::vector vector_type; typedef std::vector index_type; srvm( typename boost::call_traits::param_type k ): base_type(k) {} template void learn( IRange const &input, ORange const &output ) { learn( input, input, output ); } template void learn( IRange const &source, IRange const &target, ORange const &output ) { // create the kernel matrix (symmetric part) // initialise & compute HtH, Hty matrix_type H; kml::design_matrix( source, target, base_type::kernel, 1.0, H ); // TODO ublas::trans functionality has changed since boost 1.32 // TODO use a less heavy call? vector_type Hty( source.size()+1 ); atlas::gemv( CblasTrans, 1.0, H, output, 0.0, Hty ); // output == std::vector, is unknown to ublas::prod. //vector_type Hty( ublas::prod( ublas::trans(H), output) ); symmetric_type HtH( H.size2(), H.size2() ); inner_prod( H, HtH ); // TEST TEST TEST matrix_type L; typename base_type::template kernel_derivative<6>::type kernel2( base_type::kernel.get_parameter() ); kml::design_matrix( source, target, kernel2, 0.0, L ); symmetric_type LtL( H.size2() ); //, H.size2() ); inner_prod( L, LtL ); // explanation of variables, following Tipping (1999) // theta = 1 / alpha std::vector indices( HtH.size1() ); // fill indices with 0,1,2,3,...,N-1. This is not in standard C++, but an SGI extension. iota( indices.begin(), indices.end(), 0 ); vector_type weight_vector( HtH.size1() ); vector_type theta( HtH.size2() ); // theta is 1/alpha, as in Ralf Herbrich's R implementation // since near-zero values are better defined than "very large" values // TODO atlas/standard routine /* atlas::set( 1.0, theta ); atlas::set( 1.0, weight_vector );*/ std::fill( weight_vector.begin(), weight_vector.end(), 1.0 ); std::fill( theta.begin(), theta.end(), 1.0 ); variance = 0.1; roughness_penalty = 0.1; scalar_type max_diff = 1.0; // main loop // Change stopping criterion? while( max_diff > 1e-3 ) { /* std::cout << std::endl;*/ // Prepare the not-yet-inverted part of matrix sigma, and // the non-multiplied part of vector mu // sigma_inv <- (HtH*(1/var)+A) (part of eq. 5) // mu <- Hty (part of eq. 6) scalar_type reciprocal_variance = static_cast(1.0) / variance; ublas::symmetric_matrix sigma_inverted( indices.size(), indices.size() ); ublas::symmetric_matrix S_inverted( indices.size(), indices.size() ); vector_type mu( indices.size() ); /* std::cout << "theta's in use: "; */ for( unsigned int i=0; i(1.0) / theta(index_sv); /* std::cout << theta(index_sv) << " ";*/ } /* std::cout << std::endl;*/ // Invert matrix to form matrix sigma and compute vector mu // TODO symmetric adaptor can go if upper or lower is known (other call to symv) // NOTE recip. variance is probably not most efficient like this. ublas::matrix sigma( indices.size(), indices.size() ); ublas::matrix S( indices.size(), indices.size() ); // temporary workaround for boost non-compileness stuff. //ublas::matrix sigma( ublas::identity_matrix( indices.size() ) ); sigma.clear(); S.clear(); for( unsigned int i=0; i > sigma_symm( sigma ); lapack::ppsv( sigma_inverted, sigma ); // I think this is INCORRECT . . . . (check reference ...... ) //atlas::symv( reciprocal_variance, sigma_symm, mu, 0.0, mu ); // TODO FIXME NOTE check this!! // IMPORTANT ! ! ! ! WAS A CAUSE OF A BUG! ! ! ! ! ! ! ! ! mu = reciprocal_variance * ublas::prod( sigma_symm, mu ); /* std::cout << "vector mu: " << mu << std::endl;*/ // alright, S_inverted contains a subpart of roughness_penalty*LtL at this point // mu contains mu // we need: t(mu) %*% LtL %*% mu // so... compute this... vector_type temp( indices.size() ); scalar_type muLtLmu = 0; if (roughness_penalty > 0.0) { atlas::spmv( 1.0/roughness_penalty, S_inverted, mu, 0.0, temp ); muLtLmu = atlas::dot( mu, temp ); } // std::cout << "muLtLmu is " << muLtLmu << std::endl; // Sigma is also computed at this point, so we can determine the trace of Sigma*roughness_penalty*LtL scalar_type trace_Sigma_LtL = static_cast(0); for( unsigned int i=0; i(1.0) / theta(indices[i]); } lapack::ppsv( S_inverted, S ); // update theta vector // compute sum_i gamma_i scalar_type trace_Sigma_A = static_cast(0); scalar_type trace_S_A = static_cast(0); scalar_type gamma_summed = static_cast(0); max_diff = static_cast(0); for( unsigned int i=0; i( 0.0, (mu(i) * mu(i)) / ((S(i,i)-sigma(i,i))/theta_old) ); gamma_summed += gamma_i; weight_vector( index_sv ) = mu(i); scalar_type diff = std::fabs( std::log(theta_old) - log(theta(index_sv)) ); if ( diff > max_diff ) max_diff=diff; } variance = residual_sum_squares( H, weight_vector, indices, output ) / (static_cast(output.size()) - static_cast(indices.size()) + trace_Sigma_LtL + trace_Sigma_A ); if (muLtLmu > 0.0) { roughness_penalty = (static_cast(indices.size()) - trace_S_A - trace_Sigma_LtL) / muLtLmu; } else roughness_penalty=0.0; // prune support vectors on the basis of the theta vector prune_indices( indices, theta ); for( unsigned int i=0; i (1.0/std::numeric_limits::epsilon())) { theta(indices[i]) = std::numeric_limits::infinity(); } } } std::cout << "Smooth Relevance Vector Machine (Ter Borg, 2005)" << std::endl; std::cout << "Support vectors: " << indices.size() << std::endl; std::cout << "Variance estimate: " << variance << std::endl; std::cout << "Smoothness parameter estimate: " << roughness_penalty << std::endl; if ( indices.front() == 0 ) { base_type::bias = weight_vector(0); indices.erase( indices.begin() ); } else { base_type::bias = 0.0; } base_type::weight.resize( indices.size() ); base_type::support_vector.resize( indices.size() ); for( int i=0; i void train2( MatT const &X, VecT const &y, KF const &kernel = KF() ) { // create the kernel matrix (symmetric part) // initialise & compute HtH, Hty matrix_type H; kml::design_matrix( X, X, kernel, 1.0, H ); vector_type Hty( ublas::prod( ublas::trans(H), y ) ); //atlas::gemv(ublas::trans(H), y, Hty); symmetric_type HtH( H.size2(), H.size2() ); inner_prod( H, HtH ); std::map L; std::map lambda; std::vector orders; orders.push_back( 4 ); kml::gaussian,4 > kernelD4( kernel.param ); kml::design_matrix( X, X, kernelD4, 0.0, L[4] ); lambda[4] = 0.5; orders.push_back( 6 ); kml::gaussian,6 > kernelD6( kernel.param ); kml::design_matrix( X, X, kernelD6, 0.0, L[6] ); lambda[6] = 0.5; orders.push_back( 8 ); kml::gaussian,8 > kernelD8( kernel.param ); kml::design_matrix( X, X, kernelD8, 0.0, L[8] ); lambda[8] = 0.5; // orders.push_back( 10 ); // Gaussian kernelD10( sigma(1.6) ); // kml::design_matrix( X, X, kernelD10, L[10] ); // lambda[10] = 0.5; orders.push_back( 12 ); Gaussian kernelD12( sigma(1.6) ); kml::design_matrix( X, X, kernelD12, L[12] ); lambda[12] = 0.1; // define the matrix we will use as temporary matrix_type L_sum( L[4].size1(), L[4].size2() ); symmetric_type LtL( H.size2(), H.size2() ); matrix_type LitL( H.size2(), H.size2() ); //HtH += 0.1 * LtL; // TEST TEST TEST // explanation of variables, following Tipping (1999) // theta = 1 / alpha std::vector indices( HtH.size1() ); // fill indices with 0,1,2,3,...,N-1. This is not in standard C++, but an SGI extension. iota( indices.begin(), indices.end(), 0 ); vector_type weight_vector( HtH.size1() ); vector_type theta( HtH.size2() ); // theta is 1/alpha, as in Ralf Herbrich's R implementation // since near-zero values are better defined than "very large" values //atlas::set( 1.0, theta ); //atlas::set( 1.0, weight_vector ); std::fill( theta.begin(), theta.end(), 1.0 ); std::fill( weight_vector.begin(), weight_vector.end(), 1.0 ); variance_estimate = 0.1; scalar_type max_diff = 1.0; int iters=0; // RVM's main loop while( max_diff > 1e-3 ) { std::cout << "iteration " << iters++ << std::endl; // re-compute LtL, on the basis of all lambda's and L's // TODO: automatic loop unrollment for this expression noalias(L_sum) = lambda[4]*L[4] + lambda[6]*L[6] + lambda[8]*L[8]; // + lambda[10]*L[10] + lambda[12]*L[12]; // noalias(L_sum) = lambda[12]*L[12]; std::cout << "..." << std::endl; inner_prod( L_sum, LtL ); // Prepare the not-yet-inverted part of matrix sigma, and // the non-multiplied part of vector mu // sigma_inv <- (HtH*(1/var)+A) (part of eq. 5) // mu <- Hty (part of eq. 6) scalar_type reciprocal_variance = static_cast(1.0) / variance_estimate; ublas::symmetric_matrix sigma_inverted( indices.size(), indices.size() ); ublas::symmetric_matrix S_inverted( indices.size(), indices.size() ); vector_type mu( indices.size() ); for( unsigned int i=0; i(1.0) / theta(index_sv); } // Invert matrix to form matrix sigma and compute vector mu // sigma <- (HtH*(1/var)+A)^-1 (equation 5, Tipping, 1999) // mu <- (1/var)*sigma*Hty (equation 6, Tipping, 1999) // TODO symmetric adaptor can go if upper or lower is known (other call to symv) // NOTE recip. variance is probably not most efficient like this. ublas::matrix sigma( indices.size(), indices.size() ); ublas::matrix S( indices.size(), indices.size() ); // temporary workaround for boost non-compileness stuff. //ublas::matrix sigma( ublas::identity_matrix( indices.size() ) ); sigma.clear(); S.clear(); for( unsigned int i=0; i > sigma_symm( sigma ); lapack::ppsv( sigma_inverted, sigma ); // NOTE TODO BUG ! ! ! ! ! ! ! ! ! ! ! ! ! ! atlas::symv( reciprocal_variance, sigma_symm, mu, 0.0, mu ); // Sigma is also computed at this point, so we can determine the trace of Sigma*LtL scalar_type trace_Sigma_LtL = static_cast(0); for( unsigned int i=0; i > sigma_row( sigma, i ); ublas::matrix_column > LtL_col( S_inverted, i ); trace_Sigma_LtL += ublas::inner_prod( sigma_row, LtL_col ); } //std::cout << "trace Sigma LtL is " << trace_Sigma_LtL << std::endl; // complete S_inv by adding A to it for( unsigned int i=0; i(1.0) / theta(indices[i]); } lapack::ppsv( S_inverted, S ); // update theta vector // compute sum_i gamma_i //scalar_type trace_SA = static_cast(0); scalar_type trace_Sigma_A = static_cast(0); scalar_type trace_S_A = static_cast(0); scalar_type gamma_summed = static_cast(0); max_diff = static_cast(0); for( unsigned int i=0; i max_diff ) max_diff=diff; } std::cout << "trace Sigma_A: " << trace_Sigma_A << std::endl; std::cout << "trace S_A: " << trace_S_A << std::endl; std::cout << "trace Sigma_LtL: " << trace_Sigma_LtL << std::endl; std::cout << "gamma summed is " << gamma_summed << std::endl; std::cout << "alternative is " << -static_cast(indices.size()) + trace_Sigma_A + trace_Sigma_LtL << std::endl; std::cout << "N-Tr(Sigma*sigma^-2*HtH) = " << static_cast(y.size())-static_cast(indices.size()) + trace_Sigma_A + trace_Sigma_LtL << std::endl; // std::cout << "vector gamma: " << gamma << std::endl; std::cout << "vector mu: " << mu << std::endl; variance_estimate = residual_sum_squares( H, weight_vector, indices, y ) / (static_cast(y.size()) - static_cast(indices.size()) + trace_Sigma_LtL + trace_Sigma_A ); std::cout << "current parameters lambda: "; for( unsigned int i=0; i 0.0) { // atlas::spmv( 1.0/lambda, S_inverted, mu, 0.0, temp ); // muLtLmu = atlas::dot( mu, temp ); // } //std::cout << "muLtLmu is " << muLtLmu << std::endl; for( unsigned int i=0; i 0.0) { // lambda = (static_cast(indices.size()) - trace_S_A - trace_Sigma_LtL) / muLtLmu; // } else lambda=0.0; // std::cout << "current lambda: " << lambda << std::endl; // prune support vectors on the basis of the theta vector // what to do? 1) prune if below singularity limit of matrix // 2) ehhh...... prune_indices( indices, theta ); int qq; std::cin >> qq; } std::cout << "Smooth Relevance Vector Machine (Ter Borg, 2004)" << std::endl; std::cout << "support vectors: "; std::copy( indices.begin(), indices.end(), std::ostream_iterator(std::cout, " ") ); std::cout << std::endl; std::cout << "variance estimate: " << variance_estimate << std::endl; std::cout << "smoothness parameter lambda: "; for( unsigned int i=0; i X_row( X, indices[i]-1 ); // -1 for bias // ublas::matrix_row support_vectors_row( support_vectors, i ); // support_vectors_row.assign( X_row ); // } } */ #endif kml_src/kml/statistics.hpp000644 000765 000024 00000027425 10377266147 016655 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef STATISTICS_HPP #define STATISTICS_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace kml { namespace detail { // multiplied difference, (x-mu_1)(y-mu_2), used by covariance estimator // used as binary_op2 in std::inner_product (explains operator()) template class multiply_diff: public std::binary_function { public: multiply_diff( T const &m_x, T const &m_y ): mean_x(m_x), mean_y(m_y) {} inline T operator()(T const &x, T const &y) const { return prod_element(x-mean_x, y-mean_y); } T mean_x; T mean_y; }; // squared difference (x-mu)^2, used by variance estimator // used by accumulate (explains operator()) template class squared_diff: public std::binary_function { public: squared_diff( T const &m ): mean(m) {} inline T operator()(T const &x, T const &y) const { T temp = y-mean; return (x+prod_element(temp,temp)); } T mean; }; // just to compute the square for each element template struct square: public std::binary_function { inline T operator()( T const &sum, T const &x ) const { return sum + prod_element(x,x); } }; // square, accumulate inner prod for vectors template struct dot_square: public std::binary_function::type const&, T const &, typename input_value::type> { typedef typename input_value::type value_type; inline value_type operator()( value_type const &sum, T const &x ) const { return sum + scale_or_dot(x,x); } }; } // namespace detail /*! The sum of a range \param x a range of either scalars or vectors \return sum(x_i) A requirement is that the plus operator is defined on the value_type of the range. */ template typename boost::range_value::type sum( Range const &x ) { typedef typename boost::range_value::type value_type; typedef typename boost::range_const_iterator::type const_iterator_type; if ( boost::size(x) == 1 ) return *boost::begin(x); else { const_iterator_type my_iterator = boost::begin(x); ++my_iterator; return std::accumulate( my_iterator, boost::end(x), static_cast(*boost::begin(x)) ); } } /*! The minimum of a range \param x a range of scalar values or vectors \return min(x) A requirement is that std::max works on the value_type of the range. If x is a vector, a vector is returned with element-wise minima. */ template typename boost::range_value::type minimum( Range const &x ) { typedef typename boost::range_value::type value_type; typedef typename boost::range_const_iterator::type const_iterator_type; if ( boost::size(x) == 1 ) return *boost::begin(x); else { const_iterator_type my_iterator = boost::begin(x); ++my_iterator; return std::accumulate( my_iterator, boost::end(x), static_cast(*boost::begin(x)), boost::bind( &detail::min_element, _1, _2 ) ); } } /*! The maximum of a range \param x a range of scalar values or vectors \return max(x) A requirement is that std::max works on the value_type of the range. If x is a vector, a vector is returned with element-wise maxima. */ template typename boost::range_value::type maximum( Range const &x ) { typedef typename boost::range_value::type value_type; typedef typename boost::range_const_iterator::type const_iterator_type; if ( boost::size(x) == 1 ) return *boost::begin(x); else { const_iterator_type my_iterator = boost::begin(x); ++my_iterator; return std::accumulate( my_iterator, boost::end(x), static_cast(*boost::begin(x)), boost::bind( &detail::max_element, _1, _2 ) ); } } /*! Unbiased estimator for the population mean \param x a range of either scalar values or vectors \return mean(x) = 1/n * sum(x_i) A requirement is that the plus operator is defined on the value_type of the range, and that the value_type can be divided by a scalar_type. */ template typename boost::range_value::type mean( Range const &x ) { typedef typename boost::range_value::type value_type; typedef typename input_value::type scalar_type; if (boost::empty(x)) return std::numeric_limits::quiet_NaN(); else return sum(x) / static_cast( boost::size(x) ); } /*! Unbiased estimator for the population variance \param x a range of scalar values or vectors \return variance(x) = 1/(n-1) * sum( (x_i-mean(x))^2 ) In case of vector values, it will return a vector with the variance for each element */ template typename boost::range_value::type variance( Range const &x ) { typedef typename boost::range_value::type value_type; typedef typename input_value::type scalar_type; if (boost::size(x)<2) return std::numeric_limits::quiet_NaN(); else { return std::accumulate( boost::begin(x), boost::end(x), detail::zero_element(*boost::begin(x)), detail::squared_diff(mean(x)) ) / static_cast(boost::size(x)-1); } } /*! Unbiased estimator for the population standard deviation \param x a range of scalar values or vectors \return sqrt(variance(x)) In case of vector values, it will return a vector with the standard deviation for each element */ template typename boost::range_value::type standard_deviation( Range const &x ) { return detail::sqrt_element( variance(x) ); } /*! Mean square, or the quadratic mean, see http://mathworld.wolfram.com/Root-Mean-Square.html \param x a range of scalar values or vectors \return mean_square(x) = 1/n * sum( x_i^2 ) In case of vector values, it will return a vector with the root-mean-square for each element */ template typename boost::range_value::type mean_square( Range const &x ) { typedef typename boost::range_value::type value_type; typedef typename input_value::type scalar_type; if (boost::empty(x)) return std::numeric_limits::quiet_NaN(); else return std::accumulate( boost::begin(x), boost::end(x), detail::zero_element(*boost::begin(x)), detail::square() ) / static_cast(boost::size(x)); } /*! Root-mean-square, see http://mathworld.wolfram.com/Root-Mean-Square.html \param x a range of scalar values or vectors \return root_mean_square(x) = sqrt(mean_square(x)) In case of vector values, it will return a vector with the root-mean-square for each element */ template typename boost::range_value::type root_mean_square( Range const &x ) { return detail::sqrt_element( mean_square(x) ); } /*! Mean-dot. In case of vectors, this function uses the dot-product instead of squaring each element separately \param x a range of scalar_values or vectors \return vector_mean_square(x) = 1/n * sum( scale_or_dot(x_i,x_i) ) */ template typename input_value::type>::type mean_dot( Range const &x ) { typedef typename boost::range_value::type value_type; typedef typename input_value::type scalar_type; if (boost::empty(x)) return std::numeric_limits::quiet_NaN(); else return std::accumulate( boost::begin(x), boost::end(x), scalar_type(0), detail::dot_square() ) / static_cast(boost::size(x)); } /*! Unbiased estimator for the population covariance \param x a range of scalar values or vectors \param y a range of scalar values or vectors \return cov(x,y) = 1/(n-1) * sum( (x_i-mean(x))*(y_i-mean(y)) ) In case of vector values, it will return a vector with the covariance per element -- not a covariance matrix */ template typename boost::range_value::type covariance( Range const &x, Range const &y ) { typedef typename boost::range_value::type value_type; typedef typename input_value::type scalar_type; if ( (boost::size(x) != boost::size(y)) || (boost::size(x)<2) ) return std::numeric_limits::quiet_NaN(); else return std::inner_product( boost::begin(x), boost::end(x), boost::begin(y), detail::zero_element(*boost::begin(x)), std::plus(), detail::multiply_diff(mean(x), mean(y)) ) / static_cast(boost::size(x)-1); } /*! Statistical correlation of two ranges \param x a range of scalar values or vectors \param y a range of scalar values or vectors \return cor(x,y) = cov(x,y) / ( sd(x)*sd(y) ) In case of vector values, it will return a vector with the correlation per element */ template typename boost::range_value::type correlation( Range const &x, Range const &y ) { return detail::div_element( covariance(x,y), detail::prod_element( standard_deviation(x), standard_deviation(y) ) ); } template Range abs( Range const &x ) { return detail::abs_element( x ); } } // namespace kml #endif kml_src/kml/svm.hpp000644 000765 000024 00000041541 11126622534 015250 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * SMO Implementation copyright (C) 2005--2006 by Meredith L. Patterson * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ /***************************************************************************** * Department of Credit Where Credit is Due: * * This program uses the Sequential Minimal Optimization (SMO) algorithm, * * originally developed by John Platt. You can find the pseudocode for it at * * http://research.microsoft.com/users/jplatt/smo.html. * * * * The ranking SVM uses a technique developed by Thorsten Joachims in * * "Optimizing Search Engines Using Clickthrough Data," Proceedings of the * * ACM Conference on Knowledge Discovery and Data Mining (KDD), ACM, 2002. * *****************************************************************************/ #ifndef SVM_HPP #define SVM_HPP #define EPS .001 #define sgn(a) (((a) < 0) ? -1 : ((a) > 0) ? 1 : 0) #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 namespace lambda = boost::lambda; namespace ublas = boost::numeric::ublas; namespace kml { template class svm: public kernel_machine {}; // Classification SVM template class svm >::type>: public kernel_machine { public: typedef kernel_machine base_type; typedef typename base_type::kernel_type kernel_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef double scalar_type; typedef typename boost::property_traits::key_type key_type; typedef typename boost::property_traits::value_type object_type; svm( typename boost::call_traits::param_type k, typename boost::call_traits::param_type max_weight, typename boost::call_traits::param_type map ): base_type(k, map), C(max_weight), tol(.001), bias(0), startpt(randomness) { } svm( typename boost::call_traits::param_type k, typename boost::call_traits::param_type max_weight, typename boost::call_traits >::param_type map ): base_type(k, map), C(max_weight), tol(.001), bias(0), startpt(randomness) { } svm(svm &s): base_type(s.kernel_function, *(s.data)), startpt(randomness) { C = s.C; weight = s.weight; tol = .0001; bias = s.bias; } ~svm() { } output_type operator() (input_type const &x) { scalar_type ret=0; for (size_t i=0; i 0) ret += weight[i] * base_type::output(i) * base_type::kernel(x, i); ret -= bias; return (output_type)ret; } int takeStep(int i1, int i2) { if (i1 == i2) return 0; double alpha1 = weight[i1]; output_type y1 = base_type::output(i1); scalar_type e1, e2, L, H, a2; /* p. 49, Platt: "When an error E is required by SMO, it will look up the error in the error cache if the corresponding Lagrange multiplier is not at bound." */ if (0 != alpha1 && C != alpha1) e1 = error_cache[i1]; else e1 = operator()(base_type::input(i1)) - y1; double alpha2 = weight[i2]; output_type y2 = base_type::output(i2); /* p. 49 again */ if (0 != alpha2 && C != alpha2) e2 = error_cache[i2]; else e2 = (double)operator()(base_type::input(i2)) - y2; scalar_type s = y1 * y2; if (y1 != y2) { L = std::max(0.0, alpha2 - alpha1); H = std::min(C, C + alpha2 - alpha1); } else { /* Equation 12.3 */ L = std::max(0.0, alpha1 + alpha2 - C); /* Equation 12.4 */ H = std::min(C, alpha1 + alpha2); } if (L == H) return 0; scalar_type k11 = base_type::kernel(i1, i1); scalar_type k12 = base_type::kernel(i1, i2); scalar_type k22 = base_type::kernel(i2, i2); /* Equation 12.5 -- the second derivative of W, the objective function */ double eta = 2 * k12 - k11 - k22; if (eta < 0) { /* Equation 12.6 */ a2 = alpha2 - y2 * (e1-e2) / eta; /* Equation 12.7 */ if (a2 < L) a2 = L; else if (a2 > H) a2 = H; } else { /* This block handles corner cases; usually this means a training vector has been repeated */ scalar_type f1 = operator()(base_type::input(i1)); scalar_type f2 = operator()(base_type::input(i2)); /* Equation 12.21 */ scalar_type v1 = f1 + bias - base_type::output(i1) * alpha1 * k11 - base_type::output(i2) * alpha2 * k12; scalar_type v2 = f2 + bias - base_type::output(i1) * alpha1 * k12 - base_type::output(i2) * alpha2 * k22; /* Equation 12.22 */ scalar_type gamma = alpha1 + s * alpha2; /* Equation 12.23 -- this is ugly and should maybe be refactored out? */ scalar_type Lobj = gamma - s * L + L - .5 * k11 * (gamma - s * L) * (gamma - s * L) - .5 * k22 * L * L - s * k12 * (gamma - s * L) * L - base_type::output(i1) * (gamma - s * L) * v1 - base_type::output(i2) * L * v2; scalar_type Hobj = gamma - s * H + H - .5 * k11 * (gamma - s * H) * (gamma - s * H) - .5 * k22 * L * L - s * k12 * (gamma - s * H) * H - base_type::output(i1) * (gamma - s * H) * v1 - base_type::output(i2) * H * v2; /* Now we move the Lagrangian multipliers to the endpoint which has the highest value for W */ if (Lobj > Hobj + EPS) a2 = L; else if (Lobj < Hobj - EPS) a2 = H; else a2 = alpha2; } /* If a2 is within epsilon of 0 or C, then call it a boundary example */ if (a2 < .00000001) a2 = 0; else if (a2 > C - .00000001) a2 = C; if (fabs(a2 - alpha2) < EPS*(a2 + alpha2 + EPS)) return 0; /* Equation 12.8 */ double a1 = alpha1 + s*(alpha2 - a2); if (a1 < 0) { a2 += s*a1; a1 = 0; } else if (a1 > C) { a2 += s * (a1 - C); a1 = C; } scalar_type old_bias = bias; /* Equation 12.9 */ if (0 != a1 && C != a1) bias += e1 + y1 * (a1 - alpha1) * k11 + y2 * (a2 - alpha2) * k12; else { if (0 != a2 && C != a2) bias += e2 + y1 * (a1 - alpha1) * k12 + y2 * (a2 - alpha2) * k22; else bias = ((bias + e1 + y1 * (a1 - alpha1) * k11 + y2 * (a2 - alpha2) * k12) + (bias + e2 + y1 * (a1 - alpha1) * k12 + y2 * (a2 - alpha2) * k22)) / 2; } /* TODO figure out what to do about weight vectors for linear SVMs */ /* Update the error cache */ for (size_t i = 0; i < error_cache.size(); ++i) { if (0 != weight[i] && C != weight[i]) { error_cache[i] += y1 * (a1 - alpha1) * base_type::kernel(i, i1) + base_type::output(i2) * (a2 - alpha2) * base_type::kernel(i, i2) - (bias - old_bias); } else { /* This may not actually be necessary -- I'm not convinced any code paths will ever get here -- but since Platt says we only keep cached error values if the Lagrange multiplier is non-bound, I'm covering my bases. */ if (error_cache[i] > 0) error_cache[i] = 0; } } /* p. 49, Platt: "When a Lagrange multiplier is non-bound and is involved in a joint optimization, its cached error is set to zero." But, hey, if it's a bound multiplier, we don't cache its error. So just make it zero anyway. */ error_cache[i1] = 0; error_cache[i2] = 0; weight[i1] = a1; weight[i2] = a2; return 1; } int examineExample(int idx) { output_type y2 = base_type::output(idx); double alpha2 = weight[idx]; scalar_type e2; if (alpha2 != 0 && alpha2 != C) e2 = error_cache[idx]; else e2 = operator()(base_type::input(idx)) - y2; scalar_type r2 = e2 * y2; if ((r2 < -tol && alpha2 < C) || (r2 > tol && alpha2 > 0)) { int count = std::count_if(weight.begin(), weight.end(), (lambda::_1 != 0) && (lambda::_1 != C) ); if (count > 1) { // use second choice heuristic scalar_type tmp = 0, tmp2 = 0; int k = 0; for (size_t i = 0; i < error_cache.size(); ++i) { tmp2 = fabs(error_cache[idx] - error_cache[i]); if (tmp2 > tmp) { tmp = tmp2; k = i; } } if (takeStep(idx, k)) return 1; } for (size_t i = startpt(size), j = i; i void learn(KeyIterator begin, KeyIterator end) { size = std::distance(begin, end); weight.clear(); weight.resize(size); error_cache.clear(); error_cache.resize(size); bias = 0; int numChanged = 0; int examineAll = 1; while (numChanged > 0 || examineAll) { numChanged = 0; if (examineAll) for (size_t i=0; i < size; ++i) numChanged += examineExample(i); else for (size_t i=0; i < size; ++i) if (weight[i] != 0 && weight[i] != C) numChanged += examineExample(i); if (1 == examineAll) examineAll = 0; else if (0 == numChanged) examineAll = 1; } } void printweights() { for ( size_t i=0; i get_alpha() { std::vector ret; std::remove_copy_if(weight.begin(), weight.end(), std::back_inserter(ret), std::bind2nd(std::equal_to(), 0)); return ret; } std::vector get_svs() { std::vector ret; for (size_t i=0; i weight; scalar_type tol; scalar_type bias; std::vector error_cache; boost::mt19937 randomness; boost::random_number_generator startpt; }; // Ranking SVM. // data<0> is the point; data<1> is the group it belongs in; data<2> is the rank assigned to it. template class svm >::type >: public kernel_machine { public: typedef kernel_machine base_type; typedef typename base_type::kernel_type kernel_type; typedef double scalar_type; typedef typename Problem::input_type input_type; typedef typename Problem::output_type output_type; typedef boost::tuple inner_example_type; typedef kml::classification inner_problem_type; typedef boost::vector_property_map InnerPropertyMap; typedef svm inner_svm_type; friend class boost::serialization::access; svm( typename boost::call_traits::param_type k, typename boost::call_traits::param_type max_weight, typename boost::call_traits::param_type map): base_type(k, map), C(max_weight), inner_data(new InnerPropertyMap), inner_machine(k, max_weight, inner_data) { } svm( typename boost::call_traits::param_type k, typename boost::call_traits::param_type max_weight, typename boost::call_traits >::param_type map): base_type(k, map), C(max_weight), inner_data(new InnerPropertyMap()), inner_machine(k, max_weight, inner_data) { } output_type operator()(input_type const &x) { return inner_machine(x); } input_type make_diff(input_type &i, input_type &j) { input_type diff_vec; std::transform(i.begin(), i.end(), j.begin(), std::back_inserter(diff_vec), std::minus::type>()); return diff_vec; } // TODO find out if propertymaps can use push_back template typename boost::enable_if > >::type add_point(input_type &i, input_type &j, unsigned int count, int target) { (*inner_data)[count] = boost::make_tuple(i, target); } template typename boost::enable_if >::type add_point(input_type &i, input_type &j, unsigned int count, int target) { (*inner_data)[count] = boost::make_tuple(make_diff(i, j), target); } template void learn(KeyIterator begin, KeyIterator end) { size = std::distance(begin, end); unsigned int count=0; bool already_greater, already_lesser; for (unsigned int i = 0; i < size-1; ++i) { already_greater = false; already_lesser = false; for (unsigned int j = i+1; j < size; ++j) { if (base_type::output(i) == (*base_type::data)[j].get<1>()) { if ((*base_type::data)[i].get<2>() > (*base_type::data)[j].get<2>()) { if (!already_greater) { add_point(base_type::input(i), (*base_type::data)[j].get<0>(), count, 1); already_greater = true; ++count; } } else if ((*base_type::data)[i].get<2>() < (*base_type::data)[j].get<2>()) { if (!already_lesser) { add_point(base_type::input(i), (*base_type::data)[j].get<0>(), count, -1); already_lesser = true; ++count; } } } } } /* Let's see if artificially creating a second class works */ // 072507 this may not be necessary anymore bool one_class = true; for (unsigned int i=1; i() != (*inner_data)[0].get<1>()) { one_class = false; break; } if (one_class) { for (unsigned int i=0; i(std::transform((*inner_data)[i].get<0>().begin(), (*inner_data)[i].get<0>().end(), (*inner_data)[i].get<0>().begin(), std::negate()), (*inner_data)[i].get<0>().end()), -(*inner_data)[i].get<1>()); } inner_machine.set_data(inner_data); inner_machine.learn(inner_data->storage_begin(), inner_data->storage_end()); } unsigned int get_size() { return size; } scalar_type get_C() { return C; } std::vector get_alpha() { return inner_machine.get_alpha(); } std::vector get_svs() { return inner_machine.get_svs(); } unsigned int size; scalar_type epsilon; scalar_type C; boost::shared_ptr inner_data; inner_svm_type inner_machine; }; } // namespace kml #endif kml_src/kml/svm_c.h000644 000765 000024 00000004100 10672121047 015176 0ustar00pawelmstaff000000 000000 #ifndef SVM_C_H #define SVM_C_H #ifdef __cplusplus extern "C" { #endif void* kml_new_class_double_gaussian(double k, double s); void* kml_copy_class_double_gaussian(void *v); void kml_delete_class_double_gaussian(void *v); void kml_learn_class_double_gaussian(void *v, double **p, int *t, int sz_row, int sz_col); double kml_classify_double_gaussian(void *v, double *i, int sz); void* kml_new_rank_double_gaussian(double k, double s); void* kml_copy_rank_double_gaussian(void *v); void kml_delete_rank_double_gaussian(void *v); void kml_learn_rank_double_gaussian(void *v, double **p, int *g, int *t, int sz_row, int sz_col); double kml_rank_double_gaussian(void *v, double *i, int sz); void* kml_new_class_double_polynomial(double g, double l, double d, double s); void* kml_copy_class_double_polynomial(void *v); void kml_delete_class_double_polynomial(void *v); void kml_learn_class_double_polynomial(void *v, double **p, int *t, int sz_row, int sz_col); double kml_classify_double_polynomial(void *v, double *i, int sz); void* kml_new_rank_double_polynomial(double g, double l, double d, double s); void* kml_copy_rank_double_polynomial(void *v); void kml_delete_rank_double_polynomial(void *v); void kml_learn_rank_double_polynomial(void *v, double **p, int *t, int *g, int sz_row, int sz_col); double kml_rank_double_polynomial(void *v, double *i, int sz); void* kml_new_class_double_linear(double s); void* kml_copy_class_double_linear(void *v); void kml_delete_class_double_linear(void *v); void kml_learn_class_double_linear(void *v, double **p, int *t, int sz_row, int sz_col); double kml_classify_double_linear(void *v, double *i, int sz); void* kml_new_rank_double_linear(double s); void* kml_copy_rank_double_linear(void *v); void kml_delete_rank_double_linear(void *v); void kml_learn_rank_double_linear(void *v, double **p, int *t, int *g, int sz_row, int sz_col); double kml_rank_double_linear(void *v, double *i, int sz); #ifdef __cplusplus } #endif #endif // SVM_C_H kml_src/kml/symmetric_view.hpp000644 000765 000024 00000030115 10412446744 017510 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef SYMMETRIC_VIEW_HPP #define SYMMETRIC_VIEW_HPP #include #include #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace atlas = boost::numeric::bindings::atlas; namespace kml { /*! \brief A symmetric view of a dense matrix. \param M underlying dense matrix class This class provides a view of a symmetric matrix, and performs efficient memory management by cutting down the number of calls to .resize() of the underlying matrix. If we consider a matrix that grows by one row or column at a time, a naive resize strategy would cost O(N) memory allocation calls. It will become quadratically more expensive to copy the content of the matrix as it grows in size. Because of this, memory management is done in a similar way as that of std::vector. If needed, the size of the underlying matrix is doubled in the number of rows or in the number of columns. This takes O(log N) memory allocation calls only, delivering a considerable speedup over the naive approach. It is assumed that the symmetric view changes by 1 row and 1 column simultaneously at a time, for which member functions are available. It can be directly used in conjunction with calls to atlas bindings, as shown below. \code kml::symmetric_view< ublas::matrix > A; // view in matrix A ublas::vector x; // vector x ublas::vector b; // result vector b atlas::symv( A.view(), x, b ); // compute b <- Ax \endcode */ template class symmetric_view { public: friend class boost::serialization::access; typedef ublas::vector vector_type; typedef M matrix_type; typedef typename M::size_type size_type; symmetric_view() { // 1 by 1, for fast growth determination later on (i.e. use size * 2) matrix.resize(1,1,false); view_rows=0; view_cols=0; } // if you have some pre-knowledge, or want to pre-reserve memory // does not preserve the matrix!! void reserve( size_type rows, size_type cols ) { view_rows = rows; view_cols = cols; matrix.resize( std::max(rows,1), std::max(cols,1), false ); } /*! Increase the number of columns and the number of rows in the symmetric view by one. */ void grow_row_column() { if ( view_rows == matrix.size1() ) matrix.resize( matrix.size1() << 1, matrix.size2() << 1 ); ++view_rows; ++view_cols; } /*! Remove a column from the current matrix view at a given column index. \param index the n'th column, first column is located at 0. Keep the order of columns as they are, so all columns have to be "moved to the left". This is not the most efficient strategy in removing a column, */ void remove_column( int index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); for( size_type i=index; i<(view_cols-1); ++i ) { ublas::matrix_column< ublas::matrix_range > cur_col( matrix_view, i); ublas::matrix_column< ublas::matrix_range > next_col( matrix_view, i+1); atlas::copy( next_col, cur_col ); } --view_cols; } // copies the last column to index and decreases the view_cols void swap_remove_column( int index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); ublas::matrix_column< ublas::matrix_range > last_col( matrix_view, view_cols-1); ublas::matrix_column< ublas::matrix_range > index_col( matrix_view, index ); atlas::copy( last_col, index_col ); --view_cols; } // NOTE shouldn't this be done with atlas::copy as well? void remove_row( size_type index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); for( size_type i=index; i<(view_rows-1); ++i ) { ublas::row(matrix_view,i).assign( ublas::row(matrix_view,i+1)); } --view_rows; } // copies the last row to index and decreases the view_rows void swap_remove_row( size_type index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); ublas::matrix_row< ublas::matrix_range > last_row( matrix_view, view_rows-1); ublas::matrix_row< ublas::matrix_range > index_row( matrix_view, index); atlas::copy( last_row, index_row ); --view_rows; } void remove_row_col( size_type index ) { remove_column(index); remove_row(index); } // work for: row_major matrix with a symmetric view adaptor (row major as well) // warning: sensitive code void swap_remove_row_col( size_type index ) { ublas::matrix_range matrix_view(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); size_type index_last = view_rows-1; // perhaps this is an overkill for 1 atlas-op. // perhaps can be done with 2 matrix vector slices? ublas::matrix_row< ublas::matrix_range > last_row( matrix_view, index_last ); ublas::matrix_row< ublas::matrix_range > index_row( matrix_view, index ); ublas::vector_range< ublas::matrix_row< ublas::matrix_range > > last_row_part_1( last_row, ublas::range(0,index) ); ublas::vector_range< ublas::matrix_row< ublas::matrix_range > > index_row_part_1( index_row, ublas::range(0,index) ); atlas::copy( last_row_part_1, index_row_part_1 ); // and a difficult element copy, in same direction. can be atlasified // note that index_last is one less than the matrix size for( size_type i=index+1; i index,index matrix( index, index ) = matrix( index_last, index_last ); --view_rows; --view_cols; } void flush() { matrix.resize( view_rows, view_cols, true ); } size_type const size1() const { return view_rows; } size_type const size2() const { return view_cols; } inline ublas::matrix_range const view() { return ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)); } // also provide shrinked views: this is very useful for the inverted matrix updates // i.e. the matrix is resized first, and then an algorithm computes the updated inverse inline ublas::matrix_range const shrinked_view() { return ublas::matrix_range(matrix, ublas::range(0,view_rows-1),ublas::range(0,view_cols-1)); } inline ublas::matrix_row< ublas::matrix_range > const row( size_type const nr ) { return ublas::row( ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)), nr ); } inline ublas::matrix_vector_slice const shrinked_row( size_type const nr ) { return ublas::matrix_vector_slice( matrix, ublas::slice( nr, 0, view_cols-1 ), ublas::slice( 0, 1, view_cols-1 ) ); } // inline ublas::matrix_row< ublas::matrix_range > const shrinked_row( size_type const nr ) { // return ublas::row( ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols-1)), nr ); // } inline ublas::matrix_column< ublas::matrix_range > const column( size_type const nr ) { return ublas::column( ublas::matrix_range(matrix, ublas::range(0,view_rows),ublas::range(0,view_cols)), nr ); } inline ublas::matrix_column< ublas::matrix_range > const shrinked_column( size_type const nr ) { return ublas::column( ublas::matrix_range(matrix, ublas::range(0,view_rows-1),ublas::range(0,view_cols)), nr ); } void shrink_inverse( size_type index ) { // remove from the inverse matrix if ( view_rows==2) { --view_rows; --view_cols; matrix(0,0)=0.0; } else { ublas::matrix_range< ublas::matrix > my_range( view() ); ublas::symmetric_adaptor< ublas::matrix_range< ublas::matrix > > my_symm_view( my_range ); // take a correct row, from the symmetric adaptor!! vector_type temp_row( ublas::row( my_symm_view, index ) ); atlas::syr( -1.0/matrix(index,index), temp_row, my_symm_view ); // NOTE removing a row_col can be done more efficiently if // the matrix is symmetric remove_row( index ); remove_column( index ); } } // loading and saving capabilities template void save( Archive &archive, unsigned int const version ) const { // make a copy of the view and save that part only M matrix_copy( ublas::subrange(matrix, 0, view_rows, 0, view_cols )); archive << matrix_copy; } template void load( Archive &archive, unsigned int const version ) { // restore the copy of the view archive >> matrix; // store the view size view_rows = matrix.size1(); view_cols = matrix.size2(); // find the value of the MSB of the view_rows, that multiplied by 2 should equal pow2_rows unsigned int find_pow2_rows = view_rows; unsigned int pow2_rows = 1; while( find_pow2_rows > 0 ) { find_pow2_rows >>= 1; pow2_rows <<= 1; } // find the value of the MSB of the view_cols, that multiplied by 2 should equal pow2_cols unsigned int find_pow2_cols = view_cols; unsigned int pow2_cols = 1; while( find_pow2_cols > 0 ) { find_pow2_cols >>= 1; pow2_cols <<= 1; } // (preserved) resize of the matrix to sizes that are powers of 2 matrix.resize( pow2_rows, pow2_cols, true ); } // a convenience macro to auto-create the serialize() member function BOOST_SERIALIZATION_SPLIT_MEMBER() // internal memory is a matrix M matrix; private: size_type view_rows; size_type view_cols; }; } // namespace kml namespace boost { namespace serialization { template struct tracking_level< kml::symmetric_view > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } } // namespace serialization namespace boost #endif kml_src/kml/detail/abs_element.hpp000644 000765 000024 00000004531 10377265535 020174 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef ABS_ELEMENT_HPP #define ABS_ELEMENT_HPP #include #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { struct abs_element_scalar { template static T compute( T const &x ) { return std::fabs( x ); } }; struct abs_element_range { template static T compute( T const &x ) { typedef typename boost::range_value::type scalar_type; T answer( boost::size(x) ); std::transform( boost::begin(x), boost::end(x), boost::begin(answer), boost::bind( &abs_element_scalar::compute, _1 ) ); return answer; } }; template T abs_element( T const &x ) { return mpl::if_< boost::is_scalar, abs_element_scalar, abs_element_range >::type::compute( x ); } }} // namespace kml::detail #endif kml_src/kml/detail/div_element.hpp000644 000765 000024 00000003204 10377265535 020205 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef DIV_ELEMENT_HPP #define DIV_ELEMENT_HPP #include namespace kml { namespace detail { template T div_element( T const &x, T const &y ) { return functor_element( x, y ); } }} // namespace kml::detail #endif kml_src/kml/detail/functor_element.hpp000644 000765 000024 00000004751 10377265535 021113 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef FUNCTOR_ELEMENT_HPP #define FUNCTOR_ELEMENT_HPP #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { template class Functor> struct functor_element_scalar { template static T compute( T const x, T const y ) { return Functor()(x, y); } }; template class Functor> struct functor_element_range { template static T compute( T const &x, T const &y ) { typedef typename boost::range_value::type scalar_type; T answer( boost::size(x) ); std::transform( boost::begin(x), boost::end(x), boost::begin(y), boost::begin(answer), Functor() ); return answer; } }; template class Functor, typename T> T functor_element( T const &x, T const &y ) { return mpl::if_< boost::is_scalar, functor_element_scalar, functor_element_range >::type::compute( x, y ); } }} // namespace kml::detail #endif kml_src/kml/detail/gemm.hpp000644 000765 000024 00000006544 10377265535 016651 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef GEMM_HPP #define GEMM_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace mpl = boost::mpl; namespace kml { namespace detail { struct atlas_gemm { template static void compute( MatrixA const &A, MatrixX const &X, MatrixB &B ) { std::cout << "ATLAS gemm..." << std::endl; atlas::gemm( A, X, B ); } }; struct exotic_gemm { template static void compute( MatrixA const &A, MatrixX const &X, MatrixB &B ) { // assume value type is defined in the matrix typedef typename MatrixB::value_type value_type; std::cout << "exotic gemm..." << std::endl; // indexed for now ... for( unsigned int row_A = 0; row_A < A.size1(); ++row_A ) { for( unsigned int col_X = 0; col_X < X.size2(); ++col_X ) { value_type result = scale_or_dot( A(row_A,0), X(0,col_X) ); for (unsigned int col_A = 1; col_A < A.size2(); ++col_A ) result += scale_or_dot( A(row_A,col_A), X(col_A,col_X) ); B( row_A, col_X ) = result; } } } }; /*! Matrix A has to be a matrix that is */ template void gemm( MatrixA const &A, MatrixX const &X, MatrixB &B ) { // figure out what to do (during compile-time) // this is not completely correct now, should be as in the scale_or_dot mpl::if_< boost::is_scalar, atlas_gemm, exotic_gemm >::type::compute( A, X, B ); } }} // namespace kml::detail #endif kml_src/kml/detail/gemv.hpp000644 000765 000024 00000006147 10377265535 016661 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef GEMV_HPP #define GEMV_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include namespace atlas = boost::numeric::bindings::atlas; namespace mpl = boost::mpl; namespace kml { namespace detail { struct atlas_gemv { template static void compute( Matrix const &A, VectorX const &x, VectorB &b ) { std::cout << "ATLAS gemv..." << std::endl; atlas::gemv( A, x, b ); } }; struct exotic_gemv { template static void compute( Matrix const &A, VectorX const &x, VectorB &b ) { typedef typename boost::range_value::type value_type; std::cout << "exotic gemv..." << std::endl; // indexed for now ... for( unsigned int m = 0; m < A.size1(); ++m ) { value_type result = scale_or_dot( A(m,0), x[0] ); for( unsigned int n = 1; n < A.size2(); ++n ) result += scale_or_dot( A(m,n), x[n] ); b[m] = result; } } }; /*! Matrix A has to be a matrix that is */ template void gemv( Matrix const &A, VectorX const &x, VectorB &b ) { // figure out what to do (during compile-time) mpl::if_< boost::is_scalar, atlas_gemv, exotic_gemv >::type::compute( A, x, b ); } }} // namespace kml::detail #endif kml_src/kml/detail/math.hpp000644 000765 000024 00000010705 10405312117 016624 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef MATH_HPP #define MATH_HPP // // discrete math, compile-time // combinatoric math // namespace kml { namespace detail { // // return the sign of an underlying float type // template inline const int sign( T const &value ) { return( value >= static_cast(0) ? 1 : -1 ); } // // checks whether a number should be considered zero, or not, // i.e. below the machine precision // template inline const bool is_zero( T const &value ) { return ( (value < std::numeric_limits::epsilon()) && (value > -std::numeric_limits::epsilon()) ); } // // static factorial (up to 19 now, ie 32 unsigned bits) // template struct factorial { static const unsigned int value = N * factorial::value; }; template<> struct factorial<0> { static const unsigned int value = 1; }; // a run-time counter-part as well... inline unsigned int factorial_rt( unsigned int n ) { return ( n==0 ? 1 : n * factorial_rt(n-1) ); } // // "N choose K" (Dutch: N boven K) // the binomial coefficient (N K) // template class choose { public: static const unsigned int value = factorial::value / (factorial::value * factorial::value); }; // // static a^b // template class power { public: static const int value = A * power::value; }; template class power { public: static const int value = 1; }; template class power<-1,B> { public: static const int value = (B % 2 ? -1 : 1); }; template class power<0,B> { public: static const int value = 0; }; template class power<1,B> { public: static const int value = 1; }; template class power<2,B> { public: static const int value = 1 << B; }; template<> class power<2,0> { public: static const int value = 1; }; template<> class power<-1,0> { public: static const int value = 1; }; // // static Eulerian number // template struct eulerian_sum { static const int value = power<-1,J>::value * choose::value * power::value + eulerian_sum::value; }; template struct eulerian_sum { static const int value = choose::value * power::value; }; template struct eulerian { static const int value = eulerian_sum::value; }; // // Entringer number // http://mathworld.wolfram.com/EntringerNumber.html // // e.g. E04..E44 = 0 2 4 5 5 template struct entringer { static const unsigned value = entringer::value + entringer::value; }; template struct entringer { static const unsigned value = (N==0 ? 1 : 0); }; } // namespace detail } // namespace kml #endif kml_src/kml/detail/max_element.hpp000644 000765 000024 00000004611 10377265535 020213 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef MAX_ELEMENT_HPP #define MAX_ELEMENT_HPP #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { struct max_element_scalar { template static T compute( T const &x, T const &y ) { return std::max( x, y ); } }; struct max_element_range { template static T compute( T const &x, T const &y ) { typedef typename boost::range_value::type scalar_type; T answer( boost::size(x) ); std::transform( boost::begin(x), boost::end(x), boost::begin(y), boost::begin(answer), boost::bind( &max_element_scalar::compute, _1, _2 ) ); return answer; } }; template T max_element( T const &x, T const &y ) { return mpl::if_< boost::is_scalar, max_element_scalar, max_element_range >::type::compute( x, y ); } }} // namespace kml::detail #endif kml_src/kml/detail/min_element.hpp000644 000765 000024 00000004611 10377265535 020211 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef MIN_ELEMENT_HPP #define MIN_ELEMENT_HPP #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { struct min_element_scalar { template static T compute( T const &x, T const &y ) { return std::min( x, y ); } }; struct min_element_range { template static T compute( T const &x, T const &y ) { typedef typename boost::range_value::type scalar_type; T answer( boost::size(x) ); std::transform( boost::begin(x), boost::end(x), boost::begin(y), boost::begin(answer), boost::bind( &min_element_scalar::compute, _1, _2 ) ); return answer; } }; template T min_element( T const &x, T const &y ) { return mpl::if_< boost::is_scalar, min_element_scalar, min_element_range >::type::compute( x, y ); } }} // namespace kml::detail #endif kml_src/kml/detail/prod_element.hpp000644 000765 000024 00000003212 10377265535 020366 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef PROD_ELEMENT_HPP #define PROD_ELEMENT_HPP #include namespace kml { namespace detail { template T prod_element( T const &x, T const &y ) { return functor_element( x, y ); } }} // namespace kml::detail #endif kml_src/kml/detail/reciprocal_element.hpp000644 000765 000024 00000004744 10377265535 021560 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef RECIPROCAL_ELEMENT_HPP #define RECIPROCAL_ELEMENT_HPP #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { struct reciprocal_element_scalar { template static T compute( T const &x ) { if (std::fabs(x) < std::numeric_limits::epsilon()) return static_cast(1); else return static_cast(1) / x; } }; struct reciprocal_element_range { template static T compute( T const &x ) { typedef typename boost::range_value::type scalar_type; T answer( boost::size(x) ); std::transform( boost::begin(x), boost::end(x), boost::begin(answer), boost::bind( &reciprocal_element_scalar::compute, _1 ) ); return answer; } }; template T reciprocal_element( T const &x ) { return mpl::if_< boost::is_scalar, reciprocal_element_scalar, reciprocal_element_range >::type::compute( x ); } }} // namespace kml::detail #endif kml_src/kml/detail/scale_or_dot.hpp000644 000765 000024 00000006436 10377265535 020361 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef SCALE_OR_DOT_HPP #define SCALE_OR_DOT_HPP #include #include #include #include #include #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { // TypeX TypeY Result Handled by // scalar scalar scalar scale_product // vector scalar vector scale_product // scalar vector vector scale_product // vector vector scalar dot_product template struct scale_or_dot_value: mpl::eval_if< mpl::or_< boost::is_scalar, boost::is_scalar >, mpl::eval_if< boost::is_same, mpl::identity, mpl::if_< boost::is_scalar, TypeY, TypeX > >, boost::range_value > {}; struct scale_product { template static typename scale_or_dot_value::type compute( TypeX const &x, TypeY const &y ) { return x * y; } }; struct dot_product { template static typename scale_or_dot_value::type compute( TypeX const &x, TypeY const &y ) { typedef typename boost::range_value::type value_type; // TODO pass on to a inner-prod specialisation return std::inner_product( boost::begin(x), boost::end(x), boost::begin(y), static_cast(0) ); } }; template typename scale_or_dot_value::type scale_or_dot( TypeX const &x, TypeY const &y ) { // figure out what to do (during compile-time) return mpl::if_< mpl::or_< boost::is_scalar, boost::is_scalar >, scale_product, dot_product >::type::compute( x, y ); } }} // namespace kml::detail #endif kml_src/kml/detail/sqrt_element.hpp000644 000765 000024 00000004543 10377265535 020423 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef SQRT_ELEMENT_HPP #define SQRT_ELEMENT_HPP #include #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { struct sqrt_element_scalar { template static T compute( T const &x ) { return std::sqrt( x ); } }; struct sqrt_element_range { template static T compute( T const &x ) { typedef typename boost::range_value::type scalar_type; T answer( boost::size(x) ); std::transform( boost::begin(x), boost::end(x), boost::begin(answer), boost::bind( &sqrt_element_scalar::compute, _1 ) ); return answer; } }; template T sqrt_element( T const &x ) { return mpl::if_< boost::is_scalar, sqrt_element_scalar, sqrt_element_range >::type::compute( x ); } }} // namespace kml::detail #endif kml_src/kml/detail/zero_element.hpp000644 000765 000024 00000004447 10377265535 020414 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * This library is free software; you can redistribute it and/or * * modify it under the terms of the GNU Lesser General Public * * License as published by the Free Software Foundation; either * * version 2.1 of the License, or (at your option) any later version. * * * * This 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 * * Lesser General Public License for more details. * * * * You should have received a copy of the GNU Lesser General Public * * License along with this library; if not, write to the Free Software * * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * ***************************************************************************/ #ifndef ZERO_ELEMENT_HPP #define ZERO_ELEMENT_HPP #include #include #include #include #include #include #include namespace mpl = boost::mpl; namespace kml { namespace detail { struct zero_element_scalar { template static T compute( T const & ) { return static_cast(0); } }; struct zero_element_range { template static T compute( T const &x ) { typedef typename boost::range_value::type scalar_type; T answer( boost::size(x) ); std::fill( boost::begin(answer), boost::end(answer), static_cast(0) ); return answer; } }; template T zero_element( T const &x ) { return mpl::if_< boost::is_scalar, zero_element_scalar, zero_element_range >::type::compute( x ); } }} // namespace kml::detail #endif kml_src/example/gaussian.cpp000644 000765 000024 00000005277 10375111746 017131 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; int main(int argc, char *argv[]) { // vector input types ublas::vector u(2); ublas::vector v(2); u[0] = 1.0; u[1] = 2.0; v[0] = 3.0; v[1] = 4.0; kml::gaussian< ublas::vector > kernel( 1.0 ); std::cout << kernel( u, v ) << std::endl; // query its parameter in different formats std::cout << "Kernel width (sigma): " << kernel.get_width() << std::endl; std::cout << "Kernel scale factor (gamma): " << kernel.get_scale_factor() << std::endl; // inline use on scalar input types std::cout << kml::gaussian< float >( 1.0 )( 1.5, 2.0 ) << std::endl; // save the kernel std::ofstream ofs("testfile.txt"); boost::archive::text_oarchive my_oarchive( ofs ); my_oarchive << kernel; ofs.close(); std::cout << "Saved: " << kernel << std::endl; // ... sometime later, load the kernel kml::gaussian< ublas::vector > new_kernel; std::ifstream ifs("testfile.txt"); boost::archive::text_iarchive my_iarchive( ifs ); my_iarchive >> new_kernel; ifs.close(); std::cout << "Loaded: " << new_kernel << std::endl; return EXIT_SUCCESS; } kml_src/example/incomplete_cholesky.cpp000644 000765 000024 00000007543 10732423745 021357 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace ublas = boost::numeric::ublas; int main(int argc, char *argv[]) { boost::mt19937 randomness; typedef boost::uniform_real dist_type; dist_type random_dist( 0.0, 1.0 ); boost::variate_generator noise( randomness, random_dist ); typedef boost::tuple, double> example_type; typedef kml::regression< example_type > problem_type; typedef boost::vector_property_map< boost::tuple< ublas::vector, bool> > data_access_type; data_access_type data; typedef kml::polynomial< ublas::vector > kernel_type; kernel_type my_kernel( 1.0, 0.0, 3.0 ); int N = 1000; std::vector all_keys; for ( int sample = 0; sample < N; ++sample ) all_keys.push_back( sample ); // Create random data for ( int sample = 0; sample < N; ++sample ) { int data_dim = 10; ublas::vector x( data_dim ); for( int i=0; i my_eval( my_kernel, data ); kml::incomplete_cholesky my_eval2( my_kernel, data ); my_eval.compute_R( all_keys.begin(), all_keys.begin() + 8, 3 ); my_eval2.compute_R( all_keys.begin(), all_keys.begin() + 5, 3 ); my_eval2.increment( 5 ); my_eval2.increment( 6 ); my_eval2.increment( 7 ); std::cout << "Pivots used: "; for( int i=0; i< my_eval.basis_size; ++i ) std::cout << my_eval.pivot[i] << " "; std::cout << std::endl; std::cout << my_eval.RT.view() << std::endl; std::cout << "Pivots-2 used: "; for( int i=0; i< my_eval2.basis_size; ++i ) std::cout << my_eval2.pivot[i] << " "; std::cout << std::endl; std::cout << my_eval2.RT.view() << std::endl; return EXIT_SUCCESS; } kml_src/example/kmltool.cpp000644 000765 000024 00000030310 10425364572 016765 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004--2006 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include #include #include #include #include #include #include #include #include // include kernel machine types #include #include #include namespace po = boost::program_options; namespace ublas = boost::numeric::ublas; int main(int argc, char *argv[]) { po::options_description descriptions("Usage: kmltool [OPTION]... [FILE]...\n\nWhere OPTION can be one of the following"); descriptions.add_options() ( "help", "produce help message" ) ( "machine", po::value(), "Selects the kernel machine." ) ( "kernel", po::value< std::string >(), "select the kernel function." ) ( "input-file", po::value< std::string >(), "input file" ) ( "output-file", po::value< std::string >(), "output file" ); // all positional options should be input files... po::positional_options_description pos_options; pos_options.add( "input-file", -1 ); po::variables_map settings; po::store( po::command_line_parser( argc,argv ).options(descriptions).positional(pos_options).run(), settings ); po::notify( settings ); if ( settings.empty() || settings.count("help") > 0 ) { std::cout << descriptions << std::endl; return EXIT_SUCCESS; } if ( settings.count("input-file") == 0 ) { std::cout << "Error: no input file given." << std::endl; std::cout << descriptions << std::endl; return EXIT_SUCCESS; } if ( settings.count("machine") == 0 ) { std::cout << "Error: no --machine option found." << std::endl; std::cout << descriptions << std::endl; return EXIT_SUCCESS; } if ( settings.count("kernel") == 0 ) { std::cout << "Error: no --kernel option found." << std::endl; std::cout << descriptions << std::endl; return EXIT_SUCCESS; } // a whole slew of possible settings... enum machine_type { support_vector, relevance_vector, krls }; enum kernel_type { gaussian, linear }; machine_type selected_machine( support_vector ); kernel_type selected_kernel( gaussian ); // // The exact semantics of the command line is a TODO // std::string machine_string = settings["machine"].as(); boost::char_separator csv_separator(","); boost::tokenizer > machine_options( machine_string, csv_separator ); boost::tokenizer >::iterator m_o = machine_options.begin(); if (m_o != machine_options.end() ) { if ( *m_o == std::string("svm") ) { selected_machine = support_vector; std::cout << "support vector machine selected" << std::endl; // parse the remaining options later on!! } if ( *m_o == std::string("rvm") ) { selected_machine = relevance_vector; std::cout << "relevance vector machine selected" << std::endl; // parse any remaining options later on!! } if ( *m_o == std::string("krls") ) { selected_machine = krls; std::cout << "kernel recursive least squares selected" << std::endl; // parse any remaining options later on!! } ++m_o; } std::string kernel_string = settings["kernel"].as(); boost::tokenizer > kernel_options( kernel_string, csv_separator ); boost::tokenizer >::iterator k_o = kernel_options.begin(); if (k_o != kernel_options.end() ) { if ( *k_o == std::string("gaussian") ) { selected_kernel = gaussian; std::cout << "gaussian kernel selected" << std::endl; } if ( *k_o == std::string("linear") ) { selected_kernel = linear; std::cout << "linear kernel selected" << std::endl; } ++k_o; } std::string input_file = settings["input-file"].as(); kml::file my_file( input_file ); std::ofstream ofs("testmodel.txt"); boost::archive::text_oarchive my_oarchive( ofs ); switch( my_file.problem_type() ) { case kml::io::classification: { std::cout << "entering classification part..." << std::endl; typedef boost::tuple< ublas::vector, bool > example_type; typedef boost::vector_property_map< boost::tuple< ublas::vector, bool > > data_type; typedef kml::classification< example_type > problem_type; data_type data; std::vector learn_keys; my_file.read( data, learn_keys ); //std::random_shuffle( learn_keys.begin(), learn_keys.end() ); switch( selected_machine ) { case support_vector: { switch( selected_kernel ) { case gaussian: { typedef kml::gaussian< problem_type::input_type > kernel_type; typedef kml::online_svm< problem_type, kernel_type, data_type > machine_type; kernel_type my_kernel( k_o, kernel_options.end() ); machine_type my_machine( m_o, machine_options.end(), my_kernel, data ); my_machine.learn( learn_keys.begin(), learn_keys.end() ); my_oarchive << my_machine; break; } } break; } case relevance_vector: { switch( selected_kernel ) { case gaussian: { typedef kml::gaussian< problem_type::input_type > kernel_type; kernel_type my_kernel( k_o, kernel_options.end() ); //typedef kml::rvm< data_type, problem_type, kernel_type > machine_type; break; } } // switch kernel break; } default: { std::cout << "Sorry, no implementation available (yet) for the requested operation." << std::endl; break; } } break; } case kml::io::regression: { std::cout << "entering regression part..." << std::endl; typedef boost::tuple< ublas::vector, double > example_type; typedef boost::vector_property_map< example_type > data_type; typedef kml::regression< example_type > problem_type; // translate the file to the data container std::vector learn_keys; data_type data; my_file.read( data, learn_keys ); switch( selected_machine ) { case support_vector: { switch( selected_kernel ) { case gaussian: { typedef kml::gaussian< problem_type::input_type > kernel_type; typedef kml::online_svm< problem_type, kernel_type, data_type > machine_type; kernel_type my_kernel( k_o, kernel_options.end() ); machine_type my_machine( m_o, machine_options.end(), my_kernel, data ); my_machine.learn( learn_keys.begin(), learn_keys.end() ); my_oarchive << my_machine; break; } } break; } // svm switch case relevance_vector: { switch( selected_kernel ) { case gaussian: { typedef kml::gaussian< problem_type::input_type > kernel_type; typedef kml::rvm< problem_type, kernel_type, data_type > machine_type; kernel_type my_kernel( k_o, kernel_options.end() ); machine_type my_machine( m_o, machine_options.end(), my_kernel, data ); my_machine.learn( learn_keys.begin(), learn_keys.end() ); my_oarchive << my_machine; break; } } // switch kernel break; } // rvm switch case krls: { switch( selected_kernel ) { case gaussian: { typedef kml::gaussian< problem_type::input_type > kernel_type; typedef kml::krls< problem_type, kernel_type, data_type > machine_type; kernel_type my_kernel( k_o, kernel_options.end() ); machine_type my_machine( m_o, machine_options.end(), my_kernel, data ); my_machine.learn( learn_keys.begin(), learn_keys.end() ); my_oarchive << my_machine; break; } } break; } // krls switch } std::cout << "leaving regression part..." << std::endl; break; } case kml::io::ranking: { std::cout << "entering ranking part..." << std::endl; typedef boost::tuple< ublas::vector, int, double > example_type; typedef boost::vector_property_map< example_type > data_type; typedef kml::ranking< example_type > problem_type; switch( selected_machine ) { case support_vector: { switch( selected_kernel ) { case gaussian: { typedef kml::gaussian< problem_type::input_type > kernel_type; //typedef kml::svm< problem_type, kernel_type, data_type > machine_type; kernel_type my_kernel( k_o, kernel_options.end() ); //machine_type my_machine( m_o, machine_options.end(), my_kernel, data ); //my_machine.learn( learn_keys.begin(), learn_keys.end() ); break; } } // switch kernel break; } default: { std::cout << "Sorry, no implementation available (yet) for the requested operation." << std::endl; break; } } std::cout << "leaving ranking part..." << std::endl; break; } case kml::io::unknown: { std::cout << "Sorry, unknown filetype." << std::endl; } } // close the model file ofs.close(); return EXIT_SUCCESS; } kml_src/example/SConscript000644 000765 000024 00000001763 10671773164 016630 0ustar00pawelmstaff000000 000000 Import('env') Import('atlas_link_libs') Import('c_link_libs') # KML tool configuration if (env['PLATFORM'] == 'posix' or env['PLATFORM'] == 'darwin'): program_options_lib = ['boost_program_options'] serialization_lib = ['boost_serialization'] elif env['PLATFORM'] == 'win32': program_options_lib = [str(env.FindFile( ['libboost_program_options-vc71-mt-s.lib'], env['LIBPATH'] ))] serialization_lib = [str(env.FindFile( ['libboost_serialization-vc71-mt-s.lib'], env['LIBPATH'] ))] else: print "Please configure examples/SConscript." env.Program('gaussian.cpp', LIBS=serialization_lib) env.Program('svm_regression.cpp', LIBS=atlas_link_libs + serialization_lib ) env.Program('svm_classification.cpp' ) env.Program('svm_ranking.cpp', LIBS=serialization_lib ) env.Program('incomplete_cholesky.cpp', LIBS=atlas_link_libs ) #env.Program('svm_c_ranking.c', LIBS=c_link_libs) #env.Program('kmltool.cpp', LIBS= atlas_link_libs + program_options_lib + serialization_lib ) kml_src/example/svm_classification.cpp000644 000765 000024 00000006714 10755313364 021176 0ustar00pawelmstaff000000 000000 #ifdef HAVE_CONFIG_H #include #endif #define BOOST_UBLAS_NESTED_CLASS_DR45 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using std::string; using std::cout; using std::endl; using std::ifstream; using std::stringstream; using std::getline; using std::cerr; namespace ublas = boost::numeric::ublas; int main(int argc, char *argv[]) { typedef boost::tuple, int> example_type; typedef kml::classification problem_type; typedef boost::vector_property_map data_type; typedef kml::gaussian gaussian_kernel_type; typedef kml::polynomial polynomial_kernel_type; typedef kml::linear linear_kernel_type; if (argc < 2) { cout << "Error: need an input file to train and test on." << endl << "usage: svm_classification (trainfile) (testfile)" << endl; return 0; } data_type data; std::vector learn_keys; cerr << "Reading in vector..."; kml::file train_file(argv[1]); train_file.read(data, learn_keys); cerr << "Done reading " << std::distance(learn_keys.begin(), learn_keys.end()) << " points of size " << data[0].get<0>().size() << endl; kml::svm gaussian_machine(3.162277, 1.0, data); kml::svm polynomial_machine( polynomial_kernel_type(1.0,0.0,3.0), 1.0, data); kml::svm linear_machine( linear_kernel_type(), 1.0, data); gaussian_machine.learn(learn_keys.begin(), learn_keys.end()); cerr << "Done training gaussian." << endl; for (std::vector::iterator i = gaussian_machine.weight.begin(); i != gaussian_machine.weight.end(); ++i) cout << boost::lexical_cast(*i) << " "; cout << endl; data_type test_data; std::vector test_keys; std::vector::iterator i; cerr << "Reading in test vector..."; kml::file test_file(argv[2]); test_file.read(test_data, test_keys); cerr << "Done, " << std::distance(test_keys.begin(), test_keys.end()) << " points of size " << test_data[0].get<0>().size() << endl; for (i = test_keys.begin(); i != test_keys.end(); ++i) cout << gaussian_machine(test_data[*i].get<0>()) << endl; cout << "C = " << gaussian_machine.get_C() << endl; std::vector alpha = gaussian_machine.get_alpha(); cout << "alpha: "; for (unsigned int i=0; i < alpha.size(); ++i) cout << alpha[i] << " "; cout << endl; std::vector > svs = gaussian_machine.get_svs(); cout << "SVs: " << endl; for (unsigned int i=0; i < svs.size(); ++i) { for (unsigned int j=0; j < svs[i].size(); ++j) cout << svs[i][j] << " "; cout << endl; } return 0; } kml_src/example/svm_ranking.cpp000644 000765 000024 00000011450 10671773164 017632 0ustar00pawelmstaff000000 000000 #ifdef HAVE_CONFIG_H #include #endif #define BOOST_UBLAS_NESTED_CLASS_DR45 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using std::string; using std::cout; using std::endl; using std::ifstream; using std::stringstream; using std::getline; using std::cerr; namespace ublas = boost::numeric::ublas; typedef boost::tuple, int, double> example_type; typedef kml::ranking problem_type; typedef kml::gaussian kernel_type; typedef boost::vector_property_map PropertyMap; int main(int argc, char *argv[]) { boost::shared_ptr data(new PropertyMap); problem_type::input_type point; point.push_back(1); point.push_back(1); point.push_back(0); point.push_back(0.2); point.push_back(0); (*data)[0] = boost::make_tuple(point, 1, 3); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(1); point.push_back(0.1); point.push_back(1); (*data)[1] = boost::make_tuple(point, 1, 2); point.resize(0); point.push_back(0); point.push_back(1); point.push_back(0); point.push_back(0.4); point.push_back(0); (*data)[2] = boost::make_tuple(point, 1, 1); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(1); point.push_back(0.3); point.push_back(0); (*data)[3] = boost::make_tuple(point, 1, 1); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(1); point.push_back(0.2); point.push_back(0); (*data)[4] = boost::make_tuple(point, 2, 1); point.resize(0); point.push_back(1); point.push_back(0); point.push_back(1); point.push_back(0.4); point.push_back(0); (*data)[5] = boost::make_tuple(point, 2, 2); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(1); point.push_back(0.1); point.push_back(0); (*data)[6] = boost::make_tuple(point, 2, 1); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(1); point.push_back(0.2); point.push_back(0); (*data)[7] = boost::make_tuple(point, 2, 1); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(1); point.push_back(0.1); point.push_back(1); (*data)[8] = boost::make_tuple(point, 3, 2); point.resize(0); point.push_back(1); point.push_back(1); point.push_back(0); point.push_back(0.3); point.push_back(0); (*data)[9] = boost::make_tuple(point, 3, 3); point.resize(0); point.push_back(1); point.push_back(0); point.push_back(0); point.push_back(0.4); point.push_back(1); (*data)[10] = boost::make_tuple(point, 3, 4); point.resize(0); point.push_back(0); point.push_back(1); point.push_back(1); point.push_back(0.5); point.push_back(0); (*data)[11] = boost::make_tuple(point, 3, 1); point.resize(0); std::cerr << "All created, about to create SVM" << std::endl; kml::svm my_machine(1.0, 1.0, data); std::cerr << "About to learn" << std::endl; my_machine.learn(data->storage_begin(), data->storage_end()); std::vector testpoints; point.push_back(1); point.push_back(0); point.push_back(0); point.push_back(0.2); point.push_back(1); testpoints.push_back(point); point.resize(0); point.push_back(1); point.push_back(1); point.push_back(0); point.push_back(0.3); point.push_back(0); testpoints.push_back(point); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(0); point.push_back(0.2); point.push_back(1); testpoints.push_back(point); point.resize(0); point.push_back(0); point.push_back(0); point.push_back(1); point.push_back(0.2); point.push_back(0); testpoints.push_back(point); point.resize(0); for (std::vector::iterator i = testpoints.begin(); i != testpoints.end(); ++i) cout << my_machine(*i) << endl; cout << "C = " << my_machine.get_C() << endl; std::vector alpha = my_machine.get_alpha(); cout << "alpha: "; for (unsigned int i=0; i < alpha.size(); ++i) cout << alpha[i] << " "; cout << endl; std::vector > svs = my_machine.get_svs(); cout << "SVs: " << endl; for (unsigned int i=0; i < svs.size(); ++i) { for (unsigned int j=0; j < svs[i].size(); ++j) cout << svs[i][j] << " "; cout << endl; } return 0; } kml_src/example/svm_regression.cpp000644 000765 000024 00000012451 10515076347 020357 0ustar00pawelmstaff000000 000000 /*************************************************************************** * The Kernel-Machine Library * * Copyright (C) 2004, 2005, 2006 by Rutger W. ter Borg * * * * 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 * ***************************************************************************/ #include #include #include #include #include #include #include #include #include #include int main(int argc, char *argv[]) { // create a sinc-data set: sin(x)/x + gaussian noise with sd=0.1 boost::mt19937 randomness; boost::normal_distribution norm_dist( 0.0, 0.1 ); boost::variate_generator > noise( randomness, norm_dist ); // define the example type, which is a tuple of {vector,double}, with input=vector, output=double typedef boost::tuple, double> example_type; // data are stored in a map, similar to std::map // any map type may be used, examples are considered to be referenced by a key-value syntax; keys // may be any type; value in this case is the example // // using integer key types: // in case of regression, e.g., data[0] == reference to example 0 == tuple of {vector, double} // classification, e.g., data[0] == reference to example 0 == tuple of {vector, bool} // single-class, e.g., data[0] == reference to example 0 == tuple of {vector} // // using pointers: // data[ my_ptr ] = *my_ptr == example pointed to == etc. // here, we define the data type, which is a map with integer indexing containing elements of the example_type. // in contrast to a std::map, this has O(1) lookup time typedef boost::vector_property_map< example_type > data_type; data_type data; // fill the data set with 50 input-output examples // with the inputs in an equally spaced grid [-10,10] int N = 50; std::vector > x_vec(N); for( int i=0; i::type x(1); // equals to "ublas::vector x(1)"; x[0] = (double(i)/double(N-1))*20.0-10.0; x_vec[i] = x; data[i] = boost::make_tuple( x, boost::math::sinc_pi(x[0]) + noise() ); } // train the online_svm algorithm on this data set std::cout << "Training kernel machine..." << std::endl; // define the problem type: regression typedef kml::regression< example_type > problem_type; // define the kernel type: a gaussian kernel typedef kml::gaussian< problem_type::input_type > kernel_type; // create the actual kernel machine, an online SVM in this case // with C=10.0, epsilon=0.1, gaussian kernel width=1.6 kml::online_svm< problem_type, kernel_type, data_type > my_machine( 10.0, 0.1, kernel_type(1.6), data ); // train the kernel machine. A kernel machine can be instructed to learn a series of examples // referenced to by a series of keys. E.g., iterators over a std::vector< key_type > of keys would work, but also // more specialised types, such as using lazy-iterator type(s). // we shuffle the keys so that the data is presented in a random way to the kernel machine. Although the // result is the same, we put it here to test just that. std::vector< int > random_order; for( int i=0; i y_test(N); std::transform( x_vec.begin(), x_vec.end(), y_test.begin(), my_machine ); // temp. not working // std::cout << "RMSE " << kml::root_mean_square( y - y_test ) << std::endl; // std::cout << "Cor " << kml::correlation( y, y_test ) << std::endl; std::cout << "Predicted output values:" << std::endl; std::cout << y_test << std::endl; return EXIT_SUCCESS; } kml_src/doc/algorithm_selection.fig000644 000765 000024 00000007460 10457423463 020446 0ustar00pawelmstaff000000 000000 #FIG 3.2 Landscape Center Metric A4 100.00 Single -2 1200 2 1 2 2 1 0 7 50 -1 -1 3.000 1 0.0000 2272 1192 1687 383 585 1192 3959 1192 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2790 990 3510 990 3510 1395 2790 1395 2790 990 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 1890 990 2610 990 2610 1395 1890 1395 1890 990 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 1350 990 2070 540 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 2430 540 3150 990 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 2250 540 2250 990 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 990 990 1710 990 1710 1395 990 1395 990 990 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 1890 135 2610 135 2610 540 1890 540 1890 135 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 1800 1800 2070 1395 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2340 1800 3060 1800 3060 1980 2340 1980 2340 1800 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 1440 1800 2160 1800 2160 1980 1440 1980 1440 1800 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 2700 1800 2430 1395 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 1890 2070 2610 2070 2610 2250 1890 2250 1890 2070 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 2250 2070 2250 1395 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 3420 1890 4140 1890 4140 2070 3420 2070 3420 1890 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 3150 2160 3870 2160 3870 2340 3150 2340 3150 2160 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 3690 1620 4410 1620 4410 1800 3690 1800 3690 1620 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 3285 2160 3015 1395 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 3555 1890 3150 1395 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 3825 1620 3285 1395 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 630 2160 1350 2160 1350 2340 630 2340 630 2160 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 360 1890 1080 1890 1080 2070 360 2070 360 1890 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 90 1620 810 1620 810 1800 90 1800 90 1620 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 1170 1395 675 1620 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 1305 1395 945 1890 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 1440 1395 1215 2160 4 1 0 50 -1 0 10 0.0000 0 105 540 2250 1170 Problem\001 4 1 0 50 -1 0 10 0.0000 0 120 270 2250 1305 type\001 4 1 0 50 -1 0 10 0.0000 0 105 420 3150 1260 Kernel\001 4 1 0 50 -1 0 10 0.0000 0 105 420 2250 315 Kernel\001 4 1 0 50 -1 0 10 0.0000 0 105 525 2250 450 Machine\001 4 0 0 50 -1 0 8 0.0000 0 90 75 1530 765 is\001 4 0 0 50 -1 0 8 0.0000 0 90 405 2880 765 contains\001 4 1 0 50 -1 0 10 0.0000 0 105 225 1350 1125 e.g.\001 4 1 0 50 -1 0 10 0.0000 0 105 345 1350 1305 SVM\001 4 0 0 50 -1 0 10 0.0000 0 135 690 3735 810 Algorithm\001 4 0 0 50 -1 0 10 0.0000 0 105 555 3735 945 selection\001 4 0 0 50 -1 0 8 0.0000 0 75 315 1935 765 solves\001 4 1 0 50 -1 0 8 0.0000 0 105 555 1800 1935 Regression\001 4 1 0 50 -1 0 8 0.0000 0 90 675 2700 1935 Classification\001 4 0 0 50 -1 0 8 0.0000 0 90 75 1755 1710 is\001 4 0 0 50 -1 0 8 0.0000 0 90 75 2295 1710 is\001 4 0 0 50 -1 0 8 0.0000 0 90 75 2700 1710 is\001 4 1 0 50 -1 0 8 0.0000 0 105 615 2250 2205 Single-class\001 4 1 0 50 -1 0 8 0.0000 0 105 405 3510 2295 Sigmoid\001 4 1 0 50 -1 0 8 0.0000 0 90 420 3780 2025 Gaussian\001 4 1 0 50 -1 0 8 0.0000 0 120 570 4050 1755 Polynomial\001 4 1 0 50 -1 0 8 0.0000 0 90 690 990 2295 Deterministic\001 4 1 0 50 -1 0 8 0.0000 0 75 285 720 2025 Batch\001 4 1 0 50 -1 0 8 0.0000 0 75 300 450 1755 Exact\001 4 0 0 50 -1 0 8 0.0000 0 90 75 765 1485 is\001 4 0 0 50 -1 0 8 0.0000 0 90 75 990 1665 is\001 4 0 0 50 -1 0 8 0.0000 0 90 75 1215 1845 is\001 4 0 0 50 -1 0 8 0.0000 0 90 75 3105 2070 is\001 4 0 0 50 -1 0 8 0.0000 0 90 75 3735 1530 is\001 4 0 0 50 -1 0 8 0.0000 0 90 75 3285 1800 is\001 kml_src/doc/design.tex000644 000765 000024 00000010174 10542537135 015710 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{Design of the KML} \maketitle \section{Requirements} Here the initial requirements for the kernel-machine library are formalised. \begin{itemize} \item \textbf{It should be efficient.} Because kernel machines are all about numerical computations, one of the most important topics will be to achieve efficiency. Efficiency can be expressed in the big-O notation. \item \textbf{It should have a clean API.} Because it is a development library, one of the more difficult things of the development of a software library compared with the development of an end-user software tool is the quality of code: co-developers have to be able to read the source code. Good documentation, good use of comments, and sensible names of parameters can help. \item \textbf{It should be cross-platform.} With a dominance of more than 90\% of the desktop market, Microsoft Windows systems do contain many potential users and should be well supported. It should be tested on different operating systems. \item \textbf{It should be flexible.} It should be able to accommodate all kinds of kernel machines, and therefore be able to process data set formats used by other packages. \item \textbf{It should be extensible.} In case an unforeseen situation comes into play, it should be possible to adjust the library in line with new ideas with minimal effort without altering the validity of its contents. \end{itemize} \section{Design} % The exact design of software may depend on the capabilities of the language it is written in. The C++ language is a \emph{multi-paradigm} language, in other words, the language supports procedural, object-oriented, and even functional program structures. Recently, one of C++'s features achieved much attention: its template typing system is extremely powerful, as it allows for Turing-complete programming during compile-time: the time when the program is being compiled by a compiler. Run-time is when the program is under execution, i.e., running. This has been an important issue in the design of the KML: selecting the actions to be taken in compile-time, and what actions will be executed in run-time. The following may exemplify this distinction, \highlightcpp{} \begin{verbatim} template struct factorial{ static const int value = N*factorial< N-1 >::value; }; template< > struct factorial< 0 >{ static const int value = 1; }; \end{verbatim} and its run-time counterpart would look like as follows \highlightcpp{} \begin{verbatim} int factorial_rt(int n){ return ( n==0 ? 1 : n*factorial_rt(n-1) ); } \end{verbatim} % Now, if a factorial needs to be computed from a known number N, this can be done by the compiler at compile-time, reducing the number of computations needed at run-time to zero. % This idea may be taken much further, to arrive at the area of \emph{template meta-programming}. Figure~\ref{figure:design_kml} shows an entity-relation diagram used in the library. % \begin{figure} \includegraphics{algorithm_selection}% \caption{Entity-relation diagram used in the kernel-machine library.} \label{figure:design_kml} \end{figure} A kernel machine is a term for a combination of several concepts: a problem type, a kernel function and an algorithm. The problem type is the type of problem to be solved, e.g. classification, regression, or single class. Given a problem type, a kernel-machine states how the problem is solved and by what mechanisms. For instance, for a regression problem, an SVM has a mathematical optimisation problem different from that for a classification problem. A kernel machine \emph{contains} a kernel; it \emph{is} not a kernel. However, algorithms have been devised that are specialised towards a kernel machine in combination with a specific kernel. Therefore, a kernel can be responsible for the selection of the algorithm used by the kernel machine. Kernel machines sometimes solve identical problems in different ways: here, trade-offs and guarantees of pre-learning and post-learning come into play. ... and more \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/improvement.tex000644 000765 000024 00000003607 10731214757 017011 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \begin{document} \title{Improvement Guide} \maketitle \section*{News} \begin{itemize} \item Installed GNU's mailman mailing list manager for handling kml-devel@terborg.net. \item Installed ViewCVS for better \href{http://www.terborg.net/cgi-bin/viewcvs.cgi/trunk/kml/}{on-line browsing} of the KML repository. \item For improved collaboration, a subversion repository has been setup at \href{http://www.terborg.net/svn/trunk/kml/}{http://www.terborg.net/svn/trunk/kml/}. A recommended Windows client is \href{http://tortoisesvn.tigris.org/}{TortoiseSVN}. \item Examples have been added. \end{itemize} The development version of the Kernel-Machine Library can be checked out anonymously from the trunk directory of the subversion repository located at \href{http://www.terborg.net/svn/trunk/kml/}{http://www.terborg.net/svn/trunk/kml/}. By using the following command \begin{verbatim} svn checkout http://www.terborg.net/svn/trunk/kml \end{verbatim} a fresh up-to-date KML directory will be obtained. \section*{Mailing List} A mailing list has been setup by the library authors. On this list, we discuss issues like the design and implementation of the library, most wanted features, bugs, and, of course, all kinds of other issues \smile. Information regarding the mailing list may be found at \href{http://www.terborg.net/mailman/listinfo/kml-devel/}{http://www.terborg.net/mailman/listinfo/kml-devel/}, including links to browse its archive, to subscribe and to unsubscribe. \section*{Feedback} If you do have any questions, feedback, new algorithms, or success stories, please do not hesitate to contact us at kml-devel@terborg.net. We endeavour to use any kind of feedback for improvement of the library, including the on-line documentation. \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/index.html_fase4000644 000765 000024 00000004324 10554074364 016777 0ustar00pawelmstaff000000 000000 Kernel-Machine Library

The Kernel-Machine Library is a free (released under the LGPL) C++ library to promote the use of and progress of kernel machines. It is intended for use in research as well as in practice. The library is known to work with a recent C++ compiler on GNU/Linux, on Mac OS, and on several flavours of Windows.

Below, we would like to give you the choice to either install, use, or improve the library.

kml_src/doc/installation.tex000644 000765 000024 00000032445 10731216073 017140 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{Installation Guide} \maketitle \tableofcontents \section{Dependencies} The Kernel-Machine Library builds on top of the libraries below. \begin{itemize} \item \textbf{Boost.} Functionality of several \href{http://www.boost.org/}{Boost libraries} is in use throughout the Kernel-Machine Library. Boost provides an excellent set of C++ libraries which reduces the amount of code and boosts the quality of the overall implementation. The Kernel-Machine Library was originally built and tested against version 1.32.0, and also works with the current version of 1.33.1. \item \textbf{ATLAS.} This is a very efficient basic linear algebra system (\href{http://www.netlib.org/blas/faq.html}{BLAS}) \cite{whaley01automated}, located at \href{http://math-atlas.sourceforge.net}{Sourceforge}. ATLAS can empirically finetune its code to make optimal use of your CPU including its numerical extensions such as SSE, 3DNow! and AltiVec. It also contains several LAPACK routines. \item \textbf{Boost Numeric Bindings.} A part of Boost's sandbox CVS repository is included in the KML distribution, namely the numeric bindings. This is a software package that combines the flexibility of the C++ data types (such as that of \texttt{std::vector<>} or \texttt{ublas::matrix<>}) with the computational efficiency of a BLAS and LAPACK. The numeric bindings are . \end{itemize} \section{Debian GNU/Linux} This section describes how to start developing with the Kernel-Machine library on a Debian GNU/Linux-based operating system. Using root privileges, please run \texttt{apt-get} to install the following packages. \begin{verbatim} $ apt-get install atlas3-base-dev g++ scons subversion libboost-dev \ libboost-serialization-dev libboost-program-options* \end{verbatim} % Using your local user account, execute the following commands. \begin{verbatim} $ cd ~/my/development/dir/ $ svn checkout http://www.terborg.net/svn/trunk/kml $ cd kml $ scons \end{verbatim} % By executing the \texttt{scons} command, some examples will be built the in the directory \texttt{kml/examples/}. If this is your first install, perhaps you are interested in continuing by reading the \href{\kmlroot/tutorial.html}{tutorial}, or browsing through the \href{\kmlroot/reference/}{Reference}. If for some reason these instructions did not work out as advertised here, please drop us a message at kml-devel@terborg.net, and/or take a look at the \href{\kmlroot/improvement.html}{improvement guide}. % Suppose you would like to check for updates of the software, % basically performing a % % % \begin{verbatim} % /kml$ svn update % \end{verbatim} % % % will update your local repository. % \section{Download} % \label{section:download} % % The latest release of the Kernel-Machine Library is 0.1. However, this is not the recommended version; you are encouraged to % download the latest developer version through % \href{http://www.terborg.net/cgi-bin/viewcvs.cgi/trunk/kml/}{viewCVS} until 0.2 is released. % Version 0.1 can still be downloaded, either as a tarball % from \href{research/kml/kml-0.1.tar.gz}{kml-0.1.tar.gz} or as a zipped archive % from \href{research/kml/kml-0.1.zip}{kml-0.1.zip}. % % I have created a tarball of % \href{research/kml/boost\_bindings.tar.gz}{boost\_bindings.tar.gz} % and a zipfile % \href{research/kml/boost\_bindings.zip}{boost\_bindings.zip}% % , which are on basis of Boost's sandbox CVS of April 3rd, 2005. % % % The development version of the Kernel-Machine Library can be checked out anonymously from % the trunk directory of the subversion repository located at % \href{http://www.terborg.net/svn/trunk/kml/}{http://www.terborg.net/svn/trunk/kml/}. By using the following command % \begin{verbatim} % svn checkout http://www.terborg.net/svn/trunk/kml % \end{verbatim} % a fresh up-to-date KML directory will be obtained. \section{Microsoft Windows} This section describes the necessary steps to start using the Kernel-Machine Library on a Microsoft Windows System, using free software only. To be able to perform these steps, you will need Administrator privileges. \subsection{Install Visual C++} To develop applications comfortably under Microsoft Windows, you will need to have installed both a \href{http://msdn.microsoft.com/vstudio/express/visualc/}{C++ compiler}, and the \href{http://msdn.microsoft.com/vstudio/express/visualc/usingpsdk/}{Windows Platform SDK} (the latter is already included in the non-free version of Visual C++). Some additional installation instructions and hints are also available the notes on the page about Boost's \href{http://www.boost.org/tools/build/v1/vc-8_0-tools.html}{vc-8_0 toolset}. To check whether the compiler is installed, please run the Visual C++ Command Window (should be available in your menu), and try to execute \texttt{cl}. Check whether a file \texttt{vcvars32.bat} exists in the \texttt{bin} subdirectory of the Visual C++ compiler, as it is needed to build the Boost Libraries in the next step. \subsection{Install the Boost Libraries} On Windows x86 platforms, the Boost Libraries can most easily be installed using self-extracting prebuilt executables. The authors of the Boost libraries provide installation instructions at their \href{http://www.boost.org/more/getting_started.html}{getting started} page. For the impatient, we have provided the following steps. % \begin{enumerate} \item Download the self-extracting executable file \href{http://prdownloads.sourceforge.net/boost/boost_1_33_1.exe?download} {boost_1_33_1.exe} from Sourceforge. After the download is complete, run the executable, and extract the files to \texttt{C:\textbackslash Boost}. \item Download the zip archive of \href{http://prdownloads.sourceforge.net/boost/boost-jam-3.1.13-1-ntx86.zip?download} {boost-jam-3.1.13-1-ntx86.zip}, also from Sourceforge. Extract the \texttt{bjam.exe} file to the directory \texttt{C:\textbackslash Boost} created in step 1. \item Open the Visual C++ Command Window, change directory to \texttt{C:\textbackslash Boost}, type \begin{verbatim} bjam "-sTOOLS=vc-8_0" \end{verbatim} and wait for the compilation process to finish. \end{enumerate} % The Boost libraries are now installed. If anything went wrong, then more detailed information about Boost can be found at \href{http://www.boost.org/}{Boost's homepage}. % \subsection{Install Boost Numeric Bindings} % % Download \href{research/kml/boost\_bindings.zip}{boost\_bindings.zip} % and unzip it into the Boost directory. Make sure the subdirectories are aligned, % i.e. the directory stucture % \texttt{boost\textbackslash{}numeric\textbackslash{}bindings} should exist. \subsection{Install ATLAS} Obtaining working ATLAS binaries under Microsoft Windows could be one of the most annoying steps. If you are lucky, you could use convenient prebuilt libraries provided here (if available). Otherwise you will have to create ATLAS DLLs manually. \subsubsection{Prebuilt ATLAS libraries} The following files are available here: \begin{itemize} \item \href{research/kml/WinNT\_ATHLONSSE1.zip}{WinNT\_ATHLONSSE1.zip} \item \href{research/kml/WinNT\_PIIISSE1.zip}{WinNT\_PIIISSE1.zip} \end{itemize} If you use these, you can skip the next subsection and go ahead to subsection \ref{section:install_scons}. If your architecture is not listed here, and if you have successfully built an ATLAS dll and lib (as described below), please send us a copy of the dll and lib file at kml-devel@terborg.net. Your hard work will safe other people's time, which we think is a good thing. \subsubsection{Build your own ATLAS binaries} \begin{enumerate} \item Download the platform-independent source package \href{http://prdownloads.sourceforge.net/math-atlas/atlas3.6.0.tar.gz?download}{atlas3.6.0.tar.gz} from Sourceforge, and unzip it to \texttt{C:\textbackslash Atlas}. \item Apply the patches ``\href{http://math-atlas.sourceforge.net/errata.html#winsse} {Assembler renaming problem for Windows machine}'' and the ``\href{http://math-atlas.sourceforge.net/errata.html#longcomp}{String overrun in config for long compiler paths}'', described at the \href{http://math-atlas.sourceforge.net/errata.html} {ATLAS errata page}. Both patches need to be applied, otherwise the ATLAS build process will most probably fail. \item Install Cygwin by running the \href{http://www.cygwin.com/setup.exe}{setup.exe}. Make sure to have added the following packages to the default install: \begin{itemize} % 2006-12-18. The right-arrow issue. % first tried to use \usepackage{textcomp} in combination with \textrightarrow{}; which produces % the correct result: an utf-8 encoded rightarrow. Unfortunately, this character is not (yet) supported % on enough browsers. Therefore, a math-symbol is inserted. :-( \item Devel $\rightarrow$ gcc-g++ \item Devel $\rightarrow$ gcc-g77 \item Devel $\rightarrow$ make \end{itemize} \item Gather information about the cache size of your CPU. If you are not sure about the exact specifics of your processor, then you could try a hardware detection program, such as \href{http://www.cpuid.org/cpuz.php}{CPU-Z}. \item Open a Cywin console window, and change to the ATLAS root directory, and start the configuration of ATLAS. % \begin{verbatim} cd C:\Atlas make config \end{verbatim} % You will be asked a series of questions, shown below. If you press enter without answering, it will use the [default] value. % \begin{verbatim} Enter number at top left of screen [0]: 24 Have you scoped the errata file? [y]: Are you ready to continue? [y]: Enter your machine type: 1. Other/UNKNOWN 2. AMD Athlon 3. 32 bit AMD Hammer 4. 64 bit AMD Hammer 5. Pentium PRO 6. Pentium II 7. Pentium III 8. Pentium 4 Enter machine number [1]: 2 enable Posix threads support? [n]: use express setup? [y]: Enter Architecture name (ARCH) [WinNT_ATHLONSSE1]: Enter Maximum cache size (KB) [4096]: Enter File creation delay in seconds [0]: Use supplied default values for install? [y]: \end{verbatim} % After these questions have been answered, ATLAS will create makefiles on the basis of your configuration. It will give you a confirmation of success. \item Start the build process, which is initiated by something like % \begin{verbatim} make install arch=WinNT_ATHLONSSE1 \end{verbatim} % depending on the name of your processor. After compiling, you will have a subdirectory called \texttt{lib/WinNT\_ATHLONSSE1} in your ATLAS directory, which should contain the following files: \begin{itemize} \item \texttt{libatlas.a} \item \texttt{libcblas.a} \item \texttt{libf77blas.a} \item \texttt{liblapack.a} \end{itemize} These files are \emph{the} ATLAS binaries, and they may be used to create a DLL containing these files. \item This step is optional: it is only needed if you are \textbf{not} installing the Kernel-Machine Library, but rather would like to obtain a stand-alone ATLAS installation. Download \href{research/kml/kml\_win\_dll.sh}{kml\_win\_dll.sh} to the directory that contains the \texttt{libatlas.a}, etc., files. (Re-)Open a Cygwin console, and change to that directory. Run the command % \begin{verbatim} ./kml_win_dll.sh \end{verbatim} % You will get a message ``Generating the KML ATLAS DLL''. After this command is complete, you should be able to see new files called \begin{itemize} \item \texttt{kml\_atlas.dll} \item \texttt{kml\_atlas.lib} \end{itemize} in that directory. % If you would like to link against the ATLAS routines from within Visual Studio, you will have to do two things in Visual Studio: \begin{itemize} \item ensure the \texttt{kml\_atlas.dll} file is located in your PATH \item instruct the linker to link your project against \texttt{kml\_atlas.lib}. \end{itemize} \end{enumerate} \subsection{Install SCons} \label{section:install_scons} Prior to installing SCons, install Python by downloading and running the installer \href{http://www.python.org/ftp/python/2.5/python-2.5.msi}{python-2.5.msi}. Make sure that Python is in your PATH, e.g., by adding by \texttt{C:\textbackslash Python25} to your PATH environment variable, as described \href{http://www.python.org/doc/faq/windows.html#how-do-i-run-a-python-program-under-windows}{here}. Next, install Scons by running \href{http://prdownloads.sourceforge.net/scons/scons-0.96.1.win32.exe?download}{scons-0.96.1.win32.exe}. The installation process will find Python automatically. \subsection{Install the Kernel-Machine Library} Download the latest zipped archive of the Kernel-Machine Library, \href{http://www.terborg.net/cgi-bin/viewcvs.cgi/trunk/kml.tar.gz?view=tar}{kml.tar.gz}, and unzip it to a directory of your choice, e.g., \texttt{C:\textbackslash kml}. Open a Visual C++ Command Window, and execute the following steps. % \begin{verbatim} cd C:\kml scons \end{verbatim} % By executing the \texttt{scons} command, the ATLAS DLL will be built, and some examples will be built in the directory \texttt{kml\textbackslash examples}. If this is your first install, perhaps you are interested in continuing by reading the \href{\kmlroot/tutorial.html}{tutorial}, or browsing through the \href{\kmlroot/reference/}{Reference}. If for some reason these instructions did not work out as advertised here, please drop us a message at kml-devel@terborg.net, and/or take a look at the \href{\kmlroot/improvement.html}{improvement guide}. \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/kml_win_dll.sh000644 000765 000024 00000011025 10457423463 016543 0ustar00pawelmstaff000000 000000 #! /bin/bash GCC=gcc defname=kml_atlas.def dllname=kml_atlas.dll libbat=generate_implib.bat #-------------------------------------------- # .DEF file generation #-------------------------------------------- echo 'Generating the .def file...' Cexports=(\ #single precision routines cblas_sdsdot cblas_sdot cblas_snrm2 cblas_sasum cblas_scnrm2 \ cblas_scasum cblas_sscal cblas_isamax \ cblas_sswap cblas_scopy cblas_saxpy catlas_saxpby catlas_sset \ cblas_srotg cblas_srotmg cblas_srot cblas_srotm \ cblas_sgemv cblas_sgbmv cblas_strmv cblas_stbmv cblas_stpmv \ cblas_strsv cblas_stbsv cblas_stpsv \ cblas_ssymv cblas_ssbmv cblas_sspmv cblas_sger cblas_ssyr \ cblas_sspr cblas_ssyr2 cblas_sspr2 \ cblas_sgemm cblas_ssymm cblas_ssyrk cblas_ssyr2k cblas_strmm cblas_strsm \ #double precision routines cblas_dsdot cblas_ddot cblas_dnrm2 cblas_dasum cblas_dznrm2 \ cblas_dzasum cblas_dscal cblas_idamax \ cblas_dswap cblas_dcopy cblas_daxpy catlas_daxpby catlas_dset \ cblas_drotg cblas_drotmg cblas_drot cblas_drotm \ cblas_dgemv cblas_dgbmv cblas_dtrmv cblas_dtbmv cblas_dtpmv \ cblas_dtrsv cblas_dtbsv cblas_dtpsv \ cblas_dsymv cblas_dsbmv cblas_dspmv cblas_dger cblas_dsyr \ cblas_dspr cblas_dsyr2 cblas_dspr2 \ cblas_dgemm cblas_dsymm cblas_dsyrk cblas_dsyr2k cblas_dtrmm cblas_dtrsm \ #single precision complex routines # cblas_cdotu_sub cblas_cdotc_sub cblas_cscal cblas_csscal cblas_icamax \ # cblas_cswap cblas_ccopy cblas_caxpy catlas_caxpby catlas_cset \ # cblas_crotg cblas_csrot \ # cblas_cgemv cblas_cgbmv cblas_ctrmv cblas_ctbmv cblas_ctpmv \ # cblas_ctrsv cblas_ctbsv cblas_ctpsv \ # cblas_chemv cblas_chbmv cblas_chpmv cblas_cgeru cblas_cgerc \ # cblas_cher cblas_chpr cblas_cher2 cblas_chpr2 \ # cblas_cgemm cblas_csymm cblas_csyrk cblas_csyr2k cblas_ctrmm cblas_ctrsm \ # cblas_chemm cblas_cherk cblas_cher2k \ #double precision complex routines # cblas_zdotu_sub cblas_zdotc_sub cblas_zscal cblas_zdscal cblas_izamax \ # cblas_zswap cblas_zcopy cblas_zaxpy catlas_zaxpby catlas_zset \ # cblas_zrotg cblas_zdrot \ # cblas_zgemv cblas_zgbmv cblas_ztrmv cblas_ztbmv cblas_ztpmv \ # cblas_ztrsv cblas_ztbsv cblas_ztpsv \ # cblas_zhemv cblas_zhbmv cblas_zhpmv cblas_zgeru cblas_zgerc \ # cblas_zher cblas_zhpr cblas_zher2 cblas_zhpr2 \ # cblas_zgemm cblas_zsymm cblas_zsyrk cblas_zsyr2k cblas_ztrmm cblas_ztrsm \ # cblas_zhemm cblas_zherk cblas_zher2k \ #other stuff # cblas_errprn \ # CLAPACK interface subset clapack_sgesv clapack_sgetrf clapack_sgetrs clapack_sgetri \ clapack_sposv clapack_spotrf clapack_spotrs clapack_spotri \ clapack_slauum clapack_strtri \ clapack_dgesv clapack_dgetrf clapack_dgetrs clapack_dgetri \ clapack_dposv clapack_dpotrf clapack_dpotrs clapack_dpotri \ clapack_dlauum clapack_dtrtri \ clapack_cgesv clapack_cgetrf clapack_cgetrs clapack_cgetri \ clapack_cposv clapack_cpotrf clapack_cpotrs clapack_cpotri \ clapack_clauum clapack_ctrtri \ clapack_zgesv clapack_zgetrf clapack_zgetrs clapack_zgetri \ clapack_zposv clapack_zpotrf clapack_zpotrs clapack_zpotri \ clapack_zlauum clapack_ztrtri) #-------------------------------------------- # Generate a .def file #-------------------------------------------- echo "EXPORTS" > ${defname} for (( i = 0 ; i < ${#Cexports[*]} ; i++ )) ; do export=${Cexports[$i]} echo -e "${export}=${export}" >> ${defname} done #-------------------------------------------- # Making a .DLL from the .a files #-------------------------------------------- echo 'Generating windows .dll file...' CLIBPATH=/usr/lib/mingw mingwclib="$CLIBPATH/libg2c.a $CLIBPATH/libmoldname.a $CLIBPATH/libmsvcrt.a" ${GCC} -mno-cygwin -shared -o ${dllname} ${defname} \ liblapack.a libcblas.a libf77blas.a libatlas.a \ -Wl,--enable-auto-import \ -Wl,--no-whole-archive ${mingwclib} #-------------------------------------------- # Making a .bat for the import-library # # TODO: figure out a better way to find vcvars32.bat #-------------------------------------------- echo 'Generating the import library script...' echo " " > $libbat echo -e 'call "C:/Program Files/Microsoft Visual Studio .NET 2003/Vc7/bin/vcvars32.bat"' >> $libbat echo -e 'call "C:/Program Files/Microsoft Visual Studio/VC98/bin/vcvars32.bat"' >> $libbat echo -e 'call "C:/Program Files/DevStudio/VC/bin/vcvars32.bat"' >> $libbat echo -e 'call "C:/Msdev/bin/vcvars32.bat x86"' >> $libbat echo -e 'lib.exe /DEF:kml_atlas.def /MACHINE:Ix86 /OUT:kml_atlas.lib' >> $libbat echo 'Running the import library script...' chmod +x ./$libbat ./$libbat mkdir win mv kml_atlas.dll win mv kml_atlas.lib win cp ../../include/cblas.h win cp ../../include/clapack.h win kml_src/doc/obtain.tex000644 000765 000024 00000004716 10731214757 015722 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \begin{document} \title{Obtaining KML} \maketitle \section*{Dependencies} The Kernel-Machine Library builds on top of the libraries below. \begin{itemize} \item \textbf{Boost.} Functionality of several \href{http://www.boost.org}{Boost libraries} is in use throughout the Kernel-Machine Library. Boost provides an excellent set of C++ libraries which reduces the amount of code and boosts the quality of the overall implementation. The Kernel-Machine Library is built and tested against version 1.32.0. \item \textbf{Boost Numeric Bindings.} A part of Boost's sandbox CVS repository is required, namely the numeric bindings. This is a software package that combines the flexibility of the C++ data types (such as that of \texttt{std::vector<>} or \texttt{ublas::matrix<>}) with the computational efficiency of a BLAS and LAPACK. \item \textbf{ATLAS.} This is a very efficient basic linear algebra system (BLAS) \citep{whaley01automated}, located at \href{http://math-atlas.sourceforge.net}{Sourceforge}. ATLAS can empirically finetune its code to make optimal use of your CPU including its extensions such as SSE, 3DNow! and AltiVec. It also contains several LAPACK routines. \end{itemize} \section*{Download} \label{section:download} The latest release of the Kernel-Machine Library is 0.1. However, this is not the recommended version; you are encouraged to download the latest developer version through \href{http://www.terborg.net/cgi-bin/viewcvs.cgi/trunk/kml/}{viewCVS} until 0.2 is released. Version 0.1 can still be downloaded, either as a tarball from \href{research/kml/kml-0.1.tar.gz}{kml-0.1.tar.gz} or as a zipped archive from \href{research/kml/kml-0.1.zip}{kml-0.1.zip}. I have created a tarball of \href{research/kml/boost\_bindings.tar.gz}{boost\_bindings.tar.gz} and a zipfile \href{research/kml/boost\_bindings.zip}{boost\_bindings.zip}% , which are on basis of Boost's sandbox CVS of April 3rd, 2005. The development version of the Kernel-Machine Library can be checked out anonymously from the trunk directory of the subversion repository located at \href{http://www.terborg.net/svn/trunk/kml/}{http://www.terborg.net/svn/trunk/kml/}. By using the following command \begin{verbatim} svn checkout http://www.terborg.net/svn/trunk/kml \end{verbatim} a fresh up-to-date KML directory will be obtained. \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/000755 000765 000024 00000000000 11676172345 015657 5ustar00pawelmstaff000000 000000 kml_src/doc/SConscript000644 000765 000024 00000001120 10554074523 015716 0ustar00pawelmstaff000000 000000 Import('env') Import('install_dir') kmlroot = '/research/kml' obj = [] # generic pages obj += env.XHTML( 'index.html_fase4' ) obj += env.HTML( 'improvement.tex' ) obj += env.HTML( 'tutorial.tex' ) obj += env.HTML( 'installation.tex' ) # process subdirectories for loc in ['reference']: o = SConscript( dirs= loc ) obj += o env.Install( install_dir + '/research/kml', ['boost_bindings.tar.gz', 'boost_bindings.zip', 'kml-0.1.tar.gz', 'kml-0.1.zip', 'kml_win_dll.sh', 'WinNT_ATHLONSSE1.zip', 'WinNT_PIIISSE1.zip', 'install_WinNT_VC.html'] ) Return( 'obj' ) kml_src/doc/sinc_data.R000644 000765 000024 00000000275 10542532147 015764 0ustar00pawelmstaff000000 000000 N <- 50 x <- vector(length=N) for( i in 1:N ) { x[i] <- (i-1) / (N-1) * 20.0 - 10.0 } y <- sin(x) / x + rnorm( N, 0, 0.1 ) halfplot() plot( x, y, xlab="x", ylab="sinc(x)+N(0,0.1)" ) kml_src/doc/tutorial.tex000644 000765 000024 00000012352 10731214757 016304 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \begin{document} \title{Tutorial} \maketitle %\tableofcontents \section*{Sinc regression} A common benchmark used in the kernel-machine literature is that of a toy sinc function. Here we show how to reproduce these examples with a kernel machine of your choice. First, let us define our data structure. % \highlightcpp{} \begin{verbatim} #include typedef std::pair< double, double > example_type; typedef boost::vector_property_map< example_type > container_type; \end{verbatim} % The \texttt{example_type} is an input-output pair $(x_i,y_i)$ with both inputs and outputs being of type \texttt{double}. The \texttt{container_type} provides a type definition for the data container to be used by the kernel machine of choice (this could also very well be, e.g., a custom class that accesses a database on-the-fly to retrieve examples of example_type). We let the data for one experiment consist of 50 examples $(x_1,y_1),\ldots,(x_{50},y_{50})$, with inputs $x_{i}$ uniformly distributed over [-10,10], and outputs corrupted with Gaussian noise, $y_{i}\sim N(\mathrm{sinc}(x_{i}),0.1)$. % \highlightcpp{} \begin{verbatim} #include #include #include #include // create the random number generator N(0,0.1) boost::mt19937 randomness; typedef boost::normal_distribution dist_type; dist_type norm_dist( 0.0, 0.1 ); boost::variate_generator< boost::mt19937, dist_type > noise( randomness, norm_dist ); // instantiate the data container, and fill it with (x,y)-pairs container_type my_data; for( int i=0; i<50; ++i ) { double x = static_cast(i) / 49.0 * 20.0 - 10.0; my_data[ i ] = std::make_pair( x, boost::sinc(x) + noise() ); } \end{verbatim} % To generate the outputs, we have pulled in parts from the \href{http://www.boost.org/libs/random/index.html}{Boost Random Number Library}, and the sinc function from the \href{http://www.boost.org/libs/math/special_functions/index.html}{Boost Math Special Functions Library}. % % Figure~\ref{figure:sinc_regression} shows an example scatterplot of the data that we just built the generator for. \begin{figure} \includegraphics{sinc_data} \caption{Input data generated for our first tutorial example.} \label{figure:sinc_regression} \end{figure} % % \section*{Writing your own kernel} % % In this part of the tutorial we will create a novel type of kernel: a string kernel. To do so, % simply create a fresh source-file, called, e.g., string_kernel.hpp. % % \highlightcpp{} % \begin{verbatim} % class string_kernel: public kml::kernel< std::string, double, % string_kernel, kml::mercer_tag > { % }; % \end{verbatim} % % The first template parameter indicates that the inputs we are accepting are of type std::string. The second % template parameter says that our kernel function will return doubles, the third uses a C++ pattern called % the \emph{Curiously Recurring Template Pattern}, which enables some tricks, and the fourth parameter indicates % that we are constructing a string kernel. % % \highlightcpp{} % \begin{verbatim} % // evaluate the "closeness" of strings u and v % double dot( std::string const &u, std::string const &v ) const { % ... % } % \end{verbatim} % % If your kernel provides parameters, it should encode that in some way such that the kernel-machine % libary may use those. ... % % Now, let's see what we have gained with this new kernel. % % \highlightcpp{} % \begin{verbatim} % string_kernel my_kernel( sigma=2.0 ); % kml::svm< ..., string_kernel, > my_machine; % my_machine.learn( keys.begin(), keys.end() ); % \end{verbatim} % % This will deliver a SVM with your new kernel compiled in. % % % \section*{Data I/O} % % Kernel machines are used a lot for data mining, and given that data mining involves data, the IO functionaly % of the kernel-machine library is very convenient. It allows for the storage of all types that have serialization % support. % % \highlightcpp{} % \begin{verbatim} % std::vector< std::size_t > my_keys; % boost::property_map< ... > my_data; % kml::file my_file( "somedata.txt" ); % // read file which is in text form % my_file.read( my_data ); % // try to convert to binary first, then read the file % my_file.read( my_data, kml::io::convert_to_binary ); % my_file.close(); % \end{verbatim} % % All kernel machines available in the KML have serialization support, which means that you can load and save them % accordingly. % % \highlightcpp{} % \begin{verbatim} % std::ofstream my_file( "outputfile.txt" | std::ios::binary ); % boost::binary_ofstream ofs( my_model ); % ofs << my_machine; % my_file.close(); % \end{verbatim} % % \section*{Writing your own kernel machine} % % % \section*{Reinforcement Learning} % % For something different, let us implement the reinforcement learning as done by REF... % We will implement a SARSA algorithm using kernel machines to make things interesting. \section*{See Also} \href{\kmlroot/reference/}{Reference} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/view_matrix.fig000644 000765 000024 00000001263 10457423463 016744 0ustar00pawelmstaff000000 000000 #FIG 3.2 Produced by xfig version 3.2.5-alpha5 Landscape Center Metric Letter 100.00 Single -2 1200 2 0 32 #eff3ef 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 360 540 2430 540 2430 2610 360 2610 360 540 2 2 0 1 0 -1 52 -1 1 0.000 0 0 -1 0 0 5 360 540 2070 540 2070 2160 360 2160 360 540 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2 1 1 1.00 60.00 120.00 1 1 1.00 60.00 120.00 360 1530 2070 1530 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2 1 1 1.00 60.00 120.00 1 1 1.00 60.00 120.00 720 540 720 2160 4 1 0 50 -1 0 10 0.0000 0 105 1425 1395 2430 Static container matrix\001 4 1 0 50 -1 0 10 0.0000 0 135 870 1350 1215 Dynamic view\001 4 1 0 50 -1 0 10 0.0000 0 105 435 1350 1395 matrix\001 kml_src/doc/view_matrix.tex000644 000765 000024 00000000373 10542537135 016775 0ustar00pawelmstaff000000 000000 \documentclass{article} % do not include the default myinclude file \usepackage{graphicx} \usepackage{color} \begin{document} \pagestyle{empty} \begin{figure} \input{build/website/root/research/kml/view_matrix.pdftex_t} \end{figure} \end{document} kml_src/doc/reference/classification.tex000644 000765 000024 00000001462 10544755446 021401 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{classification} \maketitle \section*{Description} Classification is a type of \href{\kmlroot/reference/supervised_learning.html}{Supervised Learning}. \section*{Example} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/classification.hpp}{kml/classification.hpp}. \section*{Template Parameters} \section*{Model of} \href{\kmlroot/reference/supervised_learning.html}{Supervised Learning} \section*{Type requirements} \section*{Members} \section*{Notes} \section*{See also} \href{\kmlroot/reference/ranking.html}{ranking}, \href{\kmlroot/reference/regression.html}{regression} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/feature_space.fig000644 000765 000024 00000012333 10542537135 021147 0ustar00pawelmstaff000000 000000 #FIG 3.2 Landscape Center Metric A4 100.00 Single -2 1200 2 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1296 225 9 9 1287 225 1305 225 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1395 270 9 9 1386 270 1404 270 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1440 405 9 9 1431 405 1449 405 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1530 495 9 9 1521 495 1539 495 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1530 360 9 9 1521 360 1539 360 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1485 270 9 9 1476 270 1494 270 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1395 225 9 9 1386 225 1404 225 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1620 585 9 9 1611 585 1629 585 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1530 720 9 9 1521 720 1539 720 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1575 855 9 9 1566 855 1584 855 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1440 810 9 9 1431 810 1449 810 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1395 855 9 9 1386 855 1404 855 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1305 945 9 9 1296 945 1314 945 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1215 900 9 9 1206 900 1224 900 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1080 945 9 9 1071 945 1089 945 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1080 945 9 9 1071 945 1089 945 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1080 945 9 9 1071 945 1089 945 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1125 855 9 9 1116 855 1134 855 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1035 810 9 9 1026 810 1044 810 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 945 765 9 9 936 765 954 765 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1035 900 9 9 1026 900 1044 900 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 855 765 9 9 846 765 864 765 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 1575 765 9 9 1566 765 1584 765 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 765 720 9 9 756 720 774 720 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 675 765 9 9 666 765 684 765 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 585 720 9 9 576 720 594 720 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 495 765 9 9 486 765 504 765 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 360 765 9 9 351 765 369 765 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 315 855 9 9 306 855 324 855 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 315 945 9 9 306 945 324 945 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 225 1035 9 9 216 1035 234 1035 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 225 1215 9 9 216 1215 234 1215 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 270 1305 9 9 261 1305 279 1305 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 360 1575 9 9 351 1575 369 1575 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 495 1575 9 9 486 1575 504 1575 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 360 1395 9 9 351 1395 369 1395 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 315 1260 9 9 306 1260 324 1260 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 270 1125 9 9 261 1125 279 1125 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 765 765 9 9 756 765 774 765 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 945 855 9 9 936 855 954 855 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 270 1440 9 9 261 1440 279 1440 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 2970 1575 9 9 2961 1575 2979 1575 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3015 1440 9 9 3006 1440 3024 1440 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3105 1305 9 9 3096 1305 3114 1305 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3195 1080 9 9 3186 1080 3204 1080 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3285 900 9 9 3276 900 3294 900 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3465 810 9 9 3456 810 3474 810 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3510 675 9 9 3501 675 3519 675 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3510 675 9 9 3501 675 3519 675 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3645 495 9 9 3636 495 3654 495 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3600 270 9 9 3591 270 3609 270 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3645 180 9 9 3636 180 3654 180 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3510 450 9 9 3501 450 3519 450 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3420 585 9 9 3411 585 3429 585 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3240 810 9 9 3231 810 3249 810 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3330 720 9 9 3321 720 3339 720 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3195 990 9 9 3186 990 3204 990 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3285 1170 9 9 3276 1170 3294 1170 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3240 1260 9 9 3231 1260 3249 1260 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3150 1395 9 9 3141 1395 3159 1395 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3105 1485 9 9 3096 1485 3114 1485 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3330 1035 9 9 3321 1035 3339 1035 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3645 360 9 9 3636 360 3654 360 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3690 315 9 9 3681 315 3699 315 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3510 630 9 9 3501 630 3519 630 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3555 540 9 9 3546 540 3564 540 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3150 1215 9 9 3141 1215 3159 1215 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3060 1350 9 9 3051 1350 3069 1350 1 4 0 1 0 -1 50 -1 20 0.000 1 0.0000 3375 945 9 9 3366 945 3384 945 2 2 0 2 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2430 0 4230 0 4230 1800 2430 1800 2430 0 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 2970 1620 3690 180 2 2 0 2 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 0 0 1800 0 1800 1800 0 1800 0 0 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1890 900 2340 900 3 2 0 1 0 7 50 -1 -1 0.000 0 0 0 4 450 1620 360 810 1485 855 1350 180 0.000 -1.000 -1.000 0.000 4 0 0 50 -1 0 12 0.0000 6 195 1140 180 360 $\\mathcal{X}$\001 4 0 0 50 -1 0 12 0.0000 6 195 1140 2610 360 $\\mathcal{H}$\001 4 1 0 50 -1 0 12 0.0000 6 165 465 2115 810 $\\Phi$\001 kml_src/doc/reference/figueiredo.tex000644 000765 000024 00000001237 10553622243 020514 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{figueiredo} \maketitle \section*{Description} \texttt{figueiredo} implements the method of Figueiredo \cite{figueiredo01adaptive,figueiredo03adaptive}. \section*{Example} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/figueiredo.hpp}{kml/figueiredo.hpp}. \section*{Template Parameters} \section*{Model of} \section*{Type requirements} \section*{Public Base Classes} \section*{Members} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/gaussian.tex000644 000765 000024 00000005034 10546743152 020210 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \newcommand{\half}{\tfrac{1}{2}} \begin{document} \title{gaussian} \maketitle \section*{Description} \texttt{Gaussian} is a Kernel. Specifically, it is a \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}. If k is an object of class \texttt{gaussian}, and \texttt{u} and \texttt{v} are objects of class T, then k(u,v) returns % % % Important: use \[ \] in stead of $$ $$, because otherwise tex4ht will generate wrong HTML (missing paragraph tags

) % \[k(u,v) = \textrm{exp}( - \half \sigma^{-2} \Vert u-v \Vert^2 )\] % where $\sigma$ is the width of the kernel. Figure~\ref{figure:gaussian_kernel} shows a Gaussian kernel. \begin{figure} \includegraphics{gaussian_kernel} \includegraphics{gaussian_kernel_3d} \caption{A two dimensional (left) and three-dimensional (right) plot of a single Gaussian kernel located at the origin.} \label{figure:gaussian_kernel} \end{figure} The Gaussian kernel is a good choice for a great deal of applications, although sometimes it is remarked as being overused \cite{scholkopf02learning}. \section*{Example} \highlightcpp{} \begin{verbatim} std::vector< double > u(10); std::vector< double > v(10); gaussian< std::vector< double > > kernel(1.0); std::cout << kernel( u, v ) << std::endl; \end{verbatim} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/gaussian.hpp}{kml/gaussian.hpp}. \section*{Template Parameters} \begin{tabular}{lll} \textbf{Parameter} & \textbf{Description} & \textbf{Default} \\ \hline T & The gaussian argument type \\ \end{tabular} \section*{Model of} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel} \section*{Type requirements} T must be a vector type or a numeric type; distance_squared should evaluate. \section*{Members} \begin{tabular}{lll} \textbf{Member} & \textbf{Where defined} & \textbf{Description} \\ \hline \texttt{gaussian()} & \href{http://www.sgi.com/tech/stl/DefaultConstructible.html}{Default Constructible} & The default constructor \\ \texttt{result_type} & Input value & The type of the result: \texttt{input_value} \\ \end{tabular} \section*{Notes} \section*{See also} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}, \href{\kmlroot/reference/linear.html}{linear}, \href{\kmlroot/reference/hermitian.html}{hermitian}, \href{\kmlroot/reference/polynomial.html}{polynomial}, \href{\kmlroot/reference/sigmoid.html}{sigmoid} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/gaussian_kernel.R000644 000765 000024 00000000266 10542537135 021151 0ustar00pawelmstaff000000 000000 gaussian <- function(u, v) { return ( exp( - (u-v)^2 / (2*1^2) ) ) } N <- 50 x <- seq(-3,3,length=N) halfplot() plot( x, gaussian(x,0), type="l", xlab="u", ylab="k(u,0)" ) kml_src/doc/reference/gaussian_kernel_3d.R000644 000765 000024 00000000563 10542537135 021537 0ustar00pawelmstaff000000 000000 gaussian <- function(u, v) { return ( exp( - t(u-v) %*% (u-v) / (2*1^2) ) ) } N <- 25 x <- seq(-3,3,length=N) y <- matrix( nrow=N, ncol=N ) for( i in 1:N ) { for( j in 1:N ) { y[i,j] <- gaussian( c(x[i],x[j]), c(0,0) ) } } #par("mfcol"=c(1,2)) # 3d version Gaussian kernel halfplot() persp(x,x,y, col="lightblue", phi=40, theta=120, shade=0.3 ) kml_src/doc/reference/hermitian.tex000644 000765 000024 00000005200 10542537135 020347 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \newcommand{\half}{\tfrac{1}{2}} \begin{document} \title{hermitian} \maketitle \section*{Description} \texttt{Hermitian} is a family of Kernels. Specifically, it is a family of \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernels}. The N-th Hermitian kernel is equal to the N-th order derivative of the Gaussian kernel. They are named after Hermite polynomials, which may be used to identify the derivatives of the Gaussian kernels. If k is an object of class \texttt{hermite}, u and v are objects of class T, and N is a integral constant, then k(u,v) returns % \begin{equation} D^{n}k(u,v)=(-\sqrt{2}\sigma)^{-n}H_{n}((\sqrt{2}\sigma)^{-1}(u-v))\exp(-\half\sigma^{-2}\left\Vert u-v\right\Vert^{2}). \end{equation} % where $H_n$ is Rodrigues' formula for Hermite polynomials \begin{equation} H_{n}(x)=(-1)^{n}\exp(x^{2})D^{n}\exp(-x^{2}). \end{equation} % Figure~\ref{figure:hermitian_kernel} shows the Hermitian kernel for N=0 through N=5 for a scalar input type. \begin{figure} \includegraphics{hermitian_kernel} \caption{Hermitian kernels, parametrised by $\sigma=1$, with N=0 at the top left through N=5 at the bottom right.} \label{figure:hermitian_kernel} \end{figure} \section*{Example} \highlightcpp{} \begin{verbatim} vector< double > x(10); vector< double > v(10); hermitian< vector< double >, 2 > kernel(1.0); cout << kernel( x, v ) << endl; \end{verbatim} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/hermitian.hpp}{kml/hermitian.hpp}. \section*{Template Parameters} \begin{tabular}{lll} \textbf{Parameter} & \textbf{Description} & \textbf{Default} \\ \hline T & The hermitian argument type \\ N & The order of the hermitian \\ \end{tabular} \section*{Model of} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel} \section*{Type requirements} T must be a vector type or a scalar type. \section*{Members} \begin{tabular}{lll} \textbf{Member} & \textbf{Where defined} & \textbf{Description} \\ \hline \texttt{hermitian()} & \href{http://www.sgi.com/tech/stl/DefaultConstructible.html}{Default Constructible} & The default constructor \\ \texttt{result_type} & Input value & The type of the result: \texttt{input_value} \\ \end{tabular} \section*{Notes} \section*{See also} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}, \href{\kmlroot/reference/linear.html}{linear}, \href{\kmlroot/reference/gaussian.html}{gaussian}, \href{\kmlroot/reference/polynomial.html}{polynomial}, \href{\kmlroot/reference/sigmoid.html}{sigmoid} \bibliographystyle{unsrt} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/hermitian_kernel.R000644 000765 000024 00000002347 10542537135 021321 0ustar00pawelmstaff000000 000000 gaussian <- function(x, s) { return ( exp( -x^2 / (2*s^2) ) ) } gaussianD1 <- function(x,s) { u <- sqrt(2)*s v <- 1/u return ( (-u)^-1 * (2*v*x) * exp( -x^2 / (2*s^2) ) ) } gaussianD2 <- function(x,s) { u <- sqrt(2)*s v <- 1/u return ( (-u)^-2 * (4*(v*x)^2-2) * exp( -x^2 / (2*s^2) ) ) } gaussianD3 <- function(x,s) { u <- sqrt(2)*s v <- 1/u return ( (-u)^-3 * (8*(v*x)^3-12*(v*x)) * exp( -x^2 / (2*s^2) ) ) } gaussianD4 <- function(x,s) { u <- sqrt(2)*s v <- 1/u return ( (-u)^-4 * (16*(v*x)^4-48*(v*x)^2+12) * exp( -x^2 / (2*s^2)) ) } gaussianD5 <- function(x,s) { u <- sqrt(2)*s v <- 1/u return ( (-u)^-5 * (32*(v*x)^5-160*(v*x)^3+120*(v*x)) * exp( -x^2 / (2*s^2) ) ) } fullplot() par("mfcol"=c(2,3)) x <- seq(-3,3,length=100) plot( x, gaussian(x,1), type="l", ylab=expression(k(bold(x),bold(x)[i])) ) plot( x, gaussianD3(x,1), type="l", ylab=expression(D^3*k(bold(x),bold(x)[i])) ) plot( x, gaussianD1(x,1), type="l", ylab=expression(D^1*k(bold(x),bold(x)[i])) ) plot( x, gaussianD4(x,1), type="l", ylab=expression(D^4*k(bold(x),bold(x)[i])) ) plot( x, gaussianD2(x,1), type="l", ylab=expression(D^2*k(bold(x),bold(x)[i])) ) plot( x, gaussianD5(x,1), type="l", ylab=expression(D^5*k(bold(x),bold(x)[i])) ) kml_src/doc/reference/incomplete_cholesky.tex000644 000765 000024 00000031752 10553622243 022437 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} % algorithm display \usepackage{algorithm} \usepackage{algorithmic} % for the figures of xfig \usepackage{color} % linebreaks for urls \usepackage{url} % some math definitions \newcommand{\x}{x} \newcommand{\sv}{Q} \newcommand{\svm}{Q} \newcommand{\sve}{q} \newcommand{\nsve}{\mathbf{e}} \newcommand{\nonsv}{A} \newcommand{\nonsvm}{A} \newcommand{\nonsve}{a} \newcommand{\origin}{0} \newcommand{\gramm}{G} \newcommand{\ce}{R} \newcommand{\coordm}{R} \begin{document} \title{Incomplete Cholesky Factorisation} \maketitle \tableofcontents \section*{Description} The incomplete Cholesky is used in conjunction with Support Vector Machines in \cite{fine01efficient}, ... In this section we will give a geometric interpretation to the incomplete cholesky factorisation. We will start with subsection~\ref{subsection:two_circle_intersection}, where we show that it is possible to project a vector on another vector by means of a two-circle intersection. We incrementally extend the idea to a three-sphere intersection in subsection~\ref{subsection:three_sphere_intersection}, and conclude this section with a generic projection operator obtained by an associated $n$-hypersphere intersection. $$A=QR$$ where matrix $\nonsv$ is has columns with mapped defined by be a shorthand notation for our set of data $\mathcal{D}$ mapped into $\mathcal{H}$,% % \begin{equation} \nonsv=\{\nonsve_{1},...,\nonsve_{n}\}=\{\Phi(\x_{1}),...,\Phi(\x_{n})\}. \label{equation:set_to_origin} \end{equation} % Obviously, the inner product of vectors $\nonsve_{i}$ in $\nonsv$ may be expressed in terms of kernels, % \begin{equation} \nonsve_{i}^{\mathrm{T}}\nonsve_{j}=\Phi(\x_{i})^{\mathrm{T}}\Phi(\x_{j})=k(\x_{i},\x_{j}), \label{equation:inner_product_V} \end{equation}% % whereas the the squared length of a vector $\nonsve_{i}$ may be expressed as % $$\Vert\nonsve_{i}\Vert^{2}=\Vert\Phi(\x_{i})-\origin\Vert^{2}=k(\x_{i},\x_{i})$$ % where $\origin$ denotes the origin of feature space $\mathcal{H}$. \subsection{The Two-Circle Intersection\label{subsection:two_circle_intersection}} Normally, one begins the Gram-Schmidt procedure by projecting one vector onto another. The key to the geometric interpretation of the incomplete cholesky factorisation is to re-express the projection of vector $\nonsve_{2}$ onto basis vector $\sve_{1}:\nonsve_{1}/\ce_{1,1}$ as presented in Equation~\ref{equation:standard_projection} in terms of distances. Figure~\ref{figure:two_circle_intersection} shows two circles on a two-dimensional plane defined by the span of $\sve_{1}$ and $\nonsve_{2}$. % \begin{figure} \begin{center} \includegraphics{two_circle_intersection} \end{center} \caption{The projection of vector $\nonsve_{2}$ on vector $\sve_{1}$, and its associated two-circle intersection problem.% \label{figure:two_circle_intersection}} \end{figure} % The centres of the circles are placed at the origin and the head of $\nonsve_{1}$. They have radii such that they go through the head of vector $\nonsve_{2}$. This means that the left circle has a radius of $\Vert\nonsve_{2}\Vert$ equal to the length of vector $\nonsve_{2}$, and that the right circle has a radius of $d(\nonsve_{1},\nonsve_{2})$. The \emph{lens} of any circle-circle intersection is perpendicular to the line through its centres. In this case this means that the intersection is perpendicular to $\sve_{1}$, thereby fulfilling the necessary property of orthogonality of a projection. The simple equation of a circle is known as $x^{2}+y^{2}=r^{2}$, .... The two-circle intersection problem as shown in Figure~\ref{figure:two_circle_intersection} may be expressed with the following system of equations. \begin{eqnarray*} \ce_{1,2}^{2}+d_{\perp}^{2}(\sv,\nonsve_{2}) & = & \Vert\nonsve_{2}\Vert^{2}\\ (\ce_{1,2}-\ce_{1,1})^{2}+d_{\perp}^{2}(\sv,\nonsve_{2}) & = & d^{2}(\nonsve_{1},\nonsve_{2})\end{eqnarray*} The system of equations consists of two equations with two unknowns, coordinate $\ce_{1,2}$ and perpendicular distance of vector $\nonsve_{2}$ to the basis defined by $\sv$, $d_{\perp}(\sv,\nonsve_{2})$, and they can be solved rather straightforwardly. The solution is given below. \begin{eqnarray*} \ce_{1,2} & = & \frac{\ce_{1,1}^{2}+\Vert\nonsve_{2}\Vert^{2}-d^{2}(\nonsve_{1},\nonsve_{2})}{2\ce_{1,1}}=\frac{\nonsve_{1}^{T}\nonsve_{2}}{\ce_{1,1}}\\ d_{\perp}(\sv,\nonsve_{2}) & = & \sqrt{\Vert\nonsve_{2}\Vert^{2}-\ce_{1,2}^{2}}\end{eqnarray*} the upper equation .. may be simplified to .. Actually, there is a second solution to $d_{\perp}(\sv,\nonsve_{2})$, one having a negative square root. Let us ignore that solution, thereby obeying the axiom of positiveness of distances. The resulting projection of $\nonsve_{2}$ on $\sve_{1}$ in terms of $\sve_{1}$ may be obtained using the solution above, \[ \hat{\nonsve}_{2}=\ce_{1,2}\sve_{1}.\] Remarkably, we have obtained more information than the projection of $\nonsve_{i}$ only: the perpendicular distance $d_{\perp}(\sv,\nonsve_{2})$ of basis $\sv$ to vector $\nonsve_{2}$. We will come back to this issue later on. \begin{eqnarray*} \ce_{2,2} & = & d_{\perp}(\sv,\nonsve_{2})\\ \sve_{2} & = & (\nonsve_{2}-\hat{\nonsve}_{2})/\ce_{2,2}\end{eqnarray*} \subsection{The Three-Sphere Intersection\label{subsection:three_sphere_intersection}} Before discussing the arbitrary-dimensional case, let us first consider a projection of a vector $\nonsve_{i}$ onto a two-dimensional plane. Assume we already have two top-notch orthonormal basis vectors Let the current basis vectors be defined by $\sv=(\sve_{1},\sve_{2})$, .... \begin{eqnarray*} \sve_{1} & : & \nonsve_{1}/\ce_{1,1}\\ \sve_{2} & : & (\nonsve_{2}-\ce_{1,2}\sve_{1})/\ce_{2,2}\end{eqnarray*} Basis vector $\sve_{2}$ is orthogonal to basis vector $\sve_{1}$, possibly determined by a two-circle intersection presented in the preceding subsection. Figure~\ref{figure:three_sphere_intersection} illustrates the problem. It may be solved by the solution to a three-sphere intersection problem. % \begin{figure} \begin{center}\includegraphics{three_sphere_intersection}\end{center} \caption{The projection of $\nonsve_{i}$ on plane $\sv$ may be tackled by a three-sphere intersection problem.\label{figure:three_sphere_intersection}} \end{figure} Let the spheres be situated in a three-dimensional space defined by the span of $\sve_{1}$, $\sve_{2}$ and $\nonsve_{3}$, and let the centre of the first sphere be located at $\origin\in\mathcal{H}$, and that of the other two at the heads of vectors $\nonsve_{1}$ and $\nonsve_{2}$. Let the spheres be scaled in such way that they go through the head of vector $\nonsve_{3}$, having radii $\Vert\nonsve_{3}\Vert$, $d(\nonsve_{1},\nonsve_{3})$ and $d(\nonsve_{2},\nonsve_{3})$. The system of equations of a two-circle intersection problem may be extended to match a three-sphere intersection problem. \begin{eqnarray*} \ce_{1,3}^{2}+\ce_{2,3}^{2}+d_{\perp}^{2}(\sv,\nonsve_{3}) & = & \Vert\nonsve_{3}\Vert^{2}\\ (\ce_{1,3}-\ce_{1,1})^{2}+\ce_{2,3}^{2}+d_{\perp}^{2}(\sv,\nonsve_{3}) & = & d^{2}(\nonsve_{1},\nonsve_{3})\\ (\ce_{1,3}-\ce_{1,2})^{2}+(\ce_{2,3}-\ce_{2,2})^{2}+d_{\perp}^{2}(\sv,\nonsve_{3}) & = & d^{2}(\nonsve_{2},\nonsve_{3})\end{eqnarray*} In this case we have three equations with three unknowns, being $\ce_{1,3}^{2}$, $\ce_{2,3}^{2}$, and $d_{\perp}(\sv,\nonsve_{3})$. Although the solution is less trivial than that for the two-circle intersection problem, it remains rather straightforward. It is given below.\begin{eqnarray*} \ce_{1,3} & = & \frac{\nonsve_{1}^{T}\nonsve_{3}}{\ce_{1,1}}\\ \ce_{2,3} & = & \frac{\nonsve_{2}^{T}\nonsve_{3}-\ce_{1,2}\ce_{1,3}}{\ce_{2,2}}\\ d_{\perp}(\sv,\nonsve_{3}) & = & \sqrt{\Vert\nonsve_{3}\Vert^{2}-\ce_{1,3}^{2}-\ce_{2,3}^{2}}\end{eqnarray*} In comparison to the solution to a two-circle intersection problem, we make the observation that the solution to $\ce_{\nonsve_{i},1}$ has not changed shape. We have deliberately expressed the solution to $d_{\perp}(\sv,\nonsve_{i})$ in terms of $\ce_{1,3}$ and $\ce_{2,3}$ to improve clarity. Finally, the projection of vector $\nonsve_{i}$ on the plane brought forth by $\sv$ is expressed with \[ \hat{\nonsve}_{3}=\ce_{1,3}\sve_{1}+\ce_{2,3}\sve_{2}.\] And one could create a basis vector by simply substituting \begin{eqnarray*} \ce_{3,3} & = & d_{\perp}(\sv,\nonsve_{3})\\ \sve_{3} & = & (\nonsve_{3}-\hat{\nonsve}_{3})/\ce_{3,3}\end{eqnarray*} . \subsection{The $n$-Hypersphere Intersection\label{subsection:hypersphere_intersection}} Let us consider generic case of the projection of a vector $\nonsve_{i}$ on a hyperplane spanned by $\sv$. We are given $(n-1)$ ordered orthogonal basis vectors \begin{eqnarray*} \sve_{1} & : & \nonsve_{1}/\ce_{1,1}\\ \sve_{2} & : & \left(\nonsve_{2}-\ce_{1,2}\sve_{1}\right)/\ce_{2,2}\\ \sve_{3} & : & \left(\nonsve_{3}-\ce_{1,3}\sve_{1}-\ce_{2,3}\sve_{2}\right)/\ce_{3,3}\\ \vdots & & \vdots\\ \sve_{n-1} & : & \left(\nonsve_{n-1}-\sum_{j=1}^{j=n-2}\ce_{j,n-1}\sve_{j}\right)/\ce_{n-1,n-1}\end{eqnarray*} that span the hyperplane in which patterns the origin $\origin\in\mathcal{H}$ and vectors $\sve_{1},\ldots,\sve_{n-1}$ are positioned. Generally, this projection may be determined by an $n$-hypersphere intersection. The generic system of equations is given by \begin{eqnarray*} \ce_{1,n}^{2}+\ce_{2,n}^{2}+\ldots+d_{\perp}^{2}(\sv,\nonsve_{n}) & = & \Vert\nonsve_{i}\Vert^{2}\\ (\ce_{1,n}-\ce_{1,1})^{2}+\ce_{2,n}^{2}+\ldots+d_{\perp}^{2}(\sv,\nonsve_{n}) & = & d^{2}(\nonsve_{1},\nonsve_{n})\\ & \vdots\\ (\ce_{1,n}-\ce_{1,n-1})^{2}+\ldots+(\ce_{n-1,n}-\ce_{n-1,n-1})^{2}+d_{\perp}^{2}(\sv,\nonsve_{n}) & = & d^{2}(\nonsve_{n-1},\nonsve_{n})\end{eqnarray*} for any $n$. We can solve this system of $n$ equations with the following solutions \begin{eqnarray} \ce_{j,n} & = & \frac{\nonsve_{j}^{T}\nonsve_{n}-\sum_{p=1}^{p=j-1}\ce_{p,j}\ce_{p,n}}{\ce_{j,j}}\label{equation:coord_update}\\ d_{\perp}(\sv,\nonsve_{n}) & = & \sqrt{\Vert\nonsve_{n}\Vert^{2}-\sum_{j=1}^{j=n-1}\ce_{j,n}^{2}}\label{equation:perp_distance}\end{eqnarray} The way the solution is written down, requires that the computations need to be executed consecutively in the order of the basis vectors, i.e., $\ce_{\nonsve_{i},j-1}$ needs to be computed before $\ce_{\nonsve_{i},j}$ for each $j>1$. The projection of $\nonsve_{i}$ on the hyperplane defined by basis $\sv$ may be obtained by evaluating\[ \hat{\nonsve}_{i}=\sum_{j=1}^{j=n-1}\ce_{j,i}\sve_{j}.\] \subsection{The Algorithm\label{subsection:max_perp_algorithm}} In this section, we will introduce an orthogonalisation process that utilises the projection operator introduced in the preceding section. This is the pseudo code for the incomplete cholesky factorisation. % \begin{algorithm} \caption{Pseudo code of the incomplete Cholesky factorisation process.}% \label{algorithm:incomplete_cholesky} \begin{algorithmic}\FOR{$i=1:n$} \STATE $c(i)=a_i^T a_i$ \ENDFOR \STATE $k = \mathrm{max~element} \{c(1),\ldots,c(n)\}$ \STATE $\tau=c(k)$; $r=0$ \WHILE{$\tau>0$ \textbf{and} $r Reference

Reference

In C++ nomenclature, a Concept defines a set of requirements for a certain type: they define what types are allowed when substituting template parameters. A template class (or function) may be instantiated with parameters of types that adhere to such a set of requirements. These adhering types are called a Model of a certain Concept.

Contents

kml_src/doc/reference/kernel.tex000644 000765 000024 00000002564 10542537135 017661 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{Kernel} \maketitle \section*{Description} A kernel is an \href{http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html}{Adaptable Binary Function}, %A kernel, in machine-learning momenclature, may be regarded as a \emph{similarity function}. %A kernel is a Binary Function that evaluates on two objects of the same type. \section*{Refinement of} \href{http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html}{Adaptable Binary Function}, \href{http://www.boost.org/doc/html/CopyConstructible.html}{Copy Constructible}, \href{http://www.sgi.com/tech/stl/Assignable.html}{Assignable} \section*{Associated types} \begin{tabular}{lll} Kernel type & \texttt{F::type} & The type of the kernel \\ \end{tabular} \section*{Notation} \begin{tabular}{ll} K & A type that is a model of Kernel \\ k & An object of type K \\ \end{tabular} \section*{Definitions} \section*{Valid Expressions} \section*{Expression Semantics} \section*{Complexity Guarantees} \section*{Invariants} \section*{Models} \begin{itemize} \item \href{\kmlroot/reference/sigmoid.html}{sigmoid} \end{itemize} \section*{Notes} \section*{See also} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/krls.tex000644 000765 000024 00000001175 10544757330 017354 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{krls} \maketitle \section*{Description} \texttt{Krls} implements the Kernel Recursive Least Squares method \cite{engel03kernel}. \section*{Example} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/krls.hpp}{kml/krls.hpp}. \section*{Template Parameters} \section*{Model of} \section*{Type requirements} \section*{Public Base Classes} \section*{Members} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/linear.tex000644 000765 000024 00000004022 10546743152 017644 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \newcommand{\half}{\tfrac{1}{2}} \begin{document} \title{linear} \maketitle \section*{Description} \texttt{Linear} is a Kernel. Specifically, it is a \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}. When using a linear kernel, input space $\mathcal{X}$ is identical to feature space $\mathcal{H}$. If k is an object of class \texttt{linear}, and u and v are objects of class T, then k(u,v) returns the inner product % \[k(u,v) = u^T v\] % which is defined to be the product if T is a scalar type. \section*{Example} \highlightcpp{} \begin{verbatim} vector< double > u(10); vector< double > v(10); linear< vector< double > > kernel; cout << kernel( u, v ) << endl; \end{verbatim} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/linear.hpp}{kml/linear.hpp}. \section*{Template Parameters} \begin{tabular}{lll} \textbf{Parameter} & \textbf{Description} & \textbf{Default} \\ \hline T & The linear argument type \\ \end{tabular} \section*{Model of} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}, Default Constructible, Copy Constructible \section*{Type requirements} T must be a vector type or a numeric type; distance_squared should evaluate. \section*{Members} \begin{tabular}{lll} \textbf{Member} & \textbf{Where defined} & \textbf{Description} \\ \hline \texttt{linear()} & \href{http://www.sgi.com/tech/stl/DefaultConstructible.html}{Default Constructible} & The default constructor \\ \texttt{result_type} & Input value & The type of the result: \texttt{input_value} \\ \end{tabular} \section*{Notes} \section*{See also} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}, \href{\kmlroot/reference/gaussian.html}{gaussian}, \href{\kmlroot/reference/hermitian.html}{hermitian}, \href{\kmlroot/reference/polynomial.html}{polynomial}, \href{\kmlroot/reference/sigmoid.html}{sigmoid} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/mercer_kernel.tex000644 000765 000024 00000004073 10546743152 021215 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{Mercel Kernel} \maketitle \section*{Description} A Mercer Kernel is a \href{\kmlroot/reference/kernel.html}{Kernel} that is positive semi-definite. When a kernel is positive semi-definite, one may exploit the \emph{kernel trick} \cite{aizerman64theoretical}, the idea of mapping data to a high-dimensional feature space where some linear algorithm is applied that works exclusively with inner products. Assume we have some mapping $\Phi$ from an input space $\mathcal{X}$ to a feature space $\mathcal{H}$, then a kernel function (or kernel) % \[ k(u,v)=\left\langle \Phi( u ), \Phi( v ) \right\rangle \] % may be used to define the inner product in feature space $\mathcal{H}$. Figure~\ref{figure:feature_space} shows that the application of a linear algorithm in feature space $\mathcal{H}$ could correspond to a nonlinear estimate in input space $\mathcal{X}$. \begin{figure} \includegraphics{feature_space} \caption{A mapping $\Phi$ from input space $\mathcal{X}$ to feature space $\mathcal{H}$.} \label{figure:feature_space} \end{figure} Positive definiteness in the context of kernel functions also implies that a kernel matrix created using a particular kernel is positive semi-definite. A matrix is positive semi-definite if its associated eigenvalues $\lambda_1,\lambda_2,\ldots,\lambda_N$ are nonnegative. \section*{Refinement of} \href{\kmlroot/reference/kernel.html}{Kernel} \section*{Associated types} \section*{Notation} \section*{Definitions} \section*{Valid Expressions} \section*{Expression Semantics} \section*{Complexity Guarantees} \section*{Invariants} \section*{Models} \begin{itemize} \item \href{\kmlroot/reference/linear.html}{linear} \item \href{\kmlroot/reference/gaussian.html}{gaussian} \item \href{\kmlroot/reference/hermitian.html}{hermitian} \item \href{\kmlroot/reference/polynomial.html}{polynomial} \end{itemize} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/polynomial.tex000644 000765 000024 00000004012 10546743152 020554 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \newcommand{\half}{\tfrac{1}{2}} \begin{document} \title{polynomial} \maketitle \section*{Description} \texttt{polynomial} is a Kernel. Specifically, it is a \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}. If k is an object of class \texttt{polynomial}, and u and v are objects of class T, then k(u,v) returns % \[ k(u,v) = (\gamma u^T v + \lambda)^d \] % where $\gamma$ is the scale of the used inner product, $\lambda$ the bias of the used inner product, and $d$ the order of the polynomial kernel. \section*{Example} \highlightcpp{} \begin{verbatim} vector< double > u(10); vector< double > v(10); polynomial< vector< double > > kernel(1.0,0.0,3.0); cout << kernel( u, v ) << endl; \end{verbatim} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/polynomial.hpp}{kml/polynomial.hpp}. \section*{Template Parameters} \begin{tabular}{lll} \textbf{Parameter} & \textbf{Description} & \textbf{Default} \\ \hline T & The polynomial argument type \\ \end{tabular} \section*{Model of} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}, Default Constructible, Copy Constructible \section*{Type requirements} T must be a vector type or a numeric type; linear should evaluate. \section*{Members} \begin{tabular}{lll} \textbf{Member} & \textbf{Where defined} & \textbf{Description} \\ \hline \texttt{polynomial()} & \href{http://www.sgi.com/tech/stl/DefaultConstructible.html}{Default Constructible} & The default constructor \\ \texttt{result_type} & Input value & The type of the result: \texttt{input_value} \\ \end{tabular} \section*{Notes} \section*{See also} \href{\kmlroot/reference/mercer_kernel.html}{Mercer Kernel}, \href{\kmlroot/reference/linear.html}{linear}, \href{\kmlroot/reference/gaussian.html}{gaussian}, \href{\kmlroot/reference/hermitian.html}{hermitian}, \href{\kmlroot/reference/sigmoid.html}{sigmoid} \bibliographystyle{unsrt} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/proto_class.tex000644 000765 000024 00000000715 10544757517 020737 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{class} \maketitle \section*{Description} \section*{Example} \section*{Definition} \section*{Template Parameters} \section*{Model of} \section*{Type requirements} \section*{Public Base Classes} \section*{Members} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/proto_concept.tex000644 000765 000024 00000001012 10544757517 021254 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{My Concept} \maketitle \section*{Description} \section*{Refinement of} \section*{Associated types} \section*{Notation} \section*{Definitions} \section*{Valid Expressions} \section*{Expression Semantics} \section*{Complexity Guarantees} \section*{Invariants} \section*{Models} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/ranking.tex000644 000765 000024 00000001132 10544755446 020031 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \begin{document} \title{ranking} \maketitle \section*{Description} \section*{Example} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/ranking.hpp}{kml/ranking.hpp}. \section*{Template Parameters} \section*{Model of} \section*{Type requirements} \section*{Members} \section*{Notes} \section*{See also} \href{\kmlroot/reference/classification.html}{classification}, \href{\kmlroot/reference/regression.html}{regression} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/regression.tex000644 000765 000024 00000002011 10544755446 020555 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{regression} \maketitle \section*{Description} Generally, a regression problem is to find a relation between variables. In machine learning, it is considered a supervised learning problem, where we learn from instances from a data set $\mathcal{D}=\{ (x_1,y_1), (x_2,y_2), \ldots, (x_n, y_n ) \}$ containing input-output pairs $(x_i,y_i)\in \mathcal{X}\times \mathbb{R}$. \begin{figure} \includegraphics{regression_problem} \end{figure} \section*{Example} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/regression.hpp}{kml/regression.hpp}. \section*{Template Parameters} \section*{Model of} \section*{Type requirements} \section*{Members} \section*{Notes} \section*{See also} \href{\kmlroot/reference/classification.html}{classification}, \href{\kmlroot/reference/ranking.html}{ranking} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/regression_problem.fig000644 000765 000024 00000003572 10544756667 022265 0ustar00pawelmstaff000000 000000 #FIG 3.2 Produced by xfig version 3.2.5-alpha5 Landscape Center Metric A4 100.00 Single -2 1200 2 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2475 1485 23 23 2475 1485 2498 1485 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2115 1710 23 23 2115 1710 2138 1710 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2385 1755 23 23 2385 1755 2408 1755 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2385 1575 23 23 2385 1575 2408 1575 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2700 1845 23 23 2700 1845 2723 1845 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2745 1710 23 23 2745 1710 2768 1710 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2970 1935 23 23 2970 1935 2993 1935 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3060 1755 23 23 3060 1755 3083 1755 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3330 1800 23 23 3330 1800 3353 1800 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3150 1575 23 23 3150 1575 3173 1575 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3510 1485 23 23 3510 1485 3533 1485 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3510 1350 23 23 3510 1350 3533 1350 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3780 1305 23 23 3780 1305 3803 1305 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 4230 1440 23 23 4230 1440 4253 1440 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 4320 1215 23 23 4320 1215 4343 1215 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 4140 1260 23 23 4140 1260 4163 1260 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3915 1485 23 23 3915 1485 3938 1485 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3960 1125 23 23 3960 1125 3983 1125 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 4455 1485 23 23 4455 1485 4478 1485 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 3735 1665 23 23 3735 1665 3758 1665 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 4095 675 23 23 4095 675 4118 675 1 3 0 1 4 4 50 -1 20 0.000 1 0.0000 2025 1395 23 23 2025 1395 2048 1395 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 2250 2700 2250 630 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 2160 2610 4590 2610 3 2 0 2 1 7 50 -1 -1 0.000 0 0 0 4 1980 1440 2970 1800 3960 1260 4455 1305 0.000 -1.000 -1.000 0.000 kml_src/doc/reference/rvm.tex000644 000765 000024 00000001374 10546743152 017205 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{rvm} \maketitle \section*{Description} \texttt{Rvm} implements the Relevance Vector Machine \cite{tipping00relevance,tipping01sparse} using a fast algorithm \cite{tipping03fast} that is based on an analysis of the marginal likelihood \cite{faul02analysis}. \section*{Example} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/rvm.hpp}{kml/rvm.hpp}. \section*{Template Parameters} \section*{Model of} \section*{Type requirements} \section*{Public Base Classes} \section*{Members} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/SConscript000644 000765 000024 00000001531 10553622243 017657 0ustar00pawelmstaff000000 000000 Import('env') Import('install_dir') obj = [] # index page obj += env.XHTML( 'index.html_fase4' ) # kernel concepts obj += env.HTML( 'kernel.tex' ) obj += env.HTML( 'mercer_kernel.tex' ) # kernels obj += env.HTML( 'linear.tex' ) obj += env.HTML( 'gaussian.tex' ) obj += env.HTML( 'hermitian.tex' ) obj += env.HTML( 'polynomial.tex' ) obj += env.HTML( 'sigmoid.tex' ) # learning concepts obj += env.HTML( 'supervised_learning.tex' ) # supervised learning problems obj += env.HTML( 'classification.tex' ) obj += env.HTML( 'ranking.tex' ) obj += env.HTML( 'regression.tex' ) # kernel machines obj += env.HTML( 'svm.tex' ) obj += env.HTML( 'rvm.tex' ) obj += env.HTML( 'krls.tex' ) obj += env.HTML( 'figueiredo.tex' ) # misc / not yet classified obj += env.HTML( 'incomplete_cholesky.tex' ) obj += env.PDF( 'incomplete_cholesky.tex' ) Return( 'obj' ) kml_src/doc/reference/sigmoid.tex000644 000765 000024 00000003521 10546743152 020030 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{sigmoid} \maketitle \section*{Description} \texttt{Sigmoid} is a \href{\kmlroot/reference/kernel.html}{Kernel}. If k is an object of class \texttt{sigmoid}, and u and v are objects of class T, then k(u,v) returns % \[k(u,v) = \tanh( \gamma u^T v + \lambda)\] % where $\gamma$ is the scale of the used inner product, $\lambda$ the bias of the used inner product. \section*{Example} \highlightcpp{} \begin{verbatim} vector< double > u(10); vector< double > v(10); sigmoid< vector< double > > kernel(1.0,0.1); cout << kernel( u, v ) << endl; \end{verbatim} \section*{Definition} Defined in the KML header \href{\kmlsvnroot/kml/sigmoid.hpp}{kml/sigmoid.hpp}. \section*{Template Parameters} \begin{tabular}{lll} \textbf{Parameter} & \textbf{Description} & \textbf{Default} \\ \hline T & The sigmoid argument type \\ \end{tabular} \section*{Model of} \href{\kmlroot/reference/kernel.html}{Kernel} \section*{Type requirements} T must be a vector type or a numeric type; linear should evaluate. \section*{Members} \begin{tabular}{lll} \textbf{Member} & \textbf{Where defined} & \textbf{Description} \\ \hline \texttt{sigmoid()} & \href{http://www.sgi.com/tech/stl/DefaultConstructible.html}{Default Constructible} & The default constructor \\ \texttt{result_type} & Input value & The type of the result: \texttt{input_value} \\ \end{tabular} \section*{Notes} \section*{See also} \href{\kmlroot/reference/kernel.html}{Kernel}, \href{\kmlroot/reference/linear.html}{linear}, \href{\kmlroot/reference/gaussian.html}{gaussian}, \href{\kmlroot/reference/hermitian.html}{hermitian}, \href{\kmlroot/reference/polynomial.html}{polynomial} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/supervised_learning.tex000644 000765 000024 00000001325 10544755446 022454 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{Supervised Learning} \maketitle \section*{Description} \section*{Refinement of} \section*{Associated types} \section*{Definitions} \section*{Valid Expressions} \section*{Expression Semantics} \section*{Complexity Guarantees} \section*{Invariants} \section*{Models} \begin{itemize} \item \href{\kmlroot/reference/regression.html}{regression} \item \href{\kmlroot/reference/classification.html}{classification} \item \href{\kmlroot/reference/ranking.html}{ranking} \end{itemize} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/svm.tex000644 000765 000024 00000002257 10553622243 017202 0ustar00pawelmstaff000000 000000 \documentclass{article} \input{myinclude} \usepackage[numbers]{natbib} \begin{document} \title{svm} \maketitle \section*{Description} \texttt{svm} implements the Support Vector Machine. A number of implementations is available \cite{cauwenberghs00incremental,platt99fast,engel02sparse,ma03accurate}. At the moment we have different classes for batch and on-line operation, our goal is to merge them to one class that automatically deploys the most suited algorithm. \subsection*{Classification} In case of \href{\kmlroot/reference/classification.html}{Classification}, support vector machines maximise the \emph{margin} of a class-separating hyperplane. \section*{Example} \section*{Definition} SMO is defined in the KML header \href{\kmlsvnroot/kml/svm.hpp}{kml/svm.hpp}. \noindent AOSVM and AOSVR are defined in the KML header \href{\kmlsvnroot/kml/online_svm.hpp}{kml/online_svm.hpp}. \section*{Template Parameters} \section*{Model of} \section*{Type requirements} \section*{Public Base Classes} \section*{Members} \section*{Notes} \section*{See also} \bibliographystyle{unsrtnat} \bibliography{/home/rutger/documents/bibliography/references} \end{document} kml_src/doc/reference/three_sphere_intersection.fig000644 000765 000024 00000004073 10542537135 023606 0ustar00pawelmstaff000000 000000 #FIG 3.2 Produced by xfig version 3.2.5-alpha5 Landscape Center Metric Letter 100.00 Single -2 1200 2 5 1 0 1 0 7 50 -1 -1 0.000 0 1 1 0 2617.984 1861.694 2475 765 2160 855 1755 1170 1 1 1.00 45.00 90.00 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 1710 720 29 29 1710 720 1739 720 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 810 1350 29 29 810 1350 839 1350 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 2535 1530 29 29 2535 1530 2565 1530 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 1710 1710 29 29 1710 1710 1740 1710 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 1170 2205 29 29 1170 2205 1200 2205 2 1 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 2 810 1350 2565 1530 2 1 2 1 0 7 50 -1 -1 4.000 0 0 -1 0 0 2 810 1350 1710 720 2 3 0 1 0 -1 51 -1 1 0.000 0 0 -1 0 0 5 -135 1080 675 2700 3960 2700 3150 1080 -135 1080 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1170 2205 1710 720 2 1 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 2 2565 1530 1710 720 2 1 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 2 1710 720 1710 1710 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 3 1710 1620 1575 1620 1575 1710 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 3 990 1530 1035 1620 925 1620 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1170 2205 2565 1530 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 888 1530 1620 1530 2 1 2 1 0 7 51 -1 -1 3.000 0 0 -1 0 0 2 1485 1530 2520 1530 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1164 2208 804 1353 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1170 2205 944 1680 4 1 0 50 -1 0 10 0.0000 2 150 570 1170 2430 $\\origin$\001 4 2 0 50 -1 0 10 0.0000 2 165 765 1485 1215 $\\nonsve_3$\001 4 0 0 50 -1 0 10 0.0000 2 165 1125 1800 1755 $\\hat{\\nonsve}_3$\001 4 2 0 50 -1 0 10 0.0000 2 165 1875 3555 2520 $\\sv$: Span$\\{\\sve_1,\\sve_2\\}$\001 4 0 0 50 -1 0 10 0.0000 2 165 1575 2565 810 $d_\\perp(\\sv,\\nonsve_3)$\001 4 0 0 50 -1 0 10 0.0000 2 165 765 1935 1980 $\\nonsve_2$\001 4 0 0 50 -1 0 10 0.0000 2 165 540 1125 1665 $\\sve_2$\001 4 2 0 50 -1 0 10 0.0000 2 165 540 990 2025 $\\sve_1$\001 4 2 0 50 -1 0 10 0.0000 2 165 765 810 1620 $\\nonsve_1$\001 kml_src/doc/reference/two_circle_intersection.fig000644 000765 000024 00000003241 10542537135 023257 0ustar00pawelmstaff000000 000000 #FIG 3.2 Produced by xfig version 3.2.5-alpha5 Landscape Center Inches Letter 100.00 Single -2 1200 2 5 1 0 1 0 7 50 -1 -1 0.000 0 1 1 0 2662.500 1687.500 2475 750 2250 825 2025 975 1 1 1.00 45.00 90.00 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 1200 1650 35 35 1200 1650 1235 1655 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 1950 600 35 35 1950 600 1985 605 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 3075 1650 35 35 3075 1650 3110 1655 1 3 1 1 0 7 52 -1 -1 4.000 1 0.0000 3094 1655 1556 1556 3094 1655 4650 1655 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 1950 1650 35 35 1950 1650 1985 1655 1 3 1 1 0 7 52 -1 -1 4.000 1 0.0000 1205 1651 1290 1290 1205 1651 2495 1651 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1200 1650 1950 600 2 1 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 2 1950 600 1950 1650 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 3 1875 1500 1875 1575 1800 1575 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 3 2025 1500 2025 1575 2100 1575 2 1 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 2 1950 600 3075 1650 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1200 1650 3075 1650 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 60.00 120.00 1200 1650 2400 1650 4 0 0 50 -1 0 10 0.0000 2 165 1620 2700 1200 $d(\\nonsve_1,\\nonsve_2)$\001 4 2 0 50 -1 0 10 0.0000 2 150 570 1050 1725 $\\origin$\001 4 2 0 49 -1 0 10 0.0000 2 165 1455 1425 1200 $\\Vert\\nonsve_2\\Vert$\001 4 1 0 50 -1 0 10 0.0000 2 165 765 1950 375 $\\nonsve_2$\001 4 0 0 50 -1 0 10 0.0000 2 165 765 3225 1725 $\\nonsve_1$\001 4 1 0 50 -1 0 10 0.0000 2 165 1125 1950 1875 $\\hat{\\nonsve}_2$\001 4 0 0 50 -1 0 10 0.0000 2 165 1575 2550 750 $d_\\perp(\\sv,\\nonsve_2)$\001 4 1 0 50 -1 0 10 0.0000 2 165 540 2325 1875 $\\sve_1$\001 kml_src/boost/numeric/000755 000765 000024 00000000000 11676172345 015744 5ustar00pawelmstaff000000 000000 kml_src/boost/serialization/000755 000765 000024 00000000000 11676172345 017157 5ustar00pawelmstaff000000 000000 kml_src/boost/serialization/complex.hpp000644 000765 000024 00000002410 10405260742 021320 0ustar00pawelmstaff000000 000000 #ifndef BOOST_SERIALIZATION_COMPLEX_HPP #define BOOST_SERIALIZATION_COMPLEX_HPP // copyright Neal Becker, presumed to be under the Boost license // temporary include file for ublas vector type // acquired from the boost.devel mailing list // is included here until it is in boost #include #include #include #include template struct implementation_level > { typedef mpl::integral_c_tag tag; // typedef mpl::int_ type; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = implementation_level::type::value ); }; template struct tracking_level > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; template inline void serialize (Archive &ar, std::complex& z, const unsigned int file_version) { ar & boost::serialization::make_nvp ("real", real(z)); ar & boost::serialization::make_nvp ("imag", imag(z)); // ar & real(z); // ar & imag(z); } } #endif kml_src/boost/serialization/ublas_matrix.hpp000644 000765 000024 00000004553 10405260742 022355 0ustar00pawelmstaff000000 000000 #ifndef BOOST_SERIALIZATION_UBLAS_MATRIX_HPP #define BOOST_SERIALIZATION_UBLAS_MATRIX_HPP // copyright Rutger ter Borg, to be under the Boost license // // temporary include file for ublas vector type // acquired from the boost.devel mailing list // is included here until it is in boost #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace boost { namespace serialization { template struct tracking_level > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; template struct implementation_level > { typedef mpl::integral_c_tag tag; // typedef mpl::int_ type; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = implementation_level::type::value ); }; template inline void save (Archive &ar, const ublas::matrix &m, const unsigned int) { unsigned int count1 = m.size1(); unsigned int count2 = m.size2(); ar << BOOST_SERIALIZATION_NVP (count1); ar << BOOST_SERIALIZATION_NVP (count2); for ( unsigned int row = 0; row < count1; ++row ) { for( unsigned int col = 0; col < count2; ++col ) { ar << boost::serialization::make_nvp ("item", m(row,col) ); } } } template inline void load (Archive &ar, ublas::matrix &m, const unsigned int) { unsigned int count1; unsigned int count2; ar >> BOOST_SERIALIZATION_NVP (count1); ar >> BOOST_SERIALIZATION_NVP (count2); m.resize( count1, count2 ); for ( unsigned int row = 0; row < count1; ++row ) { for( unsigned int col = 0; col < count2; ++col ) { ar >> boost::serialization::make_nvp ("item", m(row,col) ); } } } template inline void serialize (Archive &ar, ublas::matrix& m, const unsigned int file_version) { boost::serialization::split_free (ar, m, file_version); } } //namespace serialization } // namespace boost #endif // BOOST_SERIALIZATION_UBLAS_MATRIX_HPP kml_src/boost/serialization/ublas_vector.hpp000644 000765 000024 00000004061 10405260742 022345 0ustar00pawelmstaff000000 000000 #ifndef BOOST_SERIALIZATION_UBLAS_VECTOR_HPP #define BOOST_SERIALIZATION_UBLAS_VECTOR_HPP // copyright Neal Becker, presumed to be under the Boost license // temporary include file for ublas vector type // acquired from the boost.devel mailing list // is included here until it is in boost #include #include #include #include #include namespace ublas = boost::numeric::ublas; namespace boost { namespace serialization { template struct tracking_level > { typedef mpl::integral_c_tag tag; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; template struct implementation_level > { typedef mpl::integral_c_tag tag; // typedef mpl::int_ type; typedef mpl::int_ type; BOOST_STATIC_CONSTANT( int, value = implementation_level::type::value ); }; template inline void save (Archive &ar, const ublas::vector &v, const unsigned int) { unsigned int count = v.size(); ar << BOOST_SERIALIZATION_NVP (count); typename ublas::vector::const_iterator it = v.begin(); while (count-- > 0) { ar << boost::serialization::make_nvp ("item", *it++); } } template inline void load (Archive &ar, ublas::vector &v, const unsigned int) { unsigned int count; ar >> BOOST_SERIALIZATION_NVP (count); v.resize (count); typename ublas::vector::iterator it = v.begin(); while (count-- > 0) { ar >> boost::serialization::make_nvp ("item", *it++); } } template inline void serialize (Archive &ar, ublas::vector& v, const unsigned int file_version) { boost::serialization::split_free (ar, v, file_version); } } // namespace serialization } // namespace boost #endif kml_src/boost/numeric/bindings/000755 000765 000024 00000000000 11676172345 017541 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/amos/000755 000765 000024 00000000000 11676172345 020500 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/atlas/000755 000765 000024 00000000000 11676172345 020645 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/blas/000755 000765 000024 00000000000 11676172345 020462 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/lapack/000755 000765 000024 00000000000 11676172345 020774 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/traits/000755 000765 000024 00000000000 11676172345 021047 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/umfpack/000755 000765 000024 00000000000 11676172345 021167 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/umfpack/umfpack.hpp000644 000765 000024 00000114750 10265665640 023334 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * 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 namespace boost { namespace numeric { namespace bindings { namespace umfpack { template struct symbolic_type : private noncopyable { void *ptr; ~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() { 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 (traits::compressed_t, MatrA const& A, void **Symbolic, double const* Control = 0, double* Info = 0) { return detail::symbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic, Control, Info); } template inline int symbolic (traits::compressed_t, MatrA const& A, QVec const& Qinit, void **Symbolic, double const* Control = 0, double* Info = 0) { return detail::qsymbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), traits::vector_storage (Qinit), Symbolic, Control, Info); } template inline int symbolic (traits::coordinate_t, MatrA const& A, void **Symbolic, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::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(), traits::spmatrix_value_storage (A), Symbolic, Control, Info); } template inline int symbolic (traits::coordinate_t, MatrA const& A, QVec const& Qinit, void **Symbolic, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::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(), traits::spmatrix_value_storage (A), traits::vector_storage (Qinit), Symbolic, Control, Info); } } // detail template inline int symbolic (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::symbolic (storage_f(), A, &Symbolic.ptr, Control, Info); } template inline int symbolic (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return symbolic (A, Symbolic, Control.ptr, Info.ptr); } template inline int symbolic (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return symbolic (A, Symbolic, Control.ptr); } template inline int symbolic (MatrA const& A, QVec const& Qinit, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif assert (traits::spmatrix_size2 (A) == traits::vector_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 traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return symbolic (A, Qinit, Symbolic, Control.ptr, Info.ptr); } template inline int symbolic (MatrA const& A, QVec const& Qinit, symbolic_type< typename traits::sparse_matrix_traits::value_type >& Symbolic, control_type< typename traits::sparse_matrix_traits::value_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 (traits::compressed_t, MatrA const& A, void *Symbolic, void** Numeric, double const* Control = 0, double* Info = 0) { return detail::numeric (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic, Numeric, Control, Info); } template inline int numeric (traits::coordinate_t, MatrA const& A, void *Symbolic, void** Numeric, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::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(), traits::spmatrix_value_storage (A), Symbolic, Numeric, Control, Info); } } // detail template inline int numeric (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type > const& Symbolic, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::numeric (storage_f(), A, Symbolic.ptr, &Numeric.ptr, Control, Info); } template inline int numeric (MatrA const& A, symbolic_type< typename traits::sparse_matrix_traits::value_type > const& Symbolic, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_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 traits::sparse_matrix_traits::value_type > const& Symbolic, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { return umfpack::numeric (A, Symbolic, Numeric, Control.ptr); } // factor /* * symbolic and numeric */ namespace detail { template inline int factor (traits::compressed_t, MatrA const& A, void** Numeric, double const* Control = 0, double* Info = 0) { symbolic_type::value_type> Symbolic; int status; status = detail::symbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::numeric (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic.ptr, Numeric, Control, Info); } template inline int factor (traits::coordinate_t, MatrA const& A, void** Numeric, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::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::value_type> Symbolic; status = detail::symbolic (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::numeric (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), Symbolic.ptr, Numeric, Control, Info); } } // detail template inline int factor (MatrA const& A, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::factor (storage_f(), A, &Numeric.ptr, Control, Info); } template inline int factor (MatrA const& A, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_type >& Info) { return factor (A, Numeric, Control.ptr, Info.ptr); } template inline int factor (MatrA const& A, numeric_type< typename traits::sparse_matrix_traits::value_type >& Numeric, control_type< typename traits::sparse_matrix_traits::value_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 (traits::compressed_t, int sys, MatrA const& A, VecX& X, VecB const& B, void *Numeric, double const* Control = 0, double* Info = 0) { return detail::solve (sys, traits::spmatrix_size1 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (B), Numeric, Control, Info); } template inline int solve (traits::coordinate_t, int sys, MatrA const& A, VecX& X, VecB const& B, void *Numeric, double const* Control = 0, double* Info = 0) { int n = traits::spmatrix_size1 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::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(), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (B), Numeric, Control, Info); } } // detail template inline int solve (int sys, MatrA const& A, VecX& X, VecB const& B, numeric_type< typename traits::sparse_matrix_traits::value_type > const& Numeric, double const* Control = 0, double* Info = 0) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif assert (traits::spmatrix_size1 (A) == traits::spmatrix_size1 (A)); assert (traits::spmatrix_size2 (A) == traits::vector_size (X)); assert (traits::spmatrix_size2 (A) == traits::vector_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 traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_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 traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_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 traits::sparse_matrix_traits::value_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 traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_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 traits::sparse_matrix_traits::value_type > const& Numeric, control_type< typename traits::sparse_matrix_traits::value_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 (traits::compressed_t, MatrA const& A, VecX& X, VecB const& B, double const* Control = 0, double* Info = 0) { symbolic_type::value_type> Symbolic; numeric_type::value_type> Numeric; int status; status = detail::symbolic (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; status = detail::numeric (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Symbolic.ptr, &Numeric.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::solve (UMFPACK_A, traits::spmatrix_size1 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (B), Numeric.ptr, Control, Info); } template inline int umf_solve (traits::coordinate_t, MatrA const& A, VecX& X, VecB const& B, double const* Control = 0, double* Info = 0) { int n_row = traits::spmatrix_size1 (A); int n_col = traits::spmatrix_size2 (A); int nnz = traits::spmatrix_num_nonzeros (A); typedef typename traits::sparse_matrix_traits::value_type val_t; int const* Ti = traits::spmatrix_index2_storage (A); int const* Tj = traits::spmatrix_index1_storage (A); traits::detail::array Ap (n_col+1); if (!Ap.valid()) return UMFPACK_ERROR_out_of_memory; traits::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::value_type> Symbolic; numeric_type::value_type> Numeric; status = detail::symbolic (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), &Symbolic.ptr, Control, Info); if (status != UMFPACK_OK) return status; status = detail::numeric (n_row, n_col, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), Symbolic.ptr, &Numeric.ptr, Control, Info); if (status != UMFPACK_OK) return status; return detail::solve (UMFPACK_A, n_row, Ap.storage(), Ai.storage(), traits::spmatrix_value_storage (A), traits::vector_storage (X), traits::vector_storage (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) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif assert (traits::spmatrix_size1 (A) == traits::spmatrix_size1 (A)); assert (traits::spmatrix_size2 (A) == traits::vector_size (X)); assert (traits::spmatrix_size2 (A) == traits::vector_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 traits::sparse_matrix_traits::value_type > const& Control, info_type< typename traits::sparse_matrix_traits::value_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 traits::sparse_matrix_traits::value_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 traits::vector_traits::value_type > const& Numeric) { return detail::scale (traits::vector_size (B), traits::vector_storage (X), traits::vector_storage (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 (traits::compressed_t, MatrA const& A, double const* Control) { return detail::report_matrix (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), 1, Control); } template inline int report_matrix (traits::coordinate_t, MatrA const& A, double const* Control) { return detail::report_triplet (traits::spmatrix_size1 (A), traits::spmatrix_size2 (A), traits::spmatrix_num_nonzeros (A), traits::spmatrix_index1_storage (A), traits::spmatrix_index2_storage (A), traits::spmatrix_value_storage (A), Control); } } // detail template inline int report_matrix (MatrA const& A, control_type< typename traits::sparse_matrix_traits::value_type > const& Control) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::sparse_matrix_traits::ordering_type, traits::column_major_t >::value)); BOOST_STATIC_ASSERT(traits::sparse_matrix_traits::index_base == 0); #endif typedef typename traits::sparse_matrix_traits::storage_format storage_f; #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::value )); #endif return detail::report_matrix (storage_f(), A, Control.ptr); } // report vector template inline int report_vector (VecX const& X, control_type< typename traits::vector_traits::value_type > const& Control) { return detail::report_vector (traits::vector_size (X), traits::vector_storage (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) { return detail::report_perm (T(), 0, traits::vector_storage (Perm), Control.ptr); } }}}} #endif // BOOST_NUMERIC_BINDINGS_UMFPACK_HPP kml_src/boost/numeric/bindings/umfpack/umfpack_inc.hpp000644 000765 000024 00000004066 10265665640 024163 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * 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 kml_src/boost/numeric/bindings/umfpack/umfpack_overloads.hpp000644 000765 000024 00000037403 10265665640 025411 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * 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]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Axi (nnz); if (!Axi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (Ax, Ax+nnz, Axr.storage(), Axi.storage()); traits::detail::array Br (n); if (!Br.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Bi (n); if (!Bi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (B, B+n, Br.storage(), Bi.storage()); traits::detail::array Xr (n); if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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) { traits::detail::array ATxr (nz); if (!ATxr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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) { traits::detail::array AAxr (nz); if (!AAxr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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) { traits::detail::array Br (n); if (!Br.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::array Bi (n); if (!Bi.valid()) return UMFPACK_ERROR_out_of_memory; traits::detail::disentangle (B, B+n, Br.storage(), Bi.storage()); traits::detail::array Xr (n); if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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]; traits::detail::array Axr (nnz); if (!Axr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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) 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); } 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) { traits::detail::array Txr (nz); if (!Txr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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 int report_vector (int n, double const* X, double const* Control) { return umfpack_di_report_vector (n, X, Control); } int report_vector (int n, traits::complex_d const* X, double const* Control) { #if 0 // see UMFPACK v 4.1 User Guide traits::detail::array Xr (n); if (!Xr.valid()) return UMFPACK_ERROR_out_of_memory; traits::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 kml_src/boost/numeric/bindings/traits/algorithm.hpp000644 000765 000024 00000001675 10265665640 023555 0ustar00pawelmstaff000000 000000 #ifndef boost_numeric_bindings_traits_algorithm_hpp #define boost_numeric_bindings_traits_algorithm_hpp #include namespace boost { namespace numeric { namespace bindings { namespace traits { /// /// To be used instead of operator== for numeric types /// Implemented as functor instead of free function because of specialisation /// rationale: operator== on builtin types can not be overloaded. template < typename T > struct is_equal { is_equal(typename type_traits< T >::real_type tolerance) : tolerance_( tolerance ) {} bool operator()(const T& a, const T& b) { return std::abs( a - b ) < tolerance_ ; } // bool operator()(const T& a, const T& b, typename value_traits< T >::value_type tolerance) // { return std::abs( a - b ) < tolerance ; } typename type_traits< T >::real_type tolerance_ ; } ; }}}} #endif // boost_numeric_bindings_traits_algorithm_hpp kml_src/boost/numeric/bindings/traits/boost_array.hpp000644 000765 000024 00000001643 10265665640 024106 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_BOOST_ARRAY_H #define BOOST_NUMERIC_BINDINGS_TRAITS_BOOST_ARRAY_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #else #error with your compiler boost::array<> cannot be used in bindings #endif #endif kml_src/boost/numeric/bindings/traits/c_array.hpp000644 000765 000024 00000003316 10265665640 023201 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_C_ARRAY_H #define BOOST_NUMERIC_BINDINGS_TRAITS_C_ARRAY_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { // built-in array template struct vector_detail_traits { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same::type>::value) ); #endif typedef T identifier_type [N]; // C++ syntax is amazing ;o) typedef V vector_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (vector_type& v) { return v; } static int size (vector_type&) { return N; } static int stride (vector_type&) { return 1; } }; }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler plain C array cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_C_ARRAY_H kml_src/boost/numeric/bindings/traits/config.hpp000644 000765 000024 00000002420 10265665640 023021 0ustar00pawelmstaff000000 000000 // // Copyright (c) 2002-2003 // Toon Knapen, Kresimir Fresl, Joerg Walter // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_CONFIG_HPP #define BOOST_NUMERIC_BINDINGS_CONFIG_HPP #include // Microsoft Visual C++ #if defined (BOOST_MSVC) // .. version 6.0 & 7.0 # if BOOST_MSVC <= 1300 # define BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS # endif #elif defined(__ICC) #elif defined(__IBMCPP__) #elif defined(__GNUC__) #elif defined(__COMO__) #elif defined(__KCC) #elif defined(__sgi) #else #error bindings do not recognise compiler #endif #if defined (BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS) // structure checks require proper traits # define BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK // type checks require proper traits # define BOOST_NUMERIC_BINDINGS_NO_TYPE_CHECK #endif #endif kml_src/boost/numeric/bindings/traits/detail/000755 000765 000024 00000000000 11676172345 022311 5ustar00pawelmstaff000000 000000 kml_src/boost/numeric/bindings/traits/fortran.h000644 000765 000024 00000002262 10265665640 022673 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright (C) 2002, 2003 Si-Lab b.v.b.a., Toon Knapen and Kresimir Fresl #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_FORTRAN_H #define BOOST_NUMERIC_BINDINGS_TRAITS_FORTRAN_H // First we need to know what the conventions for linking // C with Fortran is on this platform/toolset #if defined(__GNUC__) || defined(__ICC) || defined(__sgi) || defined(__COMO__) || defined(__KCC) #define BIND_FORTRAN_LOWERCASE_UNDERSCORE #elif defined(__IBMCPP__) || defined(_MSC_VER) #define BIND_FORTRAN_LOWERCASE #else #error do not know how to link with fortran for the given platform #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##_ #elif defined(BIND_FORTRAN_LOWERCASE) #define FORTRAN_ID( id ) id #else #error do not know how to bind to fortran calling convention #endif #endif // BOOST_NUMERIC_BINDINGS_TRAITS_FORTRAN_H kml_src/boost/numeric/bindings/traits/matrix_raw.hpp000644 000765 000024 00000027063 10265665640 023743 0ustar00pawelmstaff000000 000000 // // Copyright (c) 2002-2003 // Toon Knapen, Kresimir Fresl, Joerg Walter // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_RAW_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_RAW_HPP #include #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { namespace ublas = boost::numeric::ublas; // size: template BOOST_UBLAS_INLINE int matrix_size1 (const M &m) { return (int) m.size1(); } template BOOST_UBLAS_INLINE int matrix_size2 (const M &m) { return (int) m.size2(); } #if 0 // MSVC seems to dislike overloads if there is 'generic' template template BOOST_UBLAS_INLINE int matrix_size1 (const ublas::matrix_reference &m) { return matrix_size1 (m.expression()); } template BOOST_UBLAS_INLINE int matrix_size2 (const ublas::matrix_reference &m) { return matrix_size2 (m.expression()); } #endif // 0 template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::matrix& m) { return (int) (m.size1() * m.size2()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::c_matrix &m) { return (int) (M * N); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix &m, ublas::row_major_tag) { return (int) m.size2(); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix &m, ublas::column_major_tag) { return (int) m.size1(); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix &m) { typedef ublas::matrix matrix_t; return bindings::traits::leading_dimension (m, BOOST_UBLAS_TYPENAME matrix_t::orientation_category()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix_reference &m) { return bindings::traits::leading_dimension (m.expression()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::matrix_range &m) { return bindings::traits::leading_dimension (m.data()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::c_matrix &m) { return (int) N; } // stride: #if 0 // MSVC seems to dislike overloads if there is 'generic' template template BOOST_UBLAS_INLINE int matrix_stride1 (const M &m) { typedef typename M::functor_type functor_type; return (int) functor_type::one1 (m.size1(), m.size2()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const M &m) { typedef typename M::functor_type functor_type; return (int) functor_type::one2 (m.size1(), m.size2()); } #endif // 0 template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix &m) { return (int) F::one1 (m.size1(), m.size2()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix &m) { return (int) F::one2 (m.size1(), m.size2()); } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix_reference &m) { return matrix_stride1 (m.expression()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix_reference &m) { return matrix_stride2 (m.expression()); } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::c_matrix &m) { return (int) N; } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::c_matrix &m) { return 1; } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix_range &m) { return matrix_stride1 (m.data()); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix_range &m) { return matrix_stride2 (m.data()); } template BOOST_UBLAS_INLINE int matrix_stride1 (const ublas::matrix_slice &m) { return (int) (m.stride1() * matrix_stride1 (m.data())); } template BOOST_UBLAS_INLINE int matrix_stride2 (const ublas::matrix_slice &m) { return (int) (m.stride2() * matrix_stride2 (m.data())); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::matrix_row &v) { return matrix_stride2 (v.data()); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::matrix_column &v) { return matrix_stride1 (v.data()); } // storage: #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::matrix::const_pointer matrix_storage (const ublas::matrix &m) { return &m.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::matrix::const_pointer matrix_storage_const (const ublas::matrix &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::matrix::pointer matrix_storage (ublas::matrix &m) { return &m.data().begin()[0]; } #if 0 // MSVC seems to dislike overloads if there is 'generic' template #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const M &m) { return &m.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const M &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (M &m) { return &m.data().begin()[0]; } #endif // 0 #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::matrix_reference &m) { return matrix_storage (m.expression ()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::matrix_reference &m) { return matrix_storage_const (m.expression ()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::matrix_reference &m) { return matrix_storage (m.expression ()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::c_matrix::const_pointer matrix_storage (const ublas::c_matrix &m) { return m.data(); } #endif #ifndef BOOST_MSVC // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::c_matrix::const_pointer matrix_storage_const (const ublas::c_matrix &m) { return m.data(); } template BOOST_UBLAS_INLINE typename ublas::c_matrix::pointer matrix_storage (ublas::c_matrix &m) { return m.data(); } #endif #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::matrix_range &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data()) + m.start2() * matrix_stride2 (m.data()); } template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::matrix_slice &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::matrix_range &m) { return matrix_storage_const (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::matrix_slice &m) { return matrix_storage_const (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::matrix_range &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::matrix_slice &m) { return matrix_storage (m.data()) + m.start1() * matrix_stride1 (m.data ()) + m.start2() * matrix_stride2 (m.data ()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage (const ublas::matrix_row &v) { return matrix_storage (v.data()) + v.index() * matrix_stride1 (v.data()); } template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage (const ublas::matrix_column &v) { return matrix_storage (v.data()) + v.index() * matrix_stride2 (v.data()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage_const (const ublas::matrix_row &v) { return matrix_storage_const (v.data()) + v.index() * matrix_stride1 (v.data()); } template BOOST_UBLAS_INLINE typename M::const_pointer vector_storage_const (const ublas::matrix_column &v) { return matrix_storage_const (v.data()) + v.index() * matrix_stride2 (v.data()); } template BOOST_UBLAS_INLINE typename M::pointer vector_storage (ublas::matrix_row &v) { return matrix_storage (v.data()) + v.index() * matrix_stride1 (v.data()); } template BOOST_UBLAS_INLINE typename M::pointer vector_storage (ublas::matrix_column &v) { return matrix_storage (v.data()) + v.index() * matrix_stride2 (v.data()); } }}}} #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_NO_SYMMETRIC_TRAITS #include #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_NO_SYMMETRIC_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_RAW_HPP kml_src/boost/numeric/bindings/traits/matrix_traits.hpp000644 000765 000024 00000011003 10265665640 024443 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_TRAITS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_TRAITS_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { /// There is no default implementation since there is no reasonable default. /// Most matrix libraries provide totally different functions. /// Auxiliary traits class to reduce the number of specializations. /// MType is the actual matrix type. /// MIdentifier is used to specialize the traits for a specific matrix type, e.g. /// matrix_detail_traits< ublas::matrix, ublas::matrix const > /// matrix_detail_traits< ublas::matrix, ublas::matrix > /// Note that remove_const::type == MIdentifier template struct matrix_detail_traits { typedef MIdentifier identifier_type; typedef MType matrix_type; }; /// matrix_traits<> generic version: template struct matrix_traits : matrix_detail_traits< typename boost::remove_const::type, M> { // typedefs: // matrix_structure // ordering_type // value_type // pointer // symmetric/hermitian typedefs: // uplo_type // static functions: // pointer storage() // int size1() // int size2() // int lower_bandwidth() // only banded matrix types // int upper_bandwidth() // only banded matrix types // int storage_size() // not all matrix types // int leading_dimension() // not all matrix types }; // matrix structure tags: struct general_t {}; struct symmetric_t {}; struct symmetric_packed_t {}; struct hermitian_t {}; struct hermitian_packed_t {}; struct banded_t {}; // TO DO: add triangular, etc. struct unknown_structure_t {}; // storage ordering tags: struct row_major_t {}; struct column_major_t {}; // upper/lower triangular part tags: struct upper_t {}; struct lower_t {}; /////////////////////////// // // free accessor functions // /////////////////////////// template inline typename matrix_traits::pointer matrix_storage (M& m) { return matrix_traits::storage (m); } template inline int matrix_size1 (M& m) { return matrix_traits::size1 (m); } template inline int matrix_size2 (M& m) { return matrix_traits::size2 (m); } template inline int matrix_storage_size (M& m) { return matrix_traits::storage_size (m); } template inline int matrix_stride1 (M& m) { return matrix_traits::stride1 (m); } template inline int matrix_stride2 (M& m) { return matrix_traits::stride2 (m); } template inline int matrix_upper_bandwidth (M& m) { return matrix_traits::upper_bandwidth (m); } template inline int matrix_lower_bandwidth (M& m) { return matrix_traits::lower_bandwidth (m); } template inline int leading_dimension (M& m) { return matrix_traits::leading_dimension (m); } namespace detail { inline char matrix_uplo_tag (upper_t const&) { return 'U'; } inline char matrix_uplo_tag (lower_t const&) { return 'L'; } } template inline char matrix_uplo_tag (SymmM&) { typedef typename matrix_traits::uplo_type uplo_t; return detail::matrix_uplo_tag (uplo_t()); } }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_MATRIX_TRAITS_HPP kml_src/boost/numeric/bindings/traits/sparse_traits.hpp000644 000765 000024 00000007260 10265665640 024446 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_SPARSE_TRAITS_H #define BOOST_NUMERIC_BINDINGS_TRAITS_SPARSE_TRAITS_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { /// There is no default implementation since there is no reasonable default. /// Most matrix libraries provide totally different functions. /// Auxiliary traits class to reduce the number of specializations. template struct sparse_matrix_detail_traits { typedef MIdentifier identifier_type; typedef MType matrix_type; }; /// sparse_matrix_traits<> generic version: template struct sparse_matrix_traits : sparse_matrix_detail_traits ::type, M> { // typedefs: // matrix_structure // storage_format // ordering_type // value_type // value_pointer // index_pointer // enum (or static size_t const): // index_base // static functions: // index_pointer index1_storage() // - compressed column: array of column start locations // - compressed row: array of row start locations // - coordinate, column major: column indices of nonzeros // - coordinate, row major: row indices of nonzeros // index_pointer index2_storage() // - compressed column: array of row indices of nonzeros // - compressed row: array of column indices of nonzeros // - coordinate, column major: row indices of nonzeros // - coordinate, row major: column indices of nonzeros // value_pointer value_storage() // - array of nonzeros // int size1() // int size2() // int num_nonzeros() }; // storage format tags struct compressed_t {}; struct coordinate_t {}; /////////////////////////// // // free accessor functions // /////////////////////////// template inline typename sparse_matrix_traits::index_pointer spmatrix_index1_storage (M& m) { return sparse_matrix_traits::index1_storage (m); } template inline typename sparse_matrix_traits::index_pointer spmatrix_index2_storage (M& m) { return sparse_matrix_traits::index2_storage (m); } template inline typename sparse_matrix_traits::value_pointer spmatrix_value_storage (M& m) { return sparse_matrix_traits::value_storage (m); } template inline int spmatrix_size1 (M& m) { return sparse_matrix_traits::size1 (m); } template inline int spmatrix_size2 (M& m) { return sparse_matrix_traits::size2 (m); } template inline int spmatrix_num_nonzeros (M& m) { return sparse_matrix_traits::num_nonzeros (m); } }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler sparse matrices cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_SPARSE_TRAITS_H kml_src/boost/numeric/bindings/traits/std_valarray.hpp000644 000765 000024 00000003372 10265665640 024256 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_STD_VALARRAY_H #define BOOST_NUMERIC_BINDINGS_TRAITS_STD_VALARRAY_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // std::valarray<> template struct vector_detail_traits, V> : default_vector_traits { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< std::valarray, typename boost::remove_const::type >::value) ); #endif typedef std::valarray identifier_type; typedef V vector_type; typedef typename default_vector_traits::pointer pointer; static pointer storage (vector_type& va) { std::valarray& ncva = const_cast&> (va); return &ncva[0]; } }; }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler std::valarray<> cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_STD_VALARRAY_H kml_src/boost/numeric/bindings/traits/std_vector.hpp000644 000765 000024 00000003101 10265665640 023725 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_STD_VECTOR_H #define BOOST_NUMERIC_BINDINGS_TRAITS_STD_VECTOR_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { // std::vector<> template struct vector_detail_traits, V> : default_vector_traits< V, T > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< std::vector, typename boost::remove_const::type >::value) ); #endif typedef std::vector identifier_type; typedef V vector_type; typedef typename default_vector_traits< V, T >::pointer pointer; static pointer storage (vector_type& v) { return &v.front(); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_STD_VECTOR_H kml_src/boost/numeric/bindings/traits/symm_herm_raw.hpp000644 000765 000024 00000013160 10265665640 024430 0ustar00pawelmstaff000000 000000 // // Copyright (c) 2002-2003 // Toon Knapen, Kresimir Fresl, Joerg Walter // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_RAW_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_RAW_HPP #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { namespace ublas = boost::numeric::ublas; template BOOST_UBLAS_INLINE int leading_dimension (const ublas::symmetric_adaptor &m) { return bindings::traits::leading_dimension (m.data()); } template BOOST_UBLAS_INLINE int leading_dimension (const ublas::hermitian_adaptor &m) { return bindings::traits::leading_dimension (m.data()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::symmetric_adaptor &m) { return matrix_storage_size (m.data()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::hermitian_adaptor &m) { return matrix_storage_size (m.data()); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::symmetric_matrix &m) { return (int) ((m.size1() * (m.size1() + 1)) / 2); } template BOOST_UBLAS_INLINE int matrix_storage_size (const ublas::hermitian_matrix &m) { return (int) ((m.size1() * (m.size1() + 1)) / 2); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::symmetric_matrix::const_pointer matrix_storage (const ublas::symmetric_matrix &m) { return &m.data().begin()[0]; } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::symmetric_matrix::const_pointer matrix_storage_const (const ublas::symmetric_matrix &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::symmetric_matrix::pointer matrix_storage (ublas::symmetric_matrix &m) { return &m.data().begin()[0]; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::symmetric_adaptor &m) { return matrix_storage (m.data()); } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::symmetric_adaptor &m) { return matrix_storage_const (m.data()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::symmetric_adaptor &m) { return matrix_storage (m.data()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::hermitian_matrix::const_pointer matrix_storage (const ublas::hermitian_matrix &m) { return &m.data().begin()[0]; } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::hermitian_matrix::const_pointer matrix_storage_const (const ublas::hermitian_matrix &m) { return &m.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::hermitian_matrix::pointer matrix_storage (ublas::hermitian_matrix &m) { return &m.data().begin()[0]; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage (const ublas::hermitian_adaptor &m) { return matrix_storage (m.data()); } #endif // We need data_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename M::const_pointer matrix_storage_const (const ublas::hermitian_adaptor &m) { return matrix_storage_const (m.data()); } template BOOST_UBLAS_INLINE typename M::pointer matrix_storage (ublas::hermitian_adaptor &m) { return matrix_storage (m.data()); } namespace detail { inline char m_uplo_tag (ublas::upper_tag const&) { return 'U'; } inline char m_uplo_tag (ublas::lower_tag const&) { return 'L'; } } template inline char matrix_uplo_tag (SymmM&) { typedef typename SymmM::packed_category uplo_t; return detail::m_uplo_tag (uplo_t()); } }}}} #endif kml_src/boost/numeric/bindings/traits/tnt.hpp000644 000765 000024 00000010576 10265665640 022374 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_TNT_H #define BOOST_NUMERIC_BINDINGS_TRAITS_TNT_H // Roldan Pozo's TNT (Template Numerical Toolkit) // see: http://math.nist.gov/tnt/index.html #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // TNT::Array1D<> template struct vector_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Array1D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Array1D identifier_type; typedef V vector_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (vector_type& v) { return &v[0]; } static int size (vector_type& v) { return v.dim(); } static int stride (vector_type& v) { return 1; } }; // TNT::Fortran_Array1D<> template struct vector_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Fortran_Array1D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Fortran_Array1D identifier_type; typedef V vector_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (vector_type& v) { return &v(1); } static int size (vector_type& v) { return v.dim(); } static int stride (vector_type& v) { return 1; } }; // TNT::Array2D<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Array2D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Array2D identifier_type; typedef M matrix_type; typedef general_t matrix_structure; typedef row_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { return m[0]; } static int size1 (matrix_type& m) { return m.dim1(); } static int size2 (matrix_type& m) { return m.dim2(); } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { return m.dim2(); } }; // TNT::Fortran_Array2D<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< TNT::Fortran_Array2D, typename boost::remove_const::type >::value) ); #endif typedef TNT::Fortran_Array2D identifier_type; typedef M matrix_type; typedef general_t matrix_structure; typedef column_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { return &m(1, 1); } static int size1 (matrix_type& m) { return m.dim1(); } static int size2 (matrix_type& m) { return m.dim2(); } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { return m.dim1(); } }; }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler TNT cannot be used in bindings #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_TNT_H kml_src/boost/numeric/bindings/traits/traits.hpp000644 000765 000024 00000001356 10265665640 023071 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_H #define BOOST_NUMERIC_BINDINGS_TRAITS_H #include #include #endif kml_src/boost/numeric/bindings/traits/transpose.hpp000644 000765 000024 00000000417 10265665640 023576 0ustar00pawelmstaff000000 000000 #ifndef BOOST_BINDINGS_TRANSPOSE_HPP #define BOOST_BINDINGS_TRANSPOSE_HPP namespace boost { namespace numeric { namespace bindings { namespace traits { const char NO_TRANSPOSE = 'N' ; const char TRANSPOSE = 'T' ; const char CONJUGATE = 'C' ; }}}} #endif kml_src/boost/numeric/bindings/traits/type.h000644 000765 000024 00000001642 10265665640 022202 0ustar00pawelmstaff000000 000000 /* * Copyright (C) 2000,2001,2002,2003 Si-Lab b.v.b.a. and Toon Knapen * * License is hereby granted to use and modify this software * as long as this copyright notice is retained and modifications * are clearly marked. * This License does not permit you to redistribute this software. * */ #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 typedef float fcomplex_t ; typedef double dcomplex_t ; #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 */ /* * Define a fortran LOGICAL as a void (for now). */ typedef void logical_t ; #endif /* BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_H */ kml_src/boost/numeric/bindings/traits/type.hpp000644 000765 000024 00000001172 10265665640 022540 0ustar00pawelmstaff000000 000000 #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 { typedef std::complex< float > complex_f ; typedef std::complex< double > complex_d ; template T real (std::complex const& c) { return std::real (c); } template T imag (std::complex const& c) { return std::imag (c); } }}}} #endif // boost_numeric_bindings_type_hpp kml_src/boost/numeric/bindings/traits/type_traits.hpp000644 000765 000024 00000003722 10265665640 024131 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl and Toon Knapen 2002, 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * 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 #include namespace boost { namespace numeric { namespace bindings { namespace traits { template struct type_traits { #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef Real type; typedef Real real_type; #endif }; 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 ) ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_TRAITS_TYPE_TRAITS_HPP kml_src/boost/numeric/bindings/traits/ublas_banded.hpp000644 000765 000024 00000010271 10265665640 024162 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_BANDED_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_BANDED_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #if defined (BOOST_NUMERIC_BINDINGS_FORTRAN) || !defined (BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK) # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::matrix_banded<> // When orientation_category==row_major_tag then the ublas banded format corresponds to // the LAPACK band format. // Specialization using matrix_detail_traits so that we can specialize for // matrix_detail_traits< banded, banded > // matrix_detail_traits< banded, banded const > // at once. template struct matrix_detail_traits< boost::numeric::ublas::banded_matrix, M > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_NUMERIC_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F::orientation_category, boost::numeric::ublas::row_major_tag >::value)); #endif typedef boost::numeric::ublas::banded_matrix identifier_type ; typedef M matrix_type; typedef banded_t matrix_structure; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (m.data()); } static int size1 (matrix_type& m) { return m.size1(); } static int size2 (matrix_type& m) { return m.size2(); } static int lower_bandwidth (matrix_type& m) { return m.lower() ; } static int upper_bandwidth (matrix_type& m) { return m.upper() ; } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { // g++ 2.95.4 and 3.0.4 (with -pedantic) dislike // identifier_type::functor_type::size2() return lower_bandwidth(m) + upper_bandwidth(m) + 1 ; } // stride1 == distance (m (i, j), m (i+1, j)) static int stride1 (matrix_type& m) { typedef typename identifier_type::orientation_category orientation_category; typedef typename detail::ublas_ordering::functor_type functor_t ; return functor_t::one2 ( std::max(m.size1(), m.size2()), leading_dimension(m)-1 ) ; } // stride2 == distance (m (i, j), m (i, j+1)) static int stride2 (matrix_type& m) { typedef typename identifier_type::orientation_category orientation_category; typedef typename detail::ublas_ordering::functor_type functor_t ; return functor_t::one1 ( std::max(m.size1(), m.size2()), leading_dimension(m)-1 ) ; } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_BANDED_H kml_src/boost/numeric/bindings/traits/ublas_hermitian.hpp000644 000765 000024 00000011523 10265665640 024726 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_HERMITIAN_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_HERMITIAN_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::hermitian_matrix<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F2::orientation_category, boost::numeric::ublas::column_major_tag >::value)); #endif typedef boost::numeric::ublas::hermitian_matrix identifier_type; typedef M matrix_type; typedef hermitian_packed_t matrix_structure; typedef typename detail::ublas_ordering< typename F2::orientation_category >::type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef T value_type ; typedef typename detail::generate_const::type* pointer ; static pointer storage (matrix_type& hm) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (hm.data()); } static int size1 (matrix_type& hm) { return hm.size1(); } static int size2 (matrix_type& hm) { return hm.size2(); } static int storage_size (matrix_type& hm) { return (size1 (hm) + 1) * size2 (hm) / 2; } }; namespace detail { template int matrix_bandwidth( M const& m, upper_t ) { return matrix_traits::upper_bandwidth( m ) ; } template int matrix_bandwidth( M const& m, lower_t ) { // When the lower triangular band matrix is stored the // upper bandwidth must be zero assert( 0 == matrix_traits::upper_bandwidth( m ) ) ; return matrix_traits::lower_bandwidth( m ) ; } } // namespace detail // ublas::hermitian_adaptor<> template struct matrix_detail_traits, MA> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif typedef boost::numeric::ublas::hermitian_adaptor identifier_type; typedef MA matrix_type; typedef hermitian_t matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& hm) { return matrix_traits::storage (hm.data()); } static int size1 (matrix_type& hm) { return hm.size1(); } static int size2 (matrix_type& hm) { return hm.size2(); } static int storage_size (matrix_type& hm) { return size1 (hm) * size2 (hm); } static int leading_dimension (matrix_type& hm) { return matrix_traits::leading_dimension (hm.data()); } // For banded M static int upper_bandwidth(matrix_type& hm) { return detail::matrix_bandwidth( hm.data(), uplo_type() ); } static int lower_bandwidth(matrix_type& hm) { return detail::matrix_bandwidth( hm.data(), uplo_type() ); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_HERMITIAN_H kml_src/boost/numeric/bindings/traits/ublas_matrix.hpp000644 000765 000024 00000031773 10265665640 024263 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_MATRIX_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_MATRIX_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #if defined (BOOST_NUMERIC_BINDINGS_FORTRAN) || !defined (BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK) # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::matrix<> // Specialization using matrix_detail_traits so that we can specialize for // matrix_detail_traits< matrix, matrix > // matrix_detail_traits< matrix, matrix const > // at once. template struct matrix_detail_traits< boost::numeric::ublas::matrix, M > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_NUMERIC_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F::orientation_category, boost::numeric::ublas::column_major_tag >::value)); #endif typedef boost::numeric::ublas::matrix identifier_type ; typedef M matrix_type; typedef general_t matrix_structure; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; typedef typename identifier_type::orientation_category orientation_category; typedef typename detail::ublas_ordering::functor_type functor_t ; static pointer storage (matrix_type& m) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (m.data()); } static int size1 (matrix_type& m) { return m.size1(); } static int size2 (matrix_type& m) { return m.size2(); } static int storage_size (matrix_type& m) { return size1 (m) * size2 (m); } static int leading_dimension (matrix_type& m) { // g++ 2.95.4 and 3.0.4 (with -pedantic) dislike // identifier_type::functor_type::size2() return functor_t::size2 (m.size1(), m.size2()); } // stride1 == distance (m (i, j), m (i+1, j)) static int stride1 (matrix_type& m) { return functor_t::one1 (m.size1(), m.size2()); } // stride2 == distance (m (i, j), m (i, j+1)) static int stride2 (matrix_type& m) { return functor_t::one2 (m.size1(), m.size2()); } }; // ublas::matrix_reference<> template struct matrix_detail_traits, MR > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_reference, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_reference identifier_type; typedef MR matrix_type; typedef typename matrix_traits::matrix_structure matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& mr) { return matrix_traits::storage (mr.expression()); } static int size1 (matrix_type& mr) { return mr.size1(); } static int size2 (matrix_type& mr) { return mr.size2(); } static int leading_dimension (matrix_type& mr) { return matrix_traits::leading_dimension (mr.expression()); } static int stride1 (matrix_type& mr) { return matrix_traits::stride1 (mr.expression()); } static int stride2 (matrix_type& mr) { return matrix_traits::stride2 (mr.expression()); } // Only for banded matrices static int upper_bandwidth(matrix_type& mr) { return matrix_traits::upper_bandwidth(mr.expression()); } static int lower_bandwidth(matrix_type& mr) { return matrix_traits::lower_bandwidth(mr.expression()); } }; // ublas::matrix_range<> template struct matrix_detail_traits, MR > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_range, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_range identifier_type; typedef MR matrix_type; typedef typename matrix_traits::matrix_structure matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; private: typedef typename detail::generate_const::type m_type; public: typedef typename matrix_traits::value_type value_type; typedef typename matrix_traits::pointer pointer ; public: static pointer storage (matrix_type& mr) { m_type& mt = mr.data(); pointer ptr = matrix_traits::storage (mt); ptr += mr.start1() * matrix_traits::stride1 (mt); ptr += mr.start2() * matrix_traits::stride2 (mt); return ptr; } static int size1 (matrix_type& mr) { return mr.size1(); } static int size2 (matrix_type& mr) { return mr.size2(); } static int leading_dimension (matrix_type& mr) { return matrix_traits::leading_dimension (mr.data()); } static int stride1 (matrix_type& mr) { return matrix_traits::stride1 (mr.data()); } static int stride2 (matrix_type& mr) { return matrix_traits::stride2 (mr.data()); } // For band matrices only static int upper_bandwidth (matrix_type& mr) { return matrix_traits::upper_bandwidth(mr.data()); } static int lower_bandwidth (matrix_type& mr) { return matrix_traits::lower_bandwidth(mr.data()); } }; // ublas::matrix_slice<> template struct matrix_detail_traits, MS > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_slice, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_slice identifier_type; typedef MS matrix_type; typedef unknown_structure_t matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& ms) { m_type& mt = ms.data(); pointer ptr = matrix_traits::storage (mt); ptr += ms.start1() * matrix_traits::stride1 (mt); ptr += ms.start2() * matrix_traits::stride2 (mt); return ptr; } static int size1 (matrix_type& ms) { return ms.size1(); } static int size2 (matrix_type& ms) { return ms.size2(); } private: static int ld (int s1, int s2, boost::numeric::ublas::row_major_tag) { return s1; } static int ld (int s1, int s2, boost::numeric::ublas::column_major_tag) { return s2; } public: static int leading_dimension (matrix_type& ms) { typedef typename identifier_type::orientation_category oc_t; return ld (ms.stride1(), ms.stride2(), oc_t()) * matrix_traits::leading_dimension (ms.data()); } static int stride1 (matrix_type& ms) { return ms.stride1() * matrix_traits::stride1 (ms.data()); } static int stride2 (matrix_type& ms) { return ms.stride2() * matrix_traits::stride2 (ms.data()); } }; // matrix_row<> and matrix_column<> are vectors: // ublas::matrix_row<> template struct vector_detail_traits< boost::numeric::ublas::matrix_row, MR > : default_vector_traits< MR, typename M::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_row, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_row identifier_type; typedef MR vector_type; typedef typename M::value_type value_type; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (vector_type& mr) { m_type& mt = mr.data(); pointer ptr = matrix_traits::storage (mt); ptr += mr.index() * matrix_traits::stride1 (mt); return ptr; } static int stride (vector_type& mr) { return matrix_traits::stride2 (mr.data()); } }; // ublas::matrix_column<> template struct vector_detail_traits< boost::numeric::ublas::matrix_column, MC > : default_vector_traits< MC, typename M::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::matrix_column, typename boost::remove_const::type>::value) ) ; #endif typedef boost::numeric::ublas::matrix_column identifier_type; typedef MC vector_type; typedef typename M::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (vector_type& mc) { m_type& mt = mc.data(); pointer ptr = matrix_traits::storage (mt); ptr += mc.index() * matrix_traits::stride2 (mt); return ptr; } static int stride (vector_type& mc) { return matrix_traits::stride1 (mc.data()); } }; #ifndef BOOST_NUMERIC_BINDINGS_FORTRAN // (undocumented) ublas::c_matrix<> template struct matrix_detail_traits< boost::numeric::ublas::c_matrix, Matr > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif typedef boost::numeric::ublas::c_matrix identifier_type ; typedef Matr matrix_type; typedef general_t matrix_structure; typedef row_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& m) { return m.data(); } static int size1 (matrix_type& m) { return m.size1(); } static int size2 (matrix_type& m) { return m.size2(); } static int storage_size (matrix_type& m) { return M * N; } static int leading_dimension (matrix_type& m) { return N; } // stride1 == distance (m (i, j), m (i+1, j)) static int stride1 (matrix_type& m) { return N; } // stride2 == distance (m (i, j), m (i, j+1)) static int stride2 (matrix_type& m) { return 1; } }; #endif // BOOST_NUMERIC_BINDINGS_FORTRAN // TO DO: matrix_vector_range<>, matrix_vector_slice<> }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_MATRIX_H kml_src/boost/numeric/bindings/traits/ublas_sparse.hpp000644 000765 000024 00000012051 10265665640 024240 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SPARSE_MATRIX_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SPARSE_MATRIX_H #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::compressed_matrix<> template struct sparse_matrix_detail_traits< boost::numeric::ublas::compressed_matrix, MType > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::compressed_matrix, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::compressed_matrix identifier_type; typedef MType matrix_type; typedef general_t matrix_structure; typedef compressed_t storage_format; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef T value_type; private: typedef typename detail::generate_const::type val_array_t; typedef typename detail::generate_const::type idx_array_t; public: typedef typename vector_traits::pointer value_pointer; typedef typename vector_traits::pointer index_pointer; BOOST_STATIC_CONSTANT (std::size_t, index_base = IB); static index_pointer index1_storage (matrix_type& cm) { if ( cm.filled1()<=ordering_type::size1(cm.size1(), cm.size2()) ) std::fill( cm.index1_data().begin()+cm.filled1(), cm.index1_data().begin()+ordering_type::size1(cm.size1(), cm.size2())+1, cm.filled2() ) ; return vector_traits::storage (cm.index1_data()); } static index_pointer index2_storage (matrix_type& cm) { return vector_traits::storage (cm.index2_data()); } static value_pointer value_storage (matrix_type& cm) { return vector_traits::storage (cm.value_data()); } static int size1 (matrix_type& cm) { return cm.size1(); } static int size2 (matrix_type& cm) { return cm.size2(); } static int num_nonzeros (matrix_type& cm) { return cm.nnz(); // Joerg, this isn't very intuitive :o( // return cm.non_zeros(); } }; // ublas::coordinate_matrix<> template struct sparse_matrix_detail_traits< boost::numeric::ublas::coordinate_matrix, MType > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::coordinate_matrix, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::coordinate_matrix identifier_type; typedef MType matrix_type; typedef general_t matrix_structure; typedef coordinate_t storage_format; typedef typename detail::ublas_ordering< typename F::orientation_category >::type ordering_type; typedef T value_type; private: typedef typename detail::generate_const::type val_array_t; typedef typename detail::generate_const::type idx_array_t; public: typedef typename vector_traits::pointer value_pointer; typedef typename vector_traits::pointer index_pointer; BOOST_STATIC_CONSTANT (std::size_t, index_base = IB); static index_pointer index1_storage (matrix_type& cm) { return vector_traits::storage (cm.index1_data()); } static index_pointer index2_storage (matrix_type& cm) { return vector_traits::storage (cm.index2_data()); } static value_pointer value_storage (matrix_type& cm) { return vector_traits::storage (cm.value_data()); } static int size1 (matrix_type& cm) { return cm.size1(); } static int size2 (matrix_type& cm) { return cm.size2(); } static int num_nonzeros (matrix_type& cm) { return cm.nnz(); // Joerg, this isn't very intuitive :o( // return cm.non_zeros(); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SPARSE_MATRIX_H kml_src/boost/numeric/bindings/traits/ublas_symmetric.hpp000644 000765 000024 00000010126 10265665640 024760 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SYMMETRIC_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SYMMETRIC_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::symmetric_matrix<> template struct matrix_detail_traits, M> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif #ifdef BOOST_BINDINGS_FORTRAN BOOST_STATIC_ASSERT((boost::is_same< typename F2::orientation_category, boost::numeric::ublas::column_major_tag >::value)); #endif typedef boost::numeric::ublas::symmetric_matrix identifier_type; typedef M matrix_type; typedef symmetric_packed_t matrix_structure; typedef typename detail::ublas_ordering< typename F2::orientation_category >::type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef T value_type ; typedef typename detail::generate_const::type* pointer ; static pointer storage (matrix_type& sm) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (sm.data()); } static int size1 (matrix_type& sm) { return sm.size1(); } static int size2 (matrix_type& sm) { return sm.size2(); } static int storage_size (matrix_type& sm) { return (size1 (sm) + 1) * size2 (sm) / 2; } }; // ublas::symmetric_adaptor<> template struct matrix_detail_traits, MA> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same, typename boost::remove_const::type>::value) ); #endif typedef boost::numeric::ublas::symmetric_adaptor identifier_type; typedef MA matrix_type; typedef symmetric_t matrix_structure; typedef typename matrix_traits::ordering_type ordering_type; typedef typename detail::ublas_uplo< F1 >::type uplo_type; typedef typename M::value_type value_type; typedef typename detail::generate_const::type* pointer; private: typedef typename detail::generate_const::type m_type; public: static pointer storage (matrix_type& sm) { return matrix_traits::storage (sm.data()); } static int size1 (matrix_type& sm) { return sm.size1(); } static int size2 (matrix_type& sm) { return sm.size2(); } static int storage_size (matrix_type& sm) { return size1 (sm) * size2 (sm); } static int leading_dimension (matrix_type& sm) { return matrix_traits::leading_dimension (sm.data()); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_SYMMETRIC_H kml_src/boost/numeric/bindings/traits/ublas_vector.hpp000644 000765 000024 00000013471 10265665640 024254 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::vector<> template struct vector_detail_traits< boost::numeric::ublas::vector, V > : default_vector_traits< V, T > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector identifier_type; typedef V vector_type; typedef typename default_vector_traits< V, T >::pointer pointer; static pointer storage (vector_type& v) { typedef typename detail::generate_const::type array_type ; return vector_traits::storage (v.data()); } }; // ublas::vector_reference<> template struct vector_detail_traits< boost::numeric::ublas::vector_reference, VR > : default_vector_traits< VR, typename V::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_reference, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_reference identifier_type; typedef VR vector_type; typedef typename V::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type vct_t; public: static pointer storage (vector_type& v) { return vector_traits::storage (v.expression()); } static int stride (vector_type& v) { return vector_traits::stride (v.expression()); } }; // ublas::vector_range<> template struct vector_detail_traits< boost::numeric::ublas::vector_range, VR > : default_vector_traits< VR, typename V::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_range, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_range identifier_type; typedef VR vector_type; typedef typename V::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type v_type; public: static pointer storage (vector_type& vr) { pointer ptr = vector_traits::storage (vr.data()); ptr += vr.start() * vector_traits::stride (vr.data()); return ptr; } static int stride (vector_type& vr) { return vector_traits::stride (vr.data()); } }; // ublas::vector_slice<> template struct vector_detail_traits, VS > : default_vector_traits< VS, typename V::value_type > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_slice, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_slice identifier_type; typedef VS vector_type; typedef typename V::value_type value_type ; typedef typename default_vector_traits::pointer pointer; private: typedef typename detail::generate_const::type v_type; public: static pointer storage (vector_type& vs) { pointer ptr = vector_traits::storage (vs.data()); ptr += vs.start() * vector_traits::stride (vs.data()); return ptr; } static int stride (vector_type& vs) { return vs.stride() * vector_traits::stride (vs.data()); } }; #ifndef BOOST_NUMERIC_BINDINGS_FORTRAN // (undocumented) ublas::c_vector<> template struct vector_detail_traits< boost::numeric::ublas::c_vector, V > : default_vector_traits< V, T > { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::c_vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::c_vector identifier_type; typedef V vector_type; typedef typename default_vector_traits::pointer pointer; static pointer storage (vector_type& v) { return v.data(); } }; #endif // BOOST_NUMERIC_BINDINGS_FORTRAN }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_H kml_src/boost/numeric/bindings/traits/ublas_vector2.hpp000644 000765 000024 00000011062 10265665640 024330 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_AS_MATRIX_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_AS_MATRIX_H #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { // ublas::vector<> treated as matrix (nx1) template struct matrix_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector identifier_type; typedef V matrix_type; typedef general_t matrix_structure; typedef column_major_t ordering_type; typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& v) { typedef typename detail::generate_const::type array_type; return vector_traits::storage (v.data()); } static int size1 (matrix_type& v) { return v.size(); } static int size2 (matrix_type&) { return 1; } static int storage_size (matrix_type& v) { return v.size(); } static int leading_dimension (matrix_type& v) { return v.size(); } }; // ublas::vector_range<> treated as matrix (nx1) template struct matrix_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::vector_range, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::vector_range identifier_type; typedef V matrix_type; typedef general_t matrix_structure; typedef column_major_t ordering_type; typedef typename T::value_type value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& v) { return vector_traits::storage (v); } static int size1 (matrix_type& v) { return v.size(); } static int size2 (matrix_type&) { return 1; } static int storage_size (matrix_type& v) { return v.size(); } static int leading_dimension (matrix_type& v) { return v.size(); } }; #ifndef BOOST_NUMERIC_BINDINGS_FORTRAN // (undocumented) ublas::c_vector<> template struct matrix_detail_traits, V> { #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK BOOST_STATIC_ASSERT( (boost::is_same< boost::numeric::ublas::c_vector, typename boost::remove_const::type >::value) ); #endif typedef boost::numeric::ublas::c_vector identifier_type; typedef V matrix_type; typedef general_t matrix_structure; typedef row_major_t ordering_type; // consistent with c_matrix<> typedef T value_type; typedef typename detail::generate_const::type* pointer; static pointer storage (matrix_type& v) { return v.data(); } static int size1 (matrix_type&) { return 1; } static int size2 (matrix_type& v) { return v.size(); } static int storage_size (matrix_type&) { return N; } static int leading_dimension (matrix_type&) { return N; } }; #endif // BOOST_NUMERIC_BINDINGS_FORTRAN }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #error with your compiler ublas::vector<> cannot be used as matrix #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_VECTOR_AS_MATRIX_H kml_src/boost/numeric/bindings/traits/vector_raw.hpp000644 000765 000024 00000021447 10265665640 023741 0ustar00pawelmstaff000000 000000 // // Copyright (c) 2002,2003,2004 // Toon Knapen, Kresimir Fresl, Joerg Walter, Karl Meerbergen // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. The authors make no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. // // #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_RAW_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_RAW_HPP #include #include #ifndef BOOST_UBLAS_HAVE_BINDINGS # include #endif #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { template BOOST_UBLAS_INLINE int vector_size (const V &v) { return (int) v.size(); } //////////////////////////////////////////////////////////////// // ublas::vector<> etc. namespace ublas = boost::numeric::ublas; #if 0 // MSVC seems to dislike overloads if there is `generic' template template BOOST_UBLAS_INLINE int vector_size (const ublas::vector_reference &v) { return vector_size (v.expression()); } #endif #if 0 // MSVC seems to dislike overloads if there is `generic' template template BOOST_UBLAS_INLINE int vector_stride (const V &v) { return 1; } #endif template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector &v) { return 1; } template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector_reference &v) { return (int) vector_stride (v.expression()); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::c_vector &v) { return 1; } template int vector_stride (const ublas::vector_slice&); template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector_range &v) { return (int) vector_stride (v.data()); } template BOOST_UBLAS_INLINE int vector_stride (const ublas::vector_slice &v) { return (int) (v.stride() * vector_stride (v.data())); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::vector::value_type const* vector_storage (const ublas::vector &v) { return &v.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::vector::value_type const* vector_storage_const (const ublas::vector &v) { return &v.data().begin()[0]; } template BOOST_UBLAS_INLINE typename ublas::vector::value_type* vector_storage (ublas::vector &v) { return &v.data().begin()[0]; } #if 0 // MSVC seems to dislike overloads if there is `generic' template #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename V::const_pointer vector_storage (const V &v) { return &v.data().begin()[0]; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename V::const_pointer vector_storage_const (const V &v) { return &v.data().begin()[0]; } template BOOST_UBLAS_INLINE typename V::pointer vector_storage (V &v) { return &v.data().begin()[0]; } #endif #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage (const ublas::vector_reference &v) { return vector_storage (v.expression()); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage_const (const ublas::vector_reference &v) { return vector_storage_const (v.expression()); } template BOOST_UBLAS_INLINE typename V::value_type* vector_storage (ublas::vector_reference &v) { return vector_storage (v.expression()); } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename ublas::c_vector::value_type const* vector_storage (const ublas::c_vector &v) { return v.data(); } #endif #ifndef BOOST_MSVC // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename ublas::c_vector::value_type const* vector_storage_const (const ublas::c_vector &v) { return v.data(); } template BOOST_UBLAS_INLINE typename ublas::c_vector::value_type* vector_storage (ublas::c_vector &v) { return v.data(); } #endif #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template typename V::value_type const* vector_storage (const ublas::vector_slice&); template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage (const ublas::vector_range &v) { typename V::value_type const* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage (const ublas::vector_slice &v) { typename V::value_type const* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template typename V::value_type const* vector_storage_const (const ublas::vector_slice&); template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage_const (const ublas::vector_range &v) { typename V::value_type const* ptr = vector_storage_const (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template BOOST_UBLAS_INLINE typename V::value_type const* vector_storage_const (const ublas::vector_slice &v) { typename V::value_type const* ptr = vector_storage_const (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template typename V::value_type* vector_storage (ublas::vector_slice&); template BOOST_UBLAS_INLINE typename V::value_type* vector_storage (ublas::vector_range &v) { typename V::value_type* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } template BOOST_UBLAS_INLINE typename V::value_type* vector_storage (ublas::vector_slice &v) { typename V::value_type* ptr = vector_storage (v.data()); ptr += v.start() * vector_stride (v.data()); return ptr; } ////////////////////////////////////////////////////////////////// // std::vector<> template BOOST_UBLAS_INLINE int vector_stride (const std::vector &v) { return 1; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE typename std::vector::value_type const* vector_storage (const std::vector &v) { return &v.front(); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE typename std::vector::value_type const* vector_storage_const (const std::vector &v) { return &v.front(); } template BOOST_UBLAS_INLINE typename std::vector::value_type* vector_storage (std::vector &v) { return &v.front(); } ////////////////////////////////////////////////////////////////// // bindings::traits::detail::array<> template BOOST_UBLAS_INLINE int vector_stride (const detail::array &a) { return 1; } #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template BOOST_UBLAS_INLINE const T* vector_storage (const detail::array &a) { return a.storage(); } #endif // We need storage_const() mostly due to MSVC 6.0. // But how shall we write portable code otherwise? template BOOST_UBLAS_INLINE const T* vector_storage_const (const detail::array &a) { return a.storage(); } template BOOST_UBLAS_INLINE T* vector_storage (detail::array &a) { return a.storage(); } }}}} #endif kml_src/boost/numeric/bindings/traits/vector_traits.hpp000644 000765 000024 00000006315 10265665640 024453 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_TRAITS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_TRAITS_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_SANITY_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace traits { /// default_vector_traits is just a base-class that can be /// used as the default vector_traits and the different /// specialisation to automatically define most of the /// functions. template struct default_vector_traits { typedef T value_type; typedef typename detail::generate_const::type* pointer; // if V is const, pointer will be a const value_type* static pointer storage (V& v) { return &v[0]; } static int size (V& v) { return v.size(); } static int stride (V& v) { return 1; } }; // vector_detail_traits is used to implement specializations of vector_traits. // VIdentifier is the vector_type without const, while VType can have a const. // VIdentifier is used to write template specializations for VType and const VType. // e.g. vector_detail_traits< std::vector, std::vector const > // e.g. vector_detail_traits< std::vector, std::vector > // Note that boost::remove_const::type == VIdentifier. template struct vector_detail_traits : default_vector_traits { typedef VIdentifier identifier_type; typedef VType vector_type; }; // vector_traits<> generic version: template struct vector_traits : vector_detail_traits< typename boost::remove_const::type, V > {}; /////////////////////////// // // free accessor functions: // /////////////////////////// template inline typename vector_traits::pointer vector_storage (V& v) { return vector_traits::storage (v); } template inline int vector_size (V& v) { return vector_traits::size (v); } template inline int vector_stride (V& v) { return vector_traits::stride (v); } }}}} #else // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_VECTOR_TRAITS_HPP kml_src/boost/numeric/bindings/traits/detail/array.hpp000644 000765 000024 00000002345 10265665640 024142 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #include namespace boost { namespace numeric { namespace bindings { namespace traits { template struct vector_traits > { typedef T value_type; typedef T* pointer; static pointer storage (detail::array& a) { return a.storage(); } static int size (detail::array& a) { return a.size(); } }; }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_HPP kml_src/boost/numeric/bindings/traits/detail/array_impl.hpp000644 000765 000024 00000004661 10265665640 025166 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_IMPL_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_ARRAY_IMPL_HPP /* 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'. */ #include #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { template class array : private noncopyable { public: array (int n) { stg = new (std::nothrow) T[n]; sz = (stg != 0) ? n : 0; } ~array() { delete[] stg; } int 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: int sz; T* stg; }; }} }}} #endif kml_src/boost/numeric/bindings/traits/detail/generate_const.hpp000644 000765 000024 00000002524 10265665640 026023 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) 2002, 2003 Kresimir Fresl, Toon Knapen and Karl Meerbergen * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * First author acknowledges the support of the Faculty of Civil * Engineering, University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_GENERATE_CONST_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_GENERATE_CONST_HPP #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { /// Copy const from V to X if present template struct generate_const { typedef X type; }; template struct generate_const< const V, X > { typedef X const type; }; template struct generate_const< V const, X const > { typedef X const type; }; }}}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_GENERATE_CONST_HPP kml_src/boost/numeric/bindings/traits/detail/symm_herm_traits.hpp000644 000765 000024 00000004723 10265665640 026414 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_TRAITS_HPP #define BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_TRAITS_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { // select symmetric or hermitian matrix structure template struct symm_herm_t {}; template<> struct symm_herm_t { typedef symmetric_t type; }; template<> struct symm_herm_t { typedef symmetric_t type; }; template<> struct symm_herm_t { typedef hermitian_t type; }; template<> struct symm_herm_t { typedef hermitian_t type; }; template struct symm_herm_pack_t {}; template<> struct symm_herm_pack_t { typedef symmetric_packed_t type; }; template<> struct symm_herm_pack_t { typedef symmetric_packed_t type; }; template<> struct symm_herm_pack_t { typedef hermitian_packed_t type; }; template<> struct symm_herm_pack_t { typedef hermitian_packed_t type; }; template struct symm_herm_compatible { BOOST_STATIC_CONSTANT( bool, value=false ) ; }; template struct symm_herm_compatible< T, hermitian_t > { BOOST_STATIC_CONSTANT( bool, value=true ) ; }; template struct symm_herm_compatible< T, symmetric_t > { BOOST_STATIC_CONSTANT( bool, value=true ) ; }; template struct symm_herm_compatible< std::complex, symmetric_t > { BOOST_STATIC_CONSTANT( bool, value=false ) ; }; } }}}} #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS #endif // BOOST_NUMERIC_BINDINGS_TRAITS_SYMM_HERM_TRAITS_HPP kml_src/boost/numeric/bindings/traits/detail/ublas_ordering.hpp000644 000765 000024 00000002412 10265665640 026016 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UBLAS_ORDERING_H #define BOOST_NUMERIC_BINDINGS_TRAITS_DETAIL_UBLAS_ORDERING_H #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { template struct ublas_ordering {}; template<> struct ublas_ordering { typedef row_major_t type; typedef boost::numeric::ublas::row_major functor_type; }; template<> struct ublas_ordering { typedef column_major_t type; typedef boost::numeric::ublas::column_major functor_type; }; } }}}} #endif kml_src/boost/numeric/bindings/traits/detail/ublas_uplo.hpp000644 000765 000024 00000002030 10265665640 025160 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_UPLO_H #define BOOST_NUMERIC_BINDINGS_TRAITS_UBLAS_UPLO_H #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { template struct ublas_uplo {}; template<> struct ublas_uplo { typedef lower_t type; }; template<> struct ublas_uplo { typedef upper_t type; }; } }}}} #endif kml_src/boost/numeric/bindings/traits/detail/utils.hpp000644 000765 000024 00000004066 10265665640 024166 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * 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 #include namespace boost { namespace numeric { namespace bindings { namespace traits { namespace detail { // complex array => real & imaginary arrays template inline 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 inline 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 int inline int to_int (float f) { return static_cast (f); } inline int to_int (double d) { return static_cast (d); } inline int to_int (traits::complex_f const& cf) { return static_cast (traits::real (cf)); } inline int to_int (traits::complex_d const& cd) { return static_cast (traits::real (cd)); } } }}}} #endif kml_src/boost/numeric/bindings/lapack/gees.hpp000644 000765 000024 00000033547 10265665640 022442 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GEES_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Schur factorization of general matrix. // /////////////////////////////////////////////////////////////////// /* * gees() computes a Schur factorization of an N-by-N matrix A. * * The Schur decomposition is A = U S * herm(U) where U is a * unitary matrix and S is upper triangular. The eigenvalues of A * are on the main diagonal of S. If A is real, S is in pseudo * upper triangular form. * * Workspace is organized following the arguments in the calling sequence. * optimal_workspace() : for optimizing use of blas 3 kernels * minimal_workspace() : minimum size of workarrays, but does not allow for optimization * of blas 3 kernels * workspace( work ) for real matrices where work is a real array with * vector_size( work ) >= 3*matrix_size1( a ) * workspace( work, rwork ) for complex matrices where work is a complex * array with vector_size( work ) >= 2*matrix_size1( a ) * and rwork is a real array with * vector_size( rwork ) >= matrix_size1( a ). */ namespace detail { inline void gees (char const jobvs, char const sort, logical_t* select, int const n, float* a, int const lda, int& sdim, traits::complex_f* w, float* vs, int const ldvs, float* work, int const lwork, bool* bwork, int& info) { traits::detail::array wr(n); traits::detail::array wi(n); LAPACK_SGEES (&jobvs, &sort, select, &n, a, &lda, &sdim, traits::vector_storage(wr), traits::vector_storage(wi), vs, &ldvs, work, &lwork, bwork, &info); traits::detail::interlace(traits::vector_storage(wr), traits::vector_storage(wr)+n, traits::vector_storage(wi), w); } inline void gees (char const jobvs, char const sort, logical_t* select, int const n, double* a, int const lda, int& sdim, traits::complex_d* w, double* vs, int const ldvs, double* work, int const lwork, bool* bwork, int& info) { traits::detail::array wr(n); traits::detail::array wi(n); LAPACK_DGEES (&jobvs, &sort, select, &n, a, &lda, &sdim, traits::vector_storage(wr), traits::vector_storage(wi), vs, &ldvs, work, &lwork, bwork, &info); traits::detail::interlace(traits::vector_storage(wr), traits::vector_storage(wr)+n, traits::vector_storage(wi), w); } inline void gees (char const jobvs, char const sort, logical_t* select, int const n, traits::complex_f* a, int const lda, int& sdim, traits::complex_f* w, traits::complex_f* vs, int const ldvs, traits::complex_f* work, int lwork, float* rwork, bool* bwork, int& info) { LAPACK_CGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr (vs), &ldvs, traits::complex_ptr(work), &lwork, rwork, bwork, &info); } inline void gees (char const jobvs, char const sort, logical_t* select, int const n, traits::complex_d* a, int const lda, int& sdim, traits::complex_d* w, traits::complex_d* vs, int const ldvs, traits::complex_d* work, int lwork, double* rwork, bool* bwork, int& info) { LAPACK_ZGEES (&jobvs, &sort, select, &n, traits::complex_ptr(a), &lda, &sdim, traits::complex_ptr(w), traits::complex_ptr(vs), &ldvs, traits::complex_ptr(work), &lwork, rwork, bwork, &info); } } namespace detail { /// Compute Schur factorization, passing one work array. template inline int gees (char jobvs, MatrA& a, EigVal& w, SchVec& vs, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif typedef typename MatrA::value_type value_type ; int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (vs)); assert (n == traits::matrix_size2 (vs)); assert (n == traits::vector_size (w)); assert (3*n <= traits::vector_size (work)); logical_t* select=0; bool* bwork=0; int info, sdim; detail::gees (jobvs, 'N', select, n, traits::matrix_storage (a), traits::leading_dimension (a), sdim, traits::vector_storage (w), traits::matrix_storage (vs), traits::leading_dimension (vs), traits::vector_storage( work ), traits::vector_size( work ), bwork, info); return info ; } // gees() /// Compute Schur factorization, passing two work arrays. template inline int gees (char jobvs, MatrA& a, EigVal& w, SchVec& vs, Work& work, RWork& rwork) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif typedef typename MatrA::value_type value_type ; int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (vs)); assert (n == traits::matrix_size2 (vs)); assert (n == traits::vector_size (w)); assert (2*n <= traits::vector_size (work)); assert (n <= traits::vector_size (rwork)); logical_t* select=0; bool* bwork=0; int info, sdim; detail::gees (jobvs, 'N', select, n, traits::matrix_storage (a), traits::leading_dimension (a), sdim, traits::vector_storage (w), traits::matrix_storage (vs), traits::leading_dimension (vs), traits::vector_storage( work ), traits::vector_size( work ), traits::vector_storage( rwork ), bwork, info); return info ; } // gees() /// Compute Schur factorization, depending on whether we have one or /// two workspace arrays. N= the number of workspace arrays. template struct Gees {}; template <> struct Gees< 2 > { template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, optimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 2*n ); traits::detail::array rwork( n ); return gees( jobvs, a, w, vs, work, rwork ); } // gees() template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, minimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 2*n ); traits::detail::array rwork( n ); return gees( jobvs, a, w, vs, work, rwork ); } // gees() /// Compute Schur factorization, passing workspace2 as workspace template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, workspace2& workspace ) const { return gees( jobvs, a, w, vs, workspace.w_, workspace.wr_ ); } // gees() }; // Gees<2> template <> struct Gees< 1 > { template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, optimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 3*n ); return gees( jobvs, a, w, vs, work ); } // gees() template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, minimal_workspace ) const { typedef typename MatrA::value_type value_type ; typedef typename traits::type_traits< value_type >::real_type real_type ; int n = traits::matrix_size1( a ); traits::detail::array work( 3*n ); return gees( jobvs, a, w, vs, work ); } // gees() /// Compute Schur factorization, passing workspace1 as workspace template inline int operator() (char jobvs, MatrA& a, EigVal& w, SchVec& vs, detail::workspace1 workspace ) const { return gees( jobvs, a, w, vs, workspace.w_ ); } // gees() }; // Gees<1> } // namespace detail /// Compute Schur factorization with Schur vectors. /// /// Workspace can be the following : /// optimal_workspace() : for optimizing use of blas 3 kernels /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization /// of blas 3 kernels /// workspace( real_work ) for real matrices where /// vector_size( real_work ) >= 3*matrix_size1( a ) /// workspace( complex_work, real_work ) for complex matrices where /// vector_size( complex_work ) >= 2*matrix_size1( a ) /// and vector_size( real_work ) >= matrix_size1( a ). template inline int gees (MatrA& a, EigVal& e, SchVec& vs, Workspace workspace ) { return detail::Gees< n_workspace_args::value>() ( 'V', a, e, vs, workspace ); } // gees() // Compute Schur factorization without Schur vectors. /// /// Workspace can be the following : /// optimal_workspace() : for optimizing use of blas 3 kernels /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization /// of blas 3 kernels /// workspace( real_work ) for real matrices where /// vector_size( real_work ) >= 3*matrix_size1( a ) /// workspace( complex_work, real_work ) for complex matrices where /// vector_size( complex_work ) >= 2*matrix_size1( a ) /// and vector_size( real_work ) >= matrix_size1( a ). template inline int gees (MatrA& a, EigVal& e, Workspace workspace) { return detail::Gees< n_workspace_args::value>() ('N', a, e, a, workspace ); } } }}} #endif kml_src/boost/numeric/bindings/lapack/geev.hpp000644 000765 000024 00000027135 10265665640 022441 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Andreas Kloeckner 2004 * Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GEEV_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a general matrix A * V = V * D // /////////////////////////////////////////////////////////////////// /* * geev() computes the eigendecomposition of a N x N matrix, * where V is a N x N matrix and D is a diagonal matrix. The * diagonal element D(i,i) is an eigenvalue of A and Q(:,i) is * a corresponding eigenvector. * * * int geev (char jobz, char uplo, A& a, W& w, V* vl, V* vr, optimal_workspace); * * a is the matrix whose eigendecomposition you're interested in. (input) * * w contains the diagonal of D, above. w must always be complex. (output) * * vl is an N x N matrix containing the left eigenvectors of a in its * columns. See remark on complex vs. real below. May be left NULL to indicate * that you do not want left eigenvectors. * * vr is an N x N matrix containing the right ("usual") eigenvectors of a in its * columns. See remark on complex vs. real below. As a matrix, vr fulfills * A * VR = VR * D. (except if real, see below). May be left NULL to indicate * that you do not want right eigenvectors. * * * For real A, vr and vl may be either complex or real, at your option. * If you choose to leave them real, you have to pick apart the complex-conjugate * eigenpairs as per the LAPACK documentation. If you choose them complex, * the code will do the picking-apart on your behalf, at the expense of 4*N * extra storage. Only if vr is complex, it will really fulfill its invariant * on exit to the code in all cases, since complex pairs spoil that relation. */ namespace detail { inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, float* a, const int* lda, float* wr, float* wi, float* vl, const int* ldvl, float* vr, const int* ldvr, float* work, const int* lwork) { int info; LAPACK_SGEEV(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, &info); return info; } inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, double* a, const int* lda, double* wr, double* wi, double* vl, const int* ldvl, double* vr, const int* ldvr, double* work, const int* lwork) { int info; LAPACK_DGEEV(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, &info); return info; } inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, traits::complex_f* a, const int* lda, traits::complex_f* w, traits::complex_f* vl, const int* ldvl, traits::complex_f* vr, const int* ldvr, traits::complex_f* work, const int* lwork, float* rwork) { int info; LAPACK_CGEEV(jobvl, jobvr, n, reinterpret_cast(a), lda, reinterpret_cast(w), reinterpret_cast(vl), ldvl, reinterpret_cast(vr), ldvr, reinterpret_cast(work), lwork, rwork, &info); return info; } inline int geev_backend(const char* jobvl, const char* jobvr, const int* n, traits::complex_d* a, const int* lda, traits::complex_d* w, traits::complex_d* vl, const int* ldvl, traits::complex_d* vr, const int* ldvr, traits::complex_d* work, const int* lwork, double* rwork) { int info; LAPACK_ZGEEV(jobvl, jobvr, n, reinterpret_cast(a), lda, reinterpret_cast(w), reinterpret_cast(vl), ldvl, reinterpret_cast(vr), ldvr, reinterpret_cast(work), lwork, rwork, &info); return info; } struct real_case {}; struct mixed_case {}; struct complex_case {}; // real case template int geev(real_case, const char jobvl, const char jobvr, A& a, W& w, V* vl, V *vr) { int const n = traits::matrix_size1(a); typedef typename A::value_type value_type; traits::detail::array wr(n); traits::detail::array wi(n); traits::detail::array vl2(vl ? 0 : n); traits::detail::array vr2(vr ? 0 : n); value_type* vl_real = vl ? traits::matrix_storage(*vl) : vl2.storage(); const int ldvl = vl ? traits::matrix_size2(*vl) : 1; value_type* vr_real = vr ? traits::matrix_storage(*vr) : vr2.storage(); const int ldvr = vr ? traits::matrix_size2(*vr) : 1; // workspace query int lwork = -1; value_type work_temp; int result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl_real, &ldvl, vr_real, &ldvr, &work_temp, &lwork); if (result != 0) return result; lwork = (int) work_temp; traits::detail::array work(lwork); result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl_real, &ldvl, vr_real, &ldvr, work.storage(), &lwork); for (int i = 0; i < n; i++) w[i] = std::complex(wr[i], wi[i]); return result; } // mixed (i.e. real with complex vectors) case template int geev(mixed_case, const char jobvl, const char jobvr, A& a, W& w, V* vl, V *vr) { int const n = traits::matrix_size1(a); typedef typename A::value_type value_type; traits::detail::array wr(n); traits::detail::array wi(n); traits::detail::array vl2(vl ? n*n : n); traits::detail::array vr2(vr ? n*n : n); const int ldvl2 = vl ? n : 1; const int ldvr2 = vr ? n : 1; // workspace query int lwork = -1; value_type work_temp; int result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl2.storage(), &ldvl2, vr2.storage(), &ldvr2, &work_temp, &lwork); if (result != 0) return result; lwork = (int) work_temp; traits::detail::array work(lwork); result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, wr.storage(), wi.storage(), vl2.storage(), &ldvl2, vr2.storage(), &ldvr2, work.storage(), &lwork); typedef typename V::value_type vec_value_type; vec_value_type* vl_stor = NULL; vec_value_type* vr_stor = NULL; int ldvl = 0, ldvr = 0; if (vl) { vl_stor = traits::matrix_storage(*vl); ldvl = traits::matrix_size2(*vl); } if (vr) { vr_stor = traits::matrix_storage(*vr); ldvr = traits::matrix_size2(*vr); } for (int i = 0; i < n; i++) { w[i] = std::complex(wr[i], wi[i]); if (wi[i] != 0) { assert(i+1 < n); assert(wr[i+1] == wr[i]); assert(wi[i+1] == -wi[i+1]); w[i+1] = std::complex(wr[i+1], wi[i+1]); for (int j = 0; j < n; j++) { if (vl) { vl_stor[i*ldvl+j] = std::complex(vl2[i*n+j], vl2[(i+1)*n+j]); vl_stor[(i+1)*ldvl+j] = std::complex(vl2[i*n+j], -vl2[(i+1)*n+j]); } if (vr) { vr_stor[i*ldvr+j] = std::complex(vr2[i*n+j], vr2[(i+1)*n+j]); vr_stor[(i+1)*ldvr+j] = std::complex(vr2[i*n+j], -vr2[(i+1)*n+j]); } } i++; } else { for (int j = 0; j < n; j++) { if (vl) vl_stor[i*ldvl+j] = vl2[i*n+j]; if (vr) vr_stor[i*ldvr+j] = vr2[i*n+j]; } } } return result; } // complex case template int geev(complex_case, const char jobvl, const char jobvr, A& a, W& w, V* vl, V *vr) { typedef typename A::value_type value_type; typedef typename traits::type_traits::real_type real_type; int const n = traits::matrix_size1(a); traits::detail::array rwork(2*n); traits::detail::array vl2(vl ? 0 : n); traits::detail::array vr2(vr ? 0 : n); value_type* vl_real = vl ? traits::matrix_storage(*vl) : vl2.storage(); const int ldvl = vl ? traits::matrix_size2(*vl) : 1; value_type* vr_real = vr ? traits::matrix_storage(*vr) : vr2.storage(); const int ldvr = vr ? traits::matrix_size2(*vr) : 1; // workspace query int lwork = -1; value_type work_temp; int result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, traits::vector_storage(w), vl_real, &ldvl, vr_real, &ldvr, &work_temp, &lwork, rwork.storage()); if (result != 0) return result; lwork = (int) std::real(work_temp); traits::detail::array work(lwork); result = geev_backend(&jobvl, &jobvr, &n, traits::matrix_storage(a), &n, traits::vector_storage(w), vl_real, &ldvl, vr_real, &ldvr, work.storage(), &lwork, rwork.storage()); return result; } } // namespace detail // gateway / dispatch routine template int geev(A& a, W& w, V* vl, V* vr, optimal_workspace) { // input checking #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifndef NDEBUG int const n = traits::matrix_size1(a); #endif assert(traits::matrix_size2(a)==n); assert(traits::vector_size(w)==n); assert(vecttraits::vector_size(w)==n); assert(!vr || traits::matrix_size1(*vr)==n); assert(!vl || traits::matrix_size1(*vl)==n); // preparation typedef typename A::value_type value_type; typedef typename V::value_type vec_value_type; typedef typename traits::type_traits::real_type real_type; // dispatch return detail::geev(typename boost::mpl::if_< boost::is_same, typename boost::mpl::if_< boost::is_same, detail::real_case, detail::mixed_case>::type, detail::complex_case>::type(), vl != 0 ? 'V' : 'N', vr != 0 ? 'V' : 'N', a, w, vl, vr); } } }}} #endif kml_src/boost/numeric/bindings/lapack/geqrf.hpp000644 000765 000024 00000013616 10265665640 022616 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GEQRF_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GEQRF_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // QR factorization of a general m x n matrix A = Q * R // /////////////////////////////////////////////////////////////////// /* * geqrf() computes the QR factorization of a rectangular matrix * A = Q * R, where Q is a M x min(M,N) matrix with orthogonal * and normalized column (i.e. herm(Q) $ Q = I) and R is a * min(M,N) x N upper triangular matrix. * * On return of geqrf, the elements on and above the diagonal of * A contain the min(M,N) x N upper trapezoidal matrix R (R is * upper triangular if m >= n); the elements below the diagonal, * with the array TAU, represent the orthogonal matrix Q as a product * of min(M,N) elementary reflectors. */ namespace detail { inline void geqrf (int const m, int const n, float* a, int const lda, float* tau, float* work, int const lwork, int& info) { LAPACK_SGEQRF (&m, &n, a, &lda, tau, work, &lwork, &info); } inline void geqrf (int const m, int const n, double* a, int const lda, double* tau, double* work, int const lwork, int& info) { LAPACK_DGEQRF (&m, &n, a, &lda, tau, work, &lwork, &info); } inline void geqrf (int const m, int const n, std::complex* a, int const lda, std::complex* tau, std::complex* work, int const lwork, int& info) { LAPACK_CGEQRF (&m, &n, reinterpret_cast (a), &lda, reinterpret_cast (tau), reinterpret_cast (work), &lwork, &info ); } inline void geqrf (int const m, int const n, std::complex* a, int const lda, std::complex* tau, std::complex* work, int const lwork, int& info) { LAPACK_ZGEQRF (&m, &n, reinterpret_cast (a), &lda, reinterpret_cast (tau), reinterpret_cast (work), &lwork, &info ); } } template inline int geqrf (A& a, Tau& tau, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (std::min(m,n) <= traits::vector_size (tau)); assert (n <= traits::vector_size (work)); int info; detail::geqrf (m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (tau), traits::vector_storage (work), traits::vector_size (work), info); return info; } // Computation of the QR factorization. // Workspace is allocated dynamically so that the optimization of // blas 3 calls is optimal. template inline int geqrf (A& a, Tau& tau, optimal_workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); traits::detail::array work(std::max(1, n*32)); return geqrf( a, tau, work ); } // Computation of the QR factorization. // Workspace is allocated dynamically to its minimum size. // Blas 3 calls are not optimal. template inline int geqrf (A& a, Tau& tau, minimal_workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); traits::detail::array work(std::max(1, n)); return geqrf( a, tau, work ); } // Computation of the QR factorization. // Workspace is taken from the array in workspace. // The calling sequence is // geqrf( a, tau, workspace( work ) ) where work is an array with the same value_type // as a. template inline int geqrf (A& a, Tau& tau, detail::workspace1 workspace ) { typedef typename A::value_type value_type ; const int n = traits::matrix_size2 (a); traits::detail::array work(std::max(1, n)); return geqrf( a, tau, workspace.w_ ); } // Function without workarray as argument template inline int geqrf (A& a, Tau& tau) { return geqrf( a, tau, optimal_workspace() ); } } }}} #endif kml_src/boost/numeric/bindings/lapack/gesdd.hpp000644 000765 000024 00000061305 10265665640 022576 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESDD_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GESDD_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // singular value decomposition // /////////////////////////////////////////////////////////////////// /* * (divide and conquer driver) * gesdd() computes the singular value decomposition (SVD) of * M-by-N matrix A, optionally computing the left and/or right * singular vectors, by using divide-and-conquer method. * The SVD is written * * A = U * S * V^T or A = U * S * V^H * * where S is an M-by-N matrix which is zero except for its min(m,n) * diagonal elements, U is an M-by-M orthogonal/unitary matrix, and V * is an N-by-N orthogonal/unitary matrix. The diagonal elements of S * are the singular values of A; they are real and non-negative, and * are returnede in descending order. The first min(m,n) columns of * U and V are the left and right singular vectors of A. (Note that * the routine returns V^T or V^H, not V. */ namespace detail { inline void gesdd (char const jobz, int const m, int const n, float* a, int const lda, float* s, float* u, int const ldu, float* vt, int const ldvt, float* work, int const lwork, float* /* dummy */, int* iwork, int* info) { LAPACK_SGESDD (&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, info); } inline void gesdd (char const jobz, int const m, int const n, double* a, int const lda, double* s, double* u, int const ldu, double* vt, int const ldvt, double* work, int const lwork, double* /* dummy */, int* iwork, int* info) { LAPACK_DGESDD (&jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, info); } inline void gesdd (char const jobz, int const m, int const n, traits::complex_f* a, int const lda, float* s, traits::complex_f* u, int const ldu, traits::complex_f* vt, int const ldvt, traits::complex_f* work, int const lwork, float* rwork, int* iwork, int* info) { LAPACK_CGESDD (&jobz, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, iwork, info); } inline void gesdd (char const jobz, int const m, int const n, traits::complex_d* a, int const lda, double* s, traits::complex_d* u, int const ldu, traits::complex_d* vt, int const ldvt, traits::complex_d* work, int const lwork, double* rwork, int* iwork, int* info) { LAPACK_ZGESDD (&jobz, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, iwork, info); } inline int gesdd_min_work (float, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3 = 3 * minmn; int m4 = 4 * minmn; int minw; if (jobz == 'N') { // leading comments: // LWORK >= 3*min(M,N) + max(max(M,N), 6*min(M,N)) // code: // LWORK >= 3*min(M,N) + max(max(M,N), 7*min(M,N)) int m7 = 7 * minmn; minw = maxmn < m7 ? m7 : maxmn; minw += m3; } if (jobz == 'O') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 5*min(M,N)*min(M,N)+4*min(M,N)) int m5 = 5 * minmn * minmn + m4; minw = maxmn < m5 ? m5 : maxmn; minw += m3 * minmn; } if (jobz == 'S' || jobz == 'A') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 4*min(M,N)*min(M,N)+4*min(M,N)). int m44 = m4 * minmn + m4; minw = maxmn < m44 ? m44 : maxmn; minw += m3 * minmn; } return minw; } inline int gesdd_min_work (double, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3 = 3 * minmn; int m4 = 4 * minmn; int minw; if (jobz == 'N') { // leading comments: // LWORK >= 3*min(M,N) + max(max(M,N), 6*min(M,N)) // code: // LWORK >= 3*min(M,N) + max(max(M,N), 7*min(M,N)) int m7 = 7 * minmn; minw = maxmn < m7 ? m7 : maxmn; minw += m3; } else if (jobz == 'O') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 5*min(M,N)*min(M,N)+4*min(M,N)) int m5 = 5 * minmn * minmn + m4; minw = maxmn < m5 ? m5 : maxmn; minw += m3 * minmn; } else if (jobz == 'S' || jobz == 'A') { // LWORK >= 3*min(M,N)*min(M,N) // + max(max(M,N), 4*min(M,N)*min(M,N)+4*min(M,N)). int m44 = m4 * minmn + m4; minw = maxmn < m44 ? m44 : maxmn; minw += m3 * minmn; } else { std::cerr << "Invalid option passed to gesdd" << std::endl ; return 0 ; } return minw; } inline int gesdd_min_work (traits::complex_f, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m2 = 2 * minmn; int minw = m2 + maxmn; if (jobz == 'N') // LWORK >= 2*min(M,N)+max(M,N) ; if (jobz == 'O') // LWORK >= 2*min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += m2 * minmn; if (jobz == 'S' || jobz == 'A') // LWORK >= min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += minmn * minmn; return minw; } inline int gesdd_min_work (traits::complex_d, char jobz, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m2 = 2 * minmn; int minw = m2 + maxmn; if (jobz == 'N') // LWORK >= 2*min(M,N)+max(M,N) ; if (jobz == 'O') // LWORK >= 2*min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += m2 * minmn; if (jobz == 'S' || jobz == 'A') // LWORK >= min(M,N)*min(M,N) + 2*min(M,N) + max(M,N) minw += minmn * minmn; return minw; } inline int gesdd_rwork (float, char, int, int) { return 1; } inline int gesdd_rwork (double, char, int, int) { return 1; } inline int gesdd_rwork (traits::complex_f, char jobz, int m, int n) { int minmn = m < n ? m : n; int minw; if (jobz == 'N') // LWORK >= 7*min(M,N) minw = 7 * minmn; else // LRWORK >= 5*min(M,N)*min(M,N) + 5*min(M,N) minw = 5 * (minmn * minmn + minmn); return minw; } inline int gesdd_rwork (traits::complex_d, char jobz, int m, int n) { int minmn = m < n ? m : n; int minw; if (jobz == 'N') // LWORK >= 7*min(M,N) minw = 7 * minmn; else // LRWORK >= 5*min(M,N)*min(M,N) + 5*min(M,N) minw = 5 * (minmn * minmn + minmn); return minw; } inline int gesdd_iwork (int m, int n) { int minmn = m < n ? m : n; return 8 * minmn; } } // detail template inline int gesdd_work (char const q, char const jobz, MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (q == 'M'); #else assert (q == 'M' || q == 'O'); #endif assert (jobz == 'N' || jobz == 'O' || jobz == 'A' || jobz == 'S'); int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int lw = -13; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif if (q == 'M') lw = detail::gesdd_min_work (val_t(), jobz, m, n); #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 MatrA& a2 = const_cast (a); if (q == 'O') { // traits::detail::array w (1); val_t w; int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a2), traits::leading_dimension (a2), 0, // traits::vector_storage (s), 0, // traits::matrix_storage (u), m, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), n, // traits::leading_dimension (vt), &w, // traits::vector_storage (w), -1, // traits::vector_size (w), 0, // traits::vector_storage (rw), 0, // traits::vector_storage (iw), &info); assert (info == 0); lw = traits::detail::to_int (w); // // lw = traits::detail::to_int (w[0]); /* * is there a bug in LAPACK? or in Mandrake's .rpm? * if m == 3, n == 4 and jobz == 'N' (real A), * gesdd() returns optimal size == 1 while minimum size == 27 */ // int lwo = traits::detail::to_int (w); // int lwmin = detail::gesdd_min_work (val_t(), jobz, m, n); // lw = lwo < lwmin ? lwmin : lwo; } #endif return lw; } template inline int gesdd_rwork (char jobz, MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (jobz == 'N' || jobz == 'O' || jobz == 'A' || jobz == 'S'); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif return detail::gesdd_rwork (val_t(), jobz, traits::matrix_size1 (a), traits::matrix_size2 (a)); } template inline int gesdd_iwork (MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::gesdd_iwork (traits::matrix_size1 (a), traits::matrix_size2 (a)); } template inline int gesdd (char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w, VecIW& iw) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits::value_type, float >::value || boost::is_same< typename traits::matrix_traits::value_type, double >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert ((jobz == 'N') || ((jobz == 'O' || jobz == 'A') && m >= n) || ((jobz == 'O' || jobz == 'A') && m < n && m == traits::matrix_size2 (u)) || (jobz == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobz == 'N' && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (u) >= m) || (jobz == 'A' && traits::leading_dimension (u) >= m) || (jobz == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobz == 'N' && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (vt) >= n) || (jobz == 'A' && traits::leading_dimension (vt) >= n) || (jobz == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size (w) >= detail::gesdd_min_work (val_t(), jobz, m, n)); assert (traits::vector_size (iw) >= detail::gesdd_iwork (m, n)); int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), 0, // dummy argument traits::vector_storage (iw), &info); return info; } template inline int gesdd (char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w, VecRW& rw, VecIW& iw) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert ((jobz == 'N') || ((jobz == 'O' || jobz == 'A') && m >= n) || ((jobz == 'O' || jobz == 'A') && m < n && m == traits::matrix_size2 (u)) || (jobz == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobz == 'N' && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (u) >= m) || (jobz == 'A' && traits::leading_dimension (u) >= m) || (jobz == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobz == 'N' && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (vt) >= n) || (jobz == 'A' && traits::leading_dimension (vt) >= n) || (jobz == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size (w) >= detail::gesdd_min_work (val_t(), jobz, m, n)); assert (traits::vector_size (rw) >= detail::gesdd_rwork (val_t(), jobz, m, n)); assert (traits::vector_size (iw) >= detail::gesdd_iwork (m, n)); int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), traits::vector_storage (iw), &info); return info; } template inline int gesdd (char const opt, char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); #ifndef NDEBUG int const minmn = m < n ? m : n; #endif // NDEBUG assert (minmn == traits::vector_size (s)); assert ((jobz == 'N') || ((jobz == 'O' || jobz == 'A') && m >= n) || ((jobz == 'O' || jobz == 'A') && m < n && m == traits::matrix_size2 (u)) || (jobz == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobz == 'N' && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (u) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (u) >= m) || (jobz == 'A' && traits::leading_dimension (u) >= m) || (jobz == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobz == 'N' && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m < n && traits::leading_dimension (vt) >= 1) || (jobz == 'O' && m >= n && traits::leading_dimension (vt) >= n) || (jobz == 'A' && traits::leading_dimension (vt) >= n) || (jobz == 'S' && traits::leading_dimension (vt) >= minmn)); #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (opt == 'M'); #else assert (opt == 'M' || opt == 'O'); #endif #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesdd_work (opt, jobz, a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesdd_rwork (jobz, a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int const liw = gesdd_iwork (a); traits::detail::array iw (liw); if (!iw.valid()) return -103; int info; detail::gesdd (jobz, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), lw, //traits::vector_size (w), traits::vector_storage (rw), traits::vector_storage (iw), &info); return info; } #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 template inline int gesdd (char const jobz, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesdd ('O', jobz, a, s, u, vt); } template inline int gesdd (MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesdd ('O', 'S', a, s, u, vt); } template inline int gesdd (MatrA& a, VecS& s) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesdd_work ('O', 'N', a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesdd_rwork ('N', a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int const liw = gesdd_iwork (a); traits::detail::array iw (liw); if (!iw.valid()) return -103; int info; detail::gesdd ('N', m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), 0, // traits::matrix_storage (u), 1, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), 1, // traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), traits::vector_storage (iw), &info); return info; } #endif } // namespace lapack }}} #endif kml_src/boost/numeric/bindings/lapack/gesv.hpp000644 000765 000024 00000023373 10265665640 022457 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GESV_HPP #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // general system of linear equations A * X = B // /////////////////////////////////////////////////////////////////// /* * gesv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS * matrices. * * The LU decomposition with partial pivoting and row interchanges * is used to factor A as A = P * L * U, where P is a permutation * matrix, L is unit lower triangular, and U is upper triangular. * The factored form of A is then used to solve the system of * equations A * X = B. */ namespace detail { inline void gesv (int const n, int const nrhs, float* a, int const lda, int* ipiv, float* b, int const ldb, int* info) { LAPACK_SGESV (&n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void gesv (int const n, int const nrhs, double* a, int const lda, int* ipiv, double* b, int const ldb, int* info) { LAPACK_DGESV (&n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void gesv (int const n, int const nrhs, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CGESV (&n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void gesv (int const n, int const nrhs, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZGESV (&n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int gesv (MatrA& a, IVec& ipiv, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (ipiv)); int info; detail::gesv (n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } template inline int gesv (MatrA& a, MatrB& b) { // with 'internal' pivot vector // gesv() errors: // if (info == 0), successful // if (info < 0), the -info argument had an illegal value // -- we will use -101 if allocation fails // if (info > 0), U(i-1,i-1) is exactly zero int info = -101; traits::detail::array ipiv (traits::matrix_size1 (a)); if (ipiv.valid()) info = gesv (a, ipiv, b); return info; } /* * getrf() computes an LU factorization of a general M-by-N matrix A * using partial pivoting with row interchanges. The factorization * has the form A = P * L * U, where P is a permutation matrix, * L is lower triangular with unit diagonal elements (lower * trapezoidal if M > N), and U is upper triangular (upper * trapezoidal if M < N). */ namespace detail { inline void getrf (int const n, int const m, float* a, int const lda, int* ipiv, int* info) { LAPACK_SGETRF (&n, &m, a, &lda, ipiv, info); } inline void getrf (int const n, int const m, double* a, int const lda, int* ipiv, int* info) { LAPACK_DGETRF (&n, &m, a, &lda, ipiv, info); } inline void getrf (int const n, int const m, traits::complex_f* a, int const lda, int* ipiv, int* info) { LAPACK_CGETRF (&n, &m, traits::complex_ptr (a), &lda, ipiv, info); } inline void getrf (int const n, int const m, traits::complex_d* a, int const lda, int* ipiv, int* info) { LAPACK_ZGETRF (&n, &m, traits::complex_ptr (a), &lda, ipiv, info); } } template inline int getrf (MatrA& a, IVec& ipiv) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); int const m = traits::matrix_size2 (a); assert (traits::vector_size (ipiv) == (m < n ? m : n)); int info; detail::getrf (n, m, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv), &info); return info; } /* * getrs() solves a system of linear equations A * X = B * or A^T * X = B with a general N-by-N matrix A using * the LU factorization computed by getrf(). */ namespace detail { inline void getrs (char const trans, int const n, int const nrhs, float const* a, int const lda, int const* ipiv, float* b, int const ldb, int* info) { LAPACK_SGETRS (&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void getrs (char const trans, int const n, int const nrhs, double const* a, int const lda, int const* ipiv, double* b, int const ldb, int* info) { LAPACK_DGETRS (&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void getrs (char const trans, int const n, int const nrhs, traits::complex_f const* a, int const lda, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CGETRS (&trans, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void getrs (char const trans, int const n, int const nrhs, traits::complex_d const* a, int const lda, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZGETRS (&trans, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int getrs (char const trans, MatrA const& a, IVec const& ipiv, MatrB& b) { assert (trans == 'N' || trans == 'T' || trans == 'C'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (ipiv)); int info; detail::getrs (trans, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (ipiv), #else traits::vector_storage_const (ipiv), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } template inline int getrs (MatrA const& a, IVec const& ipiv, MatrB& b) { char const no_transpose = 'N'; return getrs (no_transpose, a, ipiv, b); } // TO DO: getri() } }}} #endif kml_src/boost/numeric/bindings/lapack/gesvd.hpp000644 000765 000024 00000045705 10265665640 022626 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_GESVD_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_GESVD_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // singular value decomposition // /////////////////////////////////////////////////////////////////// /* * (simple driver) * gesvd() computes the singular value decomposition (SVD) of * M-by-N matrix A, optionally computing the left and/or right * singular vectors. The SVD is written * * A = U * S * V^T or A = U * S * V^H * * where S is an M-by-N matrix which is zero except for its min(m,n) * diagonal elements, U is an M-by-M orthogonal/unitary matrix, and V * is an N-by-N orthogonal/unitary matrix. The diagonal elements of S * are the singular values of A; they are real and non-negative, and * are returnede in descending order. The first min(m,n) columns of * U and V are the left and right singular vectors of A. (Note that * the routine returns V^T or V^H, not V. */ namespace detail { inline void gesvd (char const jobu, char const jobvt, int const m, int const n, float* a, int const lda, float* s, float* u, int const ldu, float* vt, int const ldvt, float* work, int const lwork, float* /* dummy */, int* info) { LAPACK_SGESVD (&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, info); } inline void gesvd (char const jobu, char const jobvt, int const m, int const n, double* a, int const lda, double* s, double* u, int const ldu, double* vt, int const ldvt, double* work, int const lwork, double* /* dummy */, int* info) { LAPACK_DGESVD (&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, info); } inline void gesvd (char const jobu, char const jobvt, int const m, int const n, traits::complex_f* a, int const lda, float* s, traits::complex_f* u, int const ldu, traits::complex_f* vt, int const ldvt, traits::complex_f* work, int const lwork, float* rwork, int* info) { LAPACK_CGESVD (&jobu, &jobvt, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, info); } inline void gesvd (char const jobu, char const jobvt, int const m, int const n, traits::complex_d* a, int const lda, double* s, traits::complex_d* u, int const ldu, traits::complex_d* vt, int const ldvt, traits::complex_d* work, int const lwork, double* rwork, int* info) { LAPACK_ZGESVD (&jobu, &jobvt, &m, &n, traits::complex_ptr (a), &lda, s, traits::complex_ptr (u), &ldu, traits::complex_ptr (vt), &ldvt, traits::complex_ptr (work), &lwork, rwork, info); } inline int gesvd_min_work (float, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3x = 3 * minmn + maxmn; int m5 = 5 * minmn; return m3x < m5 ? m5 : m3x; } inline int gesvd_min_work (double, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; int m3x = 3 * minmn + maxmn; int m5 = 5 * minmn; return m3x < m5 ? m5 : m3x; } inline int gesvd_min_work (traits::complex_f, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; return 2 * minmn + maxmn; } inline int gesvd_min_work (traits::complex_d, int m, int n) { int minmn = m < n ? m : n; int maxmn = m < n ? n : m; return 2 * minmn + maxmn; } inline int gesvd_rwork (float, int, int) { return 1; } inline int gesvd_rwork (double, int, int) { return 1; } inline int gesvd_rwork (traits::complex_f, int m, int n) { return 5 * (m < n ? m : n); } inline int gesvd_rwork (traits::complex_d, int m, int n) { return 5 * (m < n ? m : n); } } // detail template inline int gesvd_work (char const q, char const jobu, char const jobvt, MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (q == 'M'); #else assert (q == 'M' || q == 'O'); #endif assert (jobu == 'N' || jobu == 'O' || jobu == 'A' || jobu == 'S'); assert (jobvt == 'N' || jobvt == 'O' || jobvt == 'A' || jobvt == 'S'); assert (!(jobu == 'O' && jobvt == 'O')); int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int lw = -13; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif if (q == 'M') lw = detail::gesvd_min_work (val_t(), m, n); #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 MatrA& a2 = const_cast (a); if (q == 'O') { // traits::detail::array w (0); val_t w; int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a2), traits::leading_dimension (a2), 0, // traits::vector_storage (s), 0, // traits::matrix_storage (u), m, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), n, // traits::leading_dimension (vt), &w, // traits::vector_storage (w), -1, // traits::vector_size (w), 0, // traits::vector_storage (rw), &info); assert (info == 0); lw = traits::detail::to_int (w); // (w[0]); } #endif return lw; } template inline int gesvd_rwork (MatrA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif return detail::gesvd_rwork (val_t(), traits::matrix_size1 (a), traits::matrix_size2 (a)); } template inline int gesvd (char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT( (boost::is_same< typename traits::matrix_traits::value_type, float >::value || boost::is_same< typename traits::matrix_traits::value_type, double >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); assert ((jobu == 'N') || (jobu == 'O') || (jobu == 'A' && m == traits::matrix_size2 (u)) || (jobu == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobu == 'N' && traits::leading_dimension (u) >= 1) || (jobu == 'O' && traits::leading_dimension (u) >= 1) || (jobu == 'A' && traits::leading_dimension (u) >= m) || (jobu == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobvt == 'N' && traits::leading_dimension (vt) >= 1) || (jobvt == 'O' && traits::leading_dimension (vt) >= 1) || (jobvt == 'A' && traits::leading_dimension (vt) >= n) || (jobvt == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size(w) >= detail::gesvd_min_work(val_t(),m,n)); int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), 0, // dummy argument &info); return info; } template inline int gesvd (char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt, VecW& w, VecRW& rw) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); assert ((jobu == 'N') || (jobu == 'O') || (jobu == 'A' && m == traits::matrix_size2 (u)) || (jobu == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobu == 'N' && traits::leading_dimension (u) >= 1) || (jobu == 'O' && traits::leading_dimension (u) >= 1) || (jobu == 'A' && traits::leading_dimension (u) >= m) || (jobu == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobvt == 'N' && traits::leading_dimension (vt) >= 1) || (jobvt == 'O' && traits::leading_dimension (vt) >= 1) || (jobvt == 'A' && traits::leading_dimension (vt) >= n) || (jobvt == 'S' && traits::leading_dimension (vt) >= minmn)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif assert (traits::vector_size(w) >= detail::gesvd_min_work(val_t(),m,n)); assert (traits::vector_size(rw) >= detail::gesvd_rwork(val_t(),m,n)); int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), &info); return info; } template inline int gesvd (char const opt, char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); assert (!(jobu == 'O' && jobvt == 'O')); assert ((jobu == 'N') || (jobu == 'O') || (jobu == 'A' && m == traits::matrix_size2 (u)) || (jobu == 'S' && minmn == traits::matrix_size2 (u))); assert ((jobu == 'N' && traits::leading_dimension (u) >= 1) || (jobu == 'O' && traits::leading_dimension (u) >= 1) || (jobu == 'A' && traits::leading_dimension (u) >= m) || (jobu == 'S' && traits::leading_dimension (u) >= m)); assert (n == traits::matrix_size2 (vt)); assert ((jobvt == 'N' && traits::leading_dimension (vt) >= 1) || (jobvt == 'O' && traits::leading_dimension (vt) >= 1) || (jobvt == 'A' && traits::leading_dimension (vt) >= n) || (jobvt == 'S' && traits::leading_dimension (vt) >= minmn)); #ifdef BOOST_NUMERIC_BINDINGS_LAPACK_2 assert (opt == 'M'); #else assert (opt == 'M' || opt == 'O'); #endif #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesvd_work (opt, jobu, jobvt, a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesvd_rwork (a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int info; detail::gesvd (jobu, jobvt, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), traits::matrix_storage (u), traits::leading_dimension (u), traits::matrix_storage (vt), traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), &info); return info; } #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_2 template inline int gesvd (char const jobu, char const jobvt, MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesvd ('O', jobu, jobvt, a, s, u, vt); } template inline int gesvd (MatrA& a, VecS& s, MatrU& u, MatrV& vt) { return gesvd ('O', 'S', 'S', a, s, u, vt); } template inline int gesvd (MatrA& a, VecS& s) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); int const minmn = m < n ? m : n; assert (minmn == traits::vector_size (s)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrA::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; int const lw = gesvd_work ('O', 'N', 'N', a); traits::detail::array w (lw); if (!w.valid()) return -101; int const lrw = gesvd_rwork (a); traits::detail::array rw (lrw); if (!rw.valid()) return -102; int info; detail::gesvd ('N', 'N', m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (s), 0, // traits::matrix_storage (u), 1, // traits::leading_dimension (u), 0, // traits::matrix_storage (vt), 1, // traits::leading_dimension (vt), traits::vector_storage (w), traits::vector_size (w), traits::vector_storage (rw), &info); return info; } #endif } // namespace lapack }}} #endif kml_src/boost/numeric/bindings/lapack/hbev.hpp000644 000765 000024 00000027130 10265665640 022432 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HBEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HBEV_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a banded Hermitian matrix. // /////////////////////////////////////////////////////////////////// /* * hbev() computes the eigenvalues and optionally the associated * eigenvectors of a banded Hermitian matrix A. A matrix is Hermitian * when herm( A ) == A. When A is real, a Hermitian matrix is also * called symmetric. * * The eigen decomposition is A = U S * herm(U) where U is a * unitary matrix and S is a diagonal matrix. The eigenvalues of A * are on the main diagonal of S. The eigenvalues are real. * * Workspace is organized following the arguments in the calling sequence. * optimal_workspace() : for optimizing use of blas 3 kernels * minimal_workspace() : minimum size of workarrays, but does not allow for optimization * of blas 3 kernels * workspace( work ) for real matrices where work is a real array with * vector_size( work ) >= 3*matrix_size1( a ) - 2 * workspace( work, rwork ) for complex matrices where work is a complex * array with vector_size( work ) >= matrix_size1( a ) * and rwork is a real array with * vector_size( rwork ) >= 3 * matrix_size1( a ) - 2. */ /* * If uplo=='L' only the lower triangular part is stored. * If uplo=='U' only the upper triangular part is stored. * * The matrix is assumed to be stored in LAPACK band format, i.e. * matrices are stored columnwise, in a compressed format so that when e.g. uplo=='U' * the (i,j) element with j>=i is in position (i-j) + j * (KD+1) + KD where KD is the * half bandwidth of the matrix. For a triadiagonal matrix, KD=1, for a diagonal matrix * KD=0. * When uplo=='L', the (i,j) element with j>=i is in position (i-j) + j * (KD+1). * * The matrix A is thus a rectangular matrix with KD+1 rows and N columns. */ namespace detail { inline void hbev (char const jobz, char const uplo, int const n, int const kd, float* ab, int const ldab, float* w, float* z, int const ldz, float* work, int& info) { //for (int i=0; i struct Hbev{}; /// Handling of workspace in the case of one workarray. template <> struct Hbev< 1 > { template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, minimal_workspace , int& info ) const { traits::detail::array work( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, optimal_workspace , int& info ) const { traits::detail::array work( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, detail::workspace1 work, int& info ) const { assert( traits::vector_size( work.w_ ) >= 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work.w_ ), info ); } }; // Hbev< 1 > /// Handling of workspace in the case of two workarrays. template <> struct Hbev< 2 > { template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, minimal_workspace , int& info ) const { traits::detail::array work( n ); traits::detail::array rwork( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), traits::vector_storage( rwork ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, optimal_workspace , int& info ) const { traits::detail::array work( n ); traits::detail::array rwork( 3*n-2 ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work ), traits::vector_storage( rwork ), info ); } template void operator() (char const jobz, char const uplo, int const n, int const kd, T* ab, int const ldab, R* w, T* z, int const ldz, detail::workspace2 work, int& info ) const { assert( traits::vector_size( work.wr_ ) >= 3*n-2 ); assert( traits::vector_size( work.w_ ) >= n ); hbev( jobz, uplo, n, kd, ab, ldab, w, z, ldz, traits::vector_storage( work.w_ ), traits::vector_storage( work.wr_ ), info ); } }; // Hbev< 2 > /// Compute eigendecomposition of the banded Hermitian matrix ab. /// if jobz=='N' only the eigenvalues are computed. /// if jobz=='V' compute the eigenvalues a and the eigenvectors. /// /// Workspace is organized following the arguments in the calling sequence. /// optimal_workspace() : for optimizing use of blas 3 kernels /// minimal_workspace() : minimum size of workarrays, but does not allow for optimization /// of blas 3 kernels /// workspace( work ) for real matrices where work is a real array with /// vector_size( work ) >= 3*matrix_size1( a )-2 /// workspace( work, rwork ) for complex matrices where work is a complex /// array with vector_size( work ) >= matrix_size1( a ) /// and rwork is a real array with /// vector_size( rwork ) >= 3*matrix_size1( a )-2. template int hbev( char const jobz, AB& ab, W& w, Z& z, Work work ) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif typedef typename AB::value_type value_type ; int const n = traits::matrix_size2 (ab); assert (n == traits::matrix_size1 (z)); assert (n == traits::vector_size (w)); assert ( jobz=='N' || jobz=='V' ); int info ; detail::Hbev< n_workspace_args::value >() (jobz, traits::matrix_uplo_tag( ab ), n, traits::matrix_upper_bandwidth(ab), traits::matrix_storage (ab), traits::leading_dimension (ab), traits::vector_storage (w), traits::matrix_storage (z), traits::leading_dimension (z), work, info); return info ; } // hbev() } // namespace detail /// Compute eigendecomposition without eigenvectors template inline int hbev (AB& ab, W& w, Work work) { return detail::hbev( 'N', ab, w, ab, work ); } // hbev() /// Compute eigendecomposition with eigenvectors template inline int hbev (AB& ab, W& w, Z& z, Work work) { BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); int const n = traits::matrix_size2 (ab); assert (n == traits::matrix_size1 (z)); assert (n == traits::matrix_size2 (z)); return detail::hbev( 'V', ab, w, z, work ); } // hbev() } }}} #endif kml_src/boost/numeric/bindings/lapack/heev.hpp000644 000765 000024 00000013224 10265665640 022434 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HEEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HEEV_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a complex Hermitian matrix A = Q * D * Q' // /////////////////////////////////////////////////////////////////// /* * heev() computes the eigendecomposition of a N x N matrix * A = Q * D * Q', where Q is a N x N unitary matrix and * D is a diagonal matrix. The diagonal element D(i,i) is an * eigenvalue of A and Q(:,i) is a corresponding eigenvector. * The eigenvalues are stored in ascending order. * * On return of heev, A is overwritten by Q and w contains the main * diagonal of D. * * int heev (char jobz, char uplo, A& a, W& w, minimal_workspace ) ; * jobz : 'V' : compute eigenvectors * 'N' : do not compute eigenvectors * uplo : 'U' : only the upper triangular part of A is used on input. * 'L' : only the lower triangular part of A is used on input. */ namespace detail { inline void heev (char const jobz, char const uplo, int const n, traits::complex_f* a, int const lda, float* w, traits::complex_f* work, int const lwork, float* rwork, int& info) { LAPACK_CHEEV (&jobz, &uplo, &n, reinterpret_cast(a), &lda, w, reinterpret_cast(work), &lwork, rwork, &info); } inline void heev (char const jobz, char const uplo, int const n, traits::complex_d* a, int const lda, double* w, traits::complex_d* work, int const lwork, double* rwork, int& info) { LAPACK_ZHEEV (&jobz, &uplo, &n, reinterpret_cast(a), &lda, w, reinterpret_cast(work), &lwork, rwork, &info); } template inline int heev (char jobz, char uplo, A& a, W& w, Work& work, RWork& rwork) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (traits::matrix_size2 (a)==n); assert (traits::vector_size (w)==n); assert (2*n-1 <= traits::vector_size (work)); assert (3*n-2 <= traits::vector_size (rwork)); assert ( uplo=='U' || uplo=='L' ); assert ( jobz=='N' || jobz=='V' ); int info; detail::heev (jobz, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (w), traits::vector_storage (work), traits::vector_size (work), traits::vector_storage (rwork), info); return info; } } // namespace detail // Function that allocates temporary arrays template int heev (char jobz, char uplo, A& a, W& w, minimal_workspace ) { typedef typename A::value_type value_type ; typedef typename traits::type_traits::real_type real_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,2*n-1) ); traits::detail::array rwork( std::max(3*n-1,1) ); return detail::heev( jobz, uplo, a, w, work, rwork ); } // Function that allocates temporary arrays template int heev (char jobz, char uplo, A& a, W& w, optimal_workspace ) { typedef typename A::value_type value_type ; typedef typename traits::type_traits::real_type real_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,33*n) ); traits::detail::array rwork( std::max(3*n-1,1) ); return detail::heev( jobz, uplo, a, w, work, rwork ); } // Function that uses given workarrays template int heev (char jobz, char uplo, A& a, W& w, detail::workspace2 workspace ) { typedef typename A::value_type value_type ; typedef typename traits::type_traits::real_type real_type ; return detail::heev( jobz, uplo, a, w, workspace.w_, workspace.wr_ ); } } }}} #endif kml_src/boost/numeric/bindings/lapack/hesv.hpp000644 000765 000024 00000045166 10265665640 022464 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HESV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HESV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A Hermitian indefinite matrix // ///////////////////////////////////////////////////////////////////// namespace detail { inline int hetrf_block (traits::complex_f, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "CHETRF", ul2, n); } inline int hetrf_block (traits::complex_d, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "ZHETRF", ul2, n); } } template inline int hetrf_block (char const q, char const ul, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::hetrf_block (val_t(), ispec, ul, n); } template inline int hetrf_block (char const q, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::hetrf_block (val_t(), ispec, ul, n); } template inline int hetrf_work (char const q, char const ul, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::hetrf_block (val_t(), 1, ul, n); return lw; } template inline int hetrf_work (char const q, HermA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::hetrf_block (val_t(), 1, ul, n); return lw; } template inline int hesv_work (char const q, char const ul, HermA const& a) { return hetrf_work (q, ul, a); } template inline int hesv_work (char const q, HermA const& a) { return hetrf_work (q, a); } /* * hesv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N Hermitian matrix and X and B * are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^H, if UPLO = 'U', * A = L * D * L^H, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is Hermitian and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored * form of A is then used to solve the system of equations A * X = B. */ namespace detail { inline void hesv (char const uplo, int const n, int const nrhs, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* b, int const ldb, traits::complex_f* w, int const lw, int* info) { LAPACK_CHESV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } inline void hesv (char const uplo, int const n, int const nrhs, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* b, int const ldb, traits::complex_d* w, int const lw, int* info) { LAPACK_ZHESV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } template inline int hesv (char const ul, HermA& a, IVec& i, MatrB& b, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; hesv (ul, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int hesv (char const ul, HermA& a, IVec& i, MatrB& b, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); return detail::hesv (ul, a, i, b, w); } template inline int hesv (HermA& a, IVec& i, MatrB& b, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::hesv (uplo, a, i, b, w); } template inline int hesv (char const ul, HermA& a, MatrB& b) { // with 'internal' pivot and work vectors assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = hetrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::hesv (ul, a, i, b, w); } return info; } template inline int hesv (HermA& a, MatrB& b) { // with 'internal' pivot and work vectors #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); char uplo = traits::matrix_uplo_tag (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = hetrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); w.resize (lw); if (w.valid()) info = detail::hesv (uplo, a, i, b, w); } return info; } /* * hetrf() computes the factorization of a Hermitian matrix A using * the Bunch-Kaufman diagonal pivoting method. The form of the * factorization is * A = U * D * U^H or A = L * D * L^H * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is Hermitian and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void hetrf (char const uplo, int const n, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* w, int const lw, int* info) { LAPACK_CHETRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } inline void hetrf (char const uplo, int const n, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* w, int const lw, int* info) { LAPACK_ZHETRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } template inline int hetrf (char const ul, HermA& a, IVec& i, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); int info; hetrf (ul, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int hetrf (char const ul, HermA& a, IVec& i, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); return detail::hetrf (ul, a, i, w); } template inline int hetrf (HermA& a, IVec& i, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const lw = traits::vector_size (w); assert (lw >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::hetrf (uplo, a, i, w); } template inline int hetrf (char const ul, HermA& a, Ivec& i) { // with 'internal' work vector assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int info = -101; int lw = hetrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::hetrf (ul, a, i, w); return info; } template inline int hetrf (HermA& a, Ivec& i) { // with 'internal' work vector #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); int info = -101; int lw = hetrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::hetrf (uplo, a, i, w); return info; } /* * hetrs() solves a system of linear equations A*X = B with * a Hermitian matrix A using the factorization * A = U * D * U^H or A = L * D * L^H * computed by hetrf(). */ namespace detail { inline void hetrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const lda, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CHETRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void hetrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const lda, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZHETRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } template inline int hetrs (char const ul, HermA const& a, IVec const& i, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; hetrs (ul, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (i), #else traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int hetrs (char const ul, HermA const& a, IVec const& i, MatrB& b) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::hetrs (ul, a, i, b); } template inline int hetrs (HermA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::hetrs (uplo, a, i, b); } // TO DO: hetri } }}} #endif kml_src/boost/numeric/bindings/lapack/hpsv.hpp000644 000765 000024 00000020263 10265665640 022466 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_HPSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_HPSV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A Hermitian indefinite matrix stored in packed format // ///////////////////////////////////////////////////////////////////// /* * hpsv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N Hermitian matrix in packed * storage and X and B are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^H, if UPLO = 'U', * A = L * D * L^H, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is Hermitian and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored * form of A is then used to solve the system of equations A * X = B. */ namespace detail { inline void hpsv (char const uplo, int const n, int const nrhs, traits::complex_f* ap, int* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CHPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } inline void hpsv (char const uplo, int const n, int const nrhs, traits::complex_d* ap, int* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZHPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } template inline int hpsv (HermA& a, IVec& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; hpsv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int hpsv (HermA& a, IVec& i, MatrB& b) { assert (traits::matrix_size1 (a) == traits::vector_size (i)); return detail::hpsv (a, i, b); } template inline int hpsv (HermA& a, MatrB& b) { // with 'internal' pivot vector int info = -101; traits::detail::array i (traits::matrix_size1 (a)); if (i.valid()) info = detail::hpsv (a, i, b); return info; } /* * hptrf() computes the factorization of a Hermitian matrix A * in packed storage using the Bunch-Kaufman diagonal pivoting * method. The form of the factorization is * A = U * D * U^H or A = L * D * L^H * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is Hermitian and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void hptrf (char const uplo, int const n, traits::complex_f* ap, int* ipiv, int* info) { LAPACK_CHPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } inline void hptrf (char const uplo, int const n, traits::complex_d* ap, int* ipiv, int* info) { LAPACK_ZHPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } template inline int hptrf (char const ul, HermA& a, IVec& i, Work& w, int const lw) { } } template inline int hptrf (HermA& a, IVec& i) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::hptrf (uplo, n, traits::matrix_storage (a), traits::vector_storage (i), &info); return info; } /* * hptrs() solves a system of linear equations A*X = B with * a Hermitian matrix A in packed storage using the factorization * A = U * D * U^H or A = L * D * L^H * computed by hptrf(). */ namespace detail { inline void hptrs (char const uplo, int const n, int const nrhs, traits::complex_f const* ap, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CHPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } inline void hptrs (char const uplo, int const n, int const nrhs, traits::complex_d const* ap, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZHPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int hptrs (HermA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::hptrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (i), #else traits::matrix_storage_const (a), traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } // TO DO: hptri } }}} #endif kml_src/boost/numeric/bindings/lapack/ilaenv.hpp000644 000765 000024 00000002406 10265665640 022763 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen, Kresimir Fresl and Matthias Troyer 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * 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 int ilaenv (int const ispec, const char* name, const char* opts, int const n1 = -1, int const n2 = -1, int const n3 = -1, int const n4 = -1) { return ::LAPACK_ILAENV (&ispec, name, opts, &n1, &n2, &n3, &n4, std::strlen (name), std::strlen (opts)); } }}}} #endif kml_src/boost/numeric/bindings/lapack/lapack.h000644 000765 000024 00000062452 10265665640 022407 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H #define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # define BOOST_NUMERIC_BINDINGS_FORTRAN #endif extern "C" { /********************************************************************/ /* linear systems */ /********************************************************************/ /* general */ void LAPACK_SGESV (int const* n, int const* nrhs, float* a, int const* lda, int* ipiv, float* b, int const* ldb, int* info); void LAPACK_DGESV (int const* n, int const* nrhs, double* a, int const* lda, int* ipiv, double* b, int const* ldb, int* info); void LAPACK_CGESV (int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZGESV (int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SGETRF (int const* n, int const* nrhs, float* a, int const* lda, int* ipiv, int* info); void LAPACK_DGETRF (int const* n, int const* nrhs, double* a, int const* lda, int* ipiv, int* info); void LAPACK_CGETRF (int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, int* info); void LAPACK_ZGETRF (int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, int* info); void LAPACK_SGETRS (char const* trans, int const* n, int const* nrhs, float const* a, int const* lda, int const* ipiv, float* b, int const* ldb, int* info); void LAPACK_DGETRS (char const* trans, int const* n, int const* nrhs, double const* a, int const* lda, int const* ipiv, double* b, int const* ldb, int* info); void LAPACK_CGETRS (char const* trans, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZGETRS (char const* trans, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian positive definite */ void LAPACK_SPOSV (char const* uplo, int const* n, int const* nrhs, float* a, int const* lda, float* b, int const* ldb, int* info); void LAPACK_DPOSV (char const* uplo, int const* n, int const* nrhs, double* a, int const* lda, double* b, int const* ldb, int* info); void LAPACK_CPOSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* a, int const* lda, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPOSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* a, int const* lda, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SPOTRF (char const* uplo, int const* n, float* a, int const* lda, int* info); void LAPACK_DPOTRF (char const* uplo, int const* n, double* a, int const* lda, int* info); void LAPACK_CPOTRF (char const* uplo, int const* n, fcomplex_t* a, int const* lda, int* info); void LAPACK_ZPOTRF (char const* uplo, int const* n, dcomplex_t* a, int const* lda, int* info); void LAPACK_SPOTRS (char const* uplo, int const* n, int const* nrhs, float const* a, int const* lda, float* b, int const* ldb, int* info); void LAPACK_DPOTRS (char const* uplo, int const* n, int const* nrhs, double const* a, int const* lda, double* b, int const* ldb, int* info); void LAPACK_CPOTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPOTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian positive definite in packed storage */ void LAPACK_SPPSV (char const* uplo, int const* n, int const* nrhs, float* ap, float* b, int const* ldb, int* info); void LAPACK_DPPSV (char const* uplo, int const* n, int const* nrhs, double* ap, double* b, int const* ldb, int* info); void LAPACK_CPPSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* ap, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPPSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* ap, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SPPTRF (char const* uplo, int const* n, float* ap, int* info); void LAPACK_DPPTRF (char const* uplo, int const* n, double* ap, int* info); void LAPACK_CPPTRF (char const* uplo, int const* n, fcomplex_t* ap, int* info); void LAPACK_ZPPTRF (char const* uplo, int const* n, dcomplex_t* ap, int* info); void LAPACK_SPPTRS (char const* uplo, int const* n, int const* nrhs, float const* ap, float* b, int const* ldb, int* info); void LAPACK_DPPTRS (char const* uplo, int const* n, int const* nrhs, double const* ap, double* b, int const* ldb, int* info); void LAPACK_CPPTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* ap, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZPPTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* ap, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian indefinite and complex symmetric */ void LAPACK_SSYSV (char const* uplo, int const* n, int const* nrhs, float* a, int const* lda, int* ipiv, float* b, int const* ldb, float* w, int const* lw, int* info); void LAPACK_DSYSV (char const* uplo, int const* n, int const* nrhs, double* a, int const* lda, int* ipiv, double* b, int const* ldb, double* w, int const* lw, int* info); void LAPACK_CSYSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* b, int const* ldb, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZSYSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* b, int const* ldb, dcomplex_t* w, int const* lw, int* info); void LAPACK_CHESV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* b, int const* ldb, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZHESV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* b, int const* ldb, dcomplex_t* w, int const* lw, int* info); void LAPACK_SSYTRF (char const* uplo, int const* n, float* a, int const* lda, int* ipiv, float* w, int const* lw, int* info); void LAPACK_DSYTRF (char const* uplo, int const* n, double* a, int const* lda, int* ipiv, double* w, int const* lw, int* info); void LAPACK_CSYTRF (char const* uplo, int const* n, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZSYTRF (char const* uplo, int const* n, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* w, int const* lw, int* info); void LAPACK_CHETRF (char const* uplo, int const* n, fcomplex_t* a, int const* lda, int* ipiv, fcomplex_t* w, int const* lw, int* info); void LAPACK_ZHETRF (char const* uplo, int const* n, dcomplex_t* a, int const* lda, int* ipiv, dcomplex_t* w, int const* lw, int* info); void LAPACK_SSYTRS (char const* uplo, int const* n, int const* nrhs, float const* a, int const* lda, int const* ipiv, float* b, int const* ldb, int* info); void LAPACK_DSYTRS (char const* uplo, int const* n, int const* nrhs, double const* a, int const* lda, int const* ipiv, double* b, int const* ldb, int* info); void LAPACK_CSYTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZSYTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_CHETRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* a, int const* lda, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZHETRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* a, int const* lda, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); /* symmetric/Hermitian indefinite and complex symmetric in packed storage */ void LAPACK_SSPSV (char const* uplo, int const* n, int const* nrhs, float* ap, int* ipiv, float* b, int const* ldb, int* info); void LAPACK_DSPSV (char const* uplo, int const* n, int const* nrhs, double* ap, int* ipiv, double* b, int const* ldb, int* info); void LAPACK_CSPSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* ap, int* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZSPSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* ap, int* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_CHPSV (char const* uplo, int const* n, int const* nrhs, fcomplex_t* ap, int* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZHPSV (char const* uplo, int const* n, int const* nrhs, dcomplex_t* ap, int* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_SSPTRF (char const* uplo, int const* n, float* ap, int* ipiv, int* info); void LAPACK_DSPTRF (char const* uplo, int const* n, double* ap, int* ipiv, int* info); void LAPACK_CSPTRF (char const* uplo, int const* n, fcomplex_t* ap, int* ipiv, int* info); void LAPACK_ZSPTRF (char const* uplo, int const* n, dcomplex_t* ap, int* ipiv, int* info); void LAPACK_CHPTRF (char const* uplo, int const* n, fcomplex_t* ap, int* ipiv, int* info); void LAPACK_ZHPTRF (char const* uplo, int const* n, dcomplex_t* ap, int* ipiv, int* info); void LAPACK_SSPTRS (char const* uplo, int const* n, int const* nrhs, float const* ap, int const* ipiv, float* b, int const* ldb, int* info); void LAPACK_DSPTRS (char const* uplo, int const* n, int const* nrhs, double const* ap, int const* ipiv, double* b, int const* ldb, int* info); void LAPACK_CSPTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* ap, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZSPTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* ap, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); void LAPACK_CHPTRS (char const* uplo, int const* n, int const* nrhs, fcomplex_t const* ap, int const* ipiv, fcomplex_t* b, int const* ldb, int* info); void LAPACK_ZHPTRS (char const* uplo, int const* n, int const* nrhs, dcomplex_t const* ap, int const* ipiv, dcomplex_t* b, int const* ldb, int* info); /**********************************************************************/ /* eigenproblems */ /**********************************************************************/ void LAPACK_SGEES (const char* jobvs, const char* sort, logical_t* select, const int* n, float* a, const int * lda, const int* sdim, float* wr, float* wi, float* vs, const int * ldvs, float* work, const int * lwork, bool* bwork, int* info); void LAPACK_DGEES (const char* jobvs, const char* sort, logical_t* select, const int* n, double* a, const int * lda, const int* sdim, double* wr, double* wi, double* vs, const int * ldvs, double* work, const int * lwork, bool* bwork, int* info); void LAPACK_CGEES( const char* jobvs, const char* sort, logical_t* select, const int *n, fcomplex_t* a, const int * lda, int * sdim, fcomplex_t* w, fcomplex_t* vs, const int * ldvs, fcomplex_t* work, const int * lwork, float* rwork, bool* bwork, int* info ); void LAPACK_ZGEES( const char* jobvs, const char* sort, const logical_t* select, const int *n, dcomplex_t* a, const int * lda, int * sdim, dcomplex_t* w, dcomplex_t* vs, const int * ldvs, dcomplex_t* work, const int * lwork, double* rwork, bool* bwork, int* info ); void LAPACK_SGEEV( const char* jobvl, const char* jobvr, const int* n, float* a, const int* lda, float* wr, float* wi, float* vl, const int* ldvl, float* vr, const int* ldvr, float* work, const int* lwork, int* info ); void LAPACK_DGEEV( const char* jobvl, const char* jobvr, const int* n, double* a, const int* lda, double* wr, double* wi, double* vl, const int* ldvl, double* vr, const int* ldvr, double* work, const int* lwork, int* info ); void LAPACK_CGEEV( const char* jobvl, const char* jobvr, const int* n, fcomplex_t* a, const int* lda, fcomplex_t* w, fcomplex_t* vl, const int* ldvl, fcomplex_t* vr, const int* ldvr, fcomplex_t* work, const int* lwork, float* rwork, int* info ); void LAPACK_ZGEEV( const char* jobvl, const char* jobvr, const int* n, dcomplex_t* a, const int* lda, dcomplex_t* w, dcomplex_t* vl, const int* ldvl, dcomplex_t* vr, const int* ldvr, dcomplex_t* work, const int* lwork, double* rwork, int* info ); void LAPACK_SSYEV( const char* jobz, const char* uplo, const int *n, float* a, const int * lda, float* w, float* work, const int * lwork, int* info ); void LAPACK_DSYEV( const char* jobz, const char* uplo, const int *n, double* a, const int * lda, double* w, double* work, const int * lwork, int* info ); void LAPACK_CHEEV( const char* jobz, const char* uplo, const int *n, fcomplex_t* a, const int * lda, float* w, fcomplex_t* work, const int * lwork, float* rwork, int* info ); void LAPACK_ZHEEV( const char* jobz, const char* uplo, const int *n, dcomplex_t* a, const int * lda, double* w, dcomplex_t* work, const int * lwork, double* rwork, int* info ); void LAPACK_CTREVC( const char* side, const char* howmny, const logical_t* select, const int *n, fcomplex_t* t, const int * ldt, fcomplex_t* vl, const int* ldvl, fcomplex_t* vr, const int * ldvr, const int * nm, int* m, fcomplex_t* work, float* rwork, int* info ); void LAPACK_ZTREVC( const char* side, const char* howmny, const logical_t* select, const int *n, dcomplex_t* t, const int * ldt, dcomplex_t* vl, const int* ldvl, dcomplex_t* vr, const int * ldvr, const int * nm, int* m, dcomplex_t* work, double* rwork, int* info ); void LAPACK_STREVC( const char* side, const char* howmny, const logical_t* select, const int *n, float* t, const int * ldt, float* vl, const int* ldvl, float* vr, const int * ldvr, const int * nm, int* m, float* work, int* info ); void LAPACK_DTREVC( const char* side, const char* howmny, const logical_t* select, const int *n, double* t, const int * ldt, double* vl, const int* ldvl, double* vr, const int * ldvr, const int * nm, int* m, double* work, int* info ); void LAPACK_STREXC( const char* compq, const int *n, float* t, const int * ldt, float* q, const int* ldq, int* ifst, const int * ilst, float* work, int* info ); void LAPACK_DTREXC( const char* compq, const int *n, double* t, const int * ldt, double* q, const int* ldq, int* ifst, const int * ilst, double* work, int* info ); void LAPACK_CTREXC( const char* compq, const int *n, fcomplex_t* t, const int * ldt, fcomplex_t* q, const int* ldq, int* ifst, const int * ilst, int* info ); void LAPACK_ZTREXC( const char* compq, const int *n, dcomplex_t* t, const int * ldt, dcomplex_t* q, const int* ldq, int* ifst, const int * ilst, int* info ); /* Hermitian banded matrices */ void LAPACK_SSBEV( char const* jobz, char const* uplo, int const* n, int const* kd, float* ab, int const* ldab, float* w, float* z, int const* ldz, float* work, int const* info ); void LAPACK_DSBEV( char const* jobz, char const* uplo, int const* n, int const* kd, double* ab, int const* ldab, double* w, double* z, int const* ldz, double* work, int const* info ); void LAPACK_CHBEV( char const* jobz, char const* uplo, int const* n, int const* kd, fcomplex_t* ab, int const* ldab, float* w, fcomplex_t* z, int const* ldz, fcomplex_t* work, float* rwork, int const* info ); void LAPACK_ZHBEV( char const* jobz, char const* uplo, int const* n, int const* kd, dcomplex_t* ab, int const* ldab, double* w, dcomplex_t* z, int const* ldz, dcomplex_t* work, double* rwork, int const* info ); /*********************************************************************/ /* SVD */ /*********************************************************************/ void LAPACK_SGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, float* a, int const* lda, float* s, float* u, int const* ldu, float* vt, int const* ldvt, float* work, int const* lwork, int* info); void LAPACK_DGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, double* a, int const* lda, double* s, double* u, int const* ldu, double* vt, int const* ldvt, double* work, int const* lwork, int* info); void LAPACK_CGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, fcomplex_t* a, int const* lda, float* s, fcomplex_t* u, int const* ldu, fcomplex_t* vt, int const* ldvt, fcomplex_t* work, int const* lwork, float* rwork, int* info); void LAPACK_ZGESVD (char const* jobu, char const* jobvt, int const* m, int const* n, dcomplex_t* a, int const* lda, double* s, dcomplex_t* u, int const* ldu, dcomplex_t* vt, int const* ldvt, dcomplex_t* work, int const* lwork, double* rwork, int* info); void LAPACK_SGESDD (char const* jobz, int const* m, int const* n, float* a, int const* lda, float* s, float* u, int const* ldu, float* vt, int const* ldvt, float* work, int const* lwork, int* iwork, int* info); void LAPACK_DGESDD (char const* jobz, int const* m, int const* n, double* a, int const* lda, double* s, double* u, int const* ldu, double* vt, int const* ldvt, double* work, int const* lwork, int* iwork, int* info); void LAPACK_CGESDD (char const* jobz, int const* m, int const* n, fcomplex_t* a, int const* lda, float* s, fcomplex_t* u, int const* ldu, fcomplex_t* vt, int const* ldvt, fcomplex_t* work, int const* lwork, float* rwork, int* iwork, int* info); void LAPACK_ZGESDD (char const* jobz, int const* m, int const* n, dcomplex_t* a, int const* lda, double* s, dcomplex_t* u, int const* ldu, dcomplex_t* vt, int const* ldvt, dcomplex_t* work, int const* lwork, double* rwork, int* iwork, int* info); /*********************************************************************/ /* QR factorization */ /*********************************************************************/ void LAPACK_SGEQRF( const int* m, const int* n, float* a, const int* lda, float* tau, float* work, const int* lwork, int* info ); void LAPACK_DGEQRF( const int* m, const int* n, double* a, const int* lda, double* tau, double* work, const int* lwork, int* info ); void LAPACK_CGEQRF( const int* m, const int* n, fcomplex_t* a, const int* lda, fcomplex_t* tau, fcomplex_t* work, const int* lwork, int* info ); void LAPACK_ZGEQRF( const int* m, const int* n, dcomplex_t* a, const int* lda, dcomplex_t* tau, dcomplex_t* work, const int* lwork, int* info ); void LAPACK_SORMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const float* a, const int* lda, const float* tau, float* c, const int* ldc, float* work, const int* lwork, int* info ); void LAPACK_DORMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const double* a, const int* lda, const double* tau, double* c, const int* ldc, double* work, const int* lwork, int* info ); void LAPACK_CUNMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const fcomplex_t* a, const int* lda, const fcomplex_t* tau, fcomplex_t* c, const int* ldc, fcomplex_t* work, const int* lwork, int* info ); void LAPACK_ZUNMQR( const char* side, const char* trans, const int* m, const int* n, const int* k, const dcomplex_t* a, const int* lda, const dcomplex_t* tau, dcomplex_t* c, const int* ldc, dcomplex_t* work, const int* lwork, int* info ); /********************************************************************/ /* auxiliary */ /********************************************************************/ int LAPACK_ILAENV (int const* ispec, const char* name, const char* opt, int const* n1, int const* n2, int const* n3, int const* n4, int, int); } #endif kml_src/boost/numeric/bindings/lapack/lapack.hpp000644 000765 000024 00000002726 10265665640 022745 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_HPP // linear systems #include #include #include #include #include #include #include // eigenproblems #include #include #include #include // SVD #include #include // Miscellaneous #include #include #endif // BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_HPP kml_src/boost/numeric/bindings/lapack/lapack_names.h000644 000765 000024 00000015200 10265665640 023557 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_NAMES_H #define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_NAMES_H #ifndef BOOST_NUMERIC_BINDINGS_USE_CLAPACK # include #else # define FORTRAN_ID( id ) id##_ #endif /* linear systems */ /* general */ #define LAPACK_SGESV FORTRAN_ID( sgesv ) #define LAPACK_DGESV FORTRAN_ID( dgesv ) #define LAPACK_CGESV FORTRAN_ID( cgesv ) #define LAPACK_ZGESV FORTRAN_ID( zgesv ) #define LAPACK_SGETRF FORTRAN_ID( sgetrf ) #define LAPACK_DGETRF FORTRAN_ID( dgetrf ) #define LAPACK_CGETRF FORTRAN_ID( cgetrf ) #define LAPACK_ZGETRF FORTRAN_ID( zgetrf ) #define LAPACK_SGETRS FORTRAN_ID( sgetrs ) #define LAPACK_DGETRS FORTRAN_ID( dgetrs ) #define LAPACK_CGETRS FORTRAN_ID( cgetrs ) #define LAPACK_ZGETRS FORTRAN_ID( zgetrs ) #define LAPACK_SGETRI FORTRAN_ID( sgetri ) #define LAPACK_DGETRI FORTRAN_ID( dgetri ) #define LAPACK_CGETRI FORTRAN_ID( cgetri ) #define LAPACK_ZGETRI FORTRAN_ID( zgetri ) /* symmetric/Hermitian positive definite */ #define LAPACK_SPOSV FORTRAN_ID( sposv ) #define LAPACK_DPOSV FORTRAN_ID( dposv ) #define LAPACK_CPOSV FORTRAN_ID( cposv ) #define LAPACK_ZPOSV FORTRAN_ID( zposv ) #define LAPACK_SPOTRF FORTRAN_ID( spotrf ) #define LAPACK_DPOTRF FORTRAN_ID( dpotrf ) #define LAPACK_CPOTRF FORTRAN_ID( cpotrf ) #define LAPACK_ZPOTRF FORTRAN_ID( zpotrf ) #define LAPACK_SPOTRS FORTRAN_ID( spotrs ) #define LAPACK_DPOTRS FORTRAN_ID( dpotrs ) #define LAPACK_CPOTRS FORTRAN_ID( cpotrs ) #define LAPACK_ZPOTRS FORTRAN_ID( zpotrs ) #define LAPACK_SPOTRI FORTRAN_ID( spotri ) #define LAPACK_DPOTRI FORTRAN_ID( dpotri ) #define LAPACK_CPOTRI FORTRAN_ID( cpotri ) #define LAPACK_ZPOTRI FORTRAN_ID( zpotri ) /* symmetric/Hermitian positive definite in packed storage */ #define LAPACK_SPPSV FORTRAN_ID( sppsv ) #define LAPACK_DPPSV FORTRAN_ID( dppsv ) #define LAPACK_CPPSV FORTRAN_ID( cppsv ) #define LAPACK_ZPPSV FORTRAN_ID( zppsv ) #define LAPACK_SPPTRF FORTRAN_ID( spptrf ) #define LAPACK_DPPTRF FORTRAN_ID( dpptrf ) #define LAPACK_CPPTRF FORTRAN_ID( cpptrf ) #define LAPACK_ZPPTRF FORTRAN_ID( zpptrf ) #define LAPACK_SPPTRS FORTRAN_ID( spptrs ) #define LAPACK_DPPTRS FORTRAN_ID( dpptrs ) #define LAPACK_CPPTRS FORTRAN_ID( cpptrs ) #define LAPACK_ZPPTRS FORTRAN_ID( zpptrs ) #define LAPACK_SPPTRI FORTRAN_ID( spptri ) #define LAPACK_DPPTRI FORTRAN_ID( dpptri ) #define LAPACK_CPPTRI FORTRAN_ID( cpptri ) #define LAPACK_ZPPTRI FORTRAN_ID( zpptri ) /* symmetric/Hermitian indefinite and complex symmetric */ #define LAPACK_SSYSV FORTRAN_ID( ssysv ) #define LAPACK_DSYSV FORTRAN_ID( dsysv ) #define LAPACK_CSYSV FORTRAN_ID( csysv ) #define LAPACK_ZSYSV FORTRAN_ID( zsysv ) #define LAPACK_CHESV FORTRAN_ID( chesv ) #define LAPACK_ZHESV FORTRAN_ID( zhesv ) #define LAPACK_SSYTRF FORTRAN_ID( ssytrf ) #define LAPACK_DSYTRF FORTRAN_ID( dsytrf ) #define LAPACK_CSYTRF FORTRAN_ID( csytrf ) #define LAPACK_ZSYTRF FORTRAN_ID( zsytrf ) #define LAPACK_CHETRF FORTRAN_ID( chetrf ) #define LAPACK_ZHETRF FORTRAN_ID( zhetrf ) #define LAPACK_SSYTRS FORTRAN_ID( ssytrs ) #define LAPACK_DSYTRS FORTRAN_ID( dsytrs ) #define LAPACK_CSYTRS FORTRAN_ID( csytrs ) #define LAPACK_ZSYTRS FORTRAN_ID( zsytrs ) #define LAPACK_CHETRS FORTRAN_ID( chetrs ) #define LAPACK_ZHETRS FORTRAN_ID( zhetrs ) /* symmetric/Hermitian indefinite and complex symmetric in packed storage */ #define LAPACK_SSPSV FORTRAN_ID( sspsv ) #define LAPACK_DSPSV FORTRAN_ID( dspsv ) #define LAPACK_CSPSV FORTRAN_ID( cspsv ) #define LAPACK_ZSPSV FORTRAN_ID( zspsv ) #define LAPACK_CHPSV FORTRAN_ID( chpsv ) #define LAPACK_ZHPSV FORTRAN_ID( zhpsv ) #define LAPACK_SSPTRF FORTRAN_ID( ssptrf ) #define LAPACK_DSPTRF FORTRAN_ID( dsptrf ) #define LAPACK_CSPTRF FORTRAN_ID( csptrf ) #define LAPACK_ZSPTRF FORTRAN_ID( zsptrf ) #define LAPACK_CHPTRF FORTRAN_ID( chptrf ) #define LAPACK_ZHPTRF FORTRAN_ID( zhptrf ) #define LAPACK_SSPTRS FORTRAN_ID( ssptrs ) #define LAPACK_DSPTRS FORTRAN_ID( dsptrs ) #define LAPACK_CSPTRS FORTRAN_ID( csptrs ) #define LAPACK_ZSPTRS FORTRAN_ID( zsptrs ) #define LAPACK_CHPTRS FORTRAN_ID( chptrs ) #define LAPACK_ZHPTRS FORTRAN_ID( zhptrs ) /********************************************/ /* eigenproblems */ #define LAPACK_SGEES FORTRAN_ID( sgees ) #define LAPACK_DGEES FORTRAN_ID( dgees ) #define LAPACK_CGEES FORTRAN_ID( cgees ) #define LAPACK_ZGEES FORTRAN_ID( zgees ) #define LAPACK_SGEEV FORTRAN_ID( sgeev ) #define LAPACK_DGEEV FORTRAN_ID( dgeev ) #define LAPACK_CGEEV FORTRAN_ID( cgeev ) #define LAPACK_ZGEEV FORTRAN_ID( zgeev ) #define LAPACK_SSYEV FORTRAN_ID( ssyev ) #define LAPACK_DSYEV FORTRAN_ID( dsyev ) #define LAPACK_CHEEV FORTRAN_ID( cheev ) #define LAPACK_ZHEEV FORTRAN_ID( zheev ) #define LAPACK_STREVC FORTRAN_ID( strevc ) #define LAPACK_DTREVC FORTRAN_ID( dtrevc ) #define LAPACK_CTREVC FORTRAN_ID( ctrevc ) #define LAPACK_ZTREVC FORTRAN_ID( ztrevc ) #define LAPACK_STREXC FORTRAN_ID( strexc ) #define LAPACK_DTREXC FORTRAN_ID( dtrexc ) #define LAPACK_CTREXC FORTRAN_ID( ctrexc ) #define LAPACK_ZTREXC FORTRAN_ID( ztrexc ) /********************************************/ /* eigenproblems for banded matrices */ #define LAPACK_SSBEV FORTRAN_ID( ssbev ) #define LAPACK_DSBEV FORTRAN_ID( dsbev ) #define LAPACK_CHBEV FORTRAN_ID( chbev ) #define LAPACK_ZHBEV FORTRAN_ID( zhbev ) /********************************************/ /* QR factorization */ #define LAPACK_SGEQRF FORTRAN_ID( sgeqrf ) #define LAPACK_DGEQRF FORTRAN_ID( dgeqrf ) #define LAPACK_CGEQRF FORTRAN_ID( cgeqrf ) #define LAPACK_ZGEQRF FORTRAN_ID( zgeqrf ) // Apply orthogonal transformation #define LAPACK_SORMQR FORTRAN_ID( sormqr ) #define LAPACK_DORMQR FORTRAN_ID( dormqr ) #define LAPACK_CUNMQR FORTRAN_ID( cunmqr ) #define LAPACK_ZUNMQR FORTRAN_ID( zunmqr ) /********************************************/ /* SVD */ #define LAPACK_SGESVD FORTRAN_ID( sgesvd ) #define LAPACK_DGESVD FORTRAN_ID( dgesvd ) #define LAPACK_CGESVD FORTRAN_ID( cgesvd ) #define LAPACK_ZGESVD FORTRAN_ID( zgesvd ) #define LAPACK_SGESDD FORTRAN_ID( sgesdd ) #define LAPACK_DGESDD FORTRAN_ID( dgesdd ) #define LAPACK_CGESDD FORTRAN_ID( cgesdd ) #define LAPACK_ZGESDD FORTRAN_ID( zgesdd ) /********************************************/ /* auxiliary */ #define LAPACK_ILAENV FORTRAN_ID( ilaenv ) #endif kml_src/boost/numeric/bindings/lapack/ormqr.hpp000644 000765 000024 00000017376 10265665640 022661 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_ORMQR_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_ORMQR_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Apply the orthogonal transformation abtained by geqrf() to // a general matrix. // /////////////////////////////////////////////////////////////////// /* * ormqr() overwrites the general M by N matrix C with * * SIDE = 'L' SIDE = 'R' * TRANS = 'N': Q * C C * Q * TRANS = 'C' || 'T': Q**H * C C * Q**H * * where Q is a complex unitary matrix defined as the product of k * elementary reflectors * * Q = H(1) H(2) . . . H(k) * * as returned by geqrf(). Q is of order M if SIDE = 'L' and of order N * if SIDE = 'R'. * * Workspace is organized following the arguments in the calling sequence. * optimal_workspace() : for optimizing use of blas 3 kernels * minimal_workspace() : minimum size of workarrays, but does not allow for optimization * of blas 3 kernels * workspace( work ) where is an array that is used as auxiliary memory with the same value_type * as C. * We must have that vector_size( work ) >= matrix_size2( c ) * if SIDE=='L' otherwise vector_size( work ) >= matrix_size1( c ) */ namespace detail { inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const float* a, int const lda, const float* tau, float* c, int const ldc, float* work, int const lwork, int& info) { LAPACK_SORMQR (&side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, &info); } inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const double* a, int const lda, const double* tau, double* c, int const ldc, double* work, int const lwork, int& info) { LAPACK_DORMQR (&side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work, &lwork, &info); } inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const std::complex* a, int const lda, const std::complex* tau, std::complex* c, int const ldc, std::complex* work, int const lwork, int& info) { LAPACK_CUNMQR (&side, &trans, &m, &n, &k, reinterpret_cast(a), &lda, reinterpret_cast(tau), reinterpret_cast(c), &ldc, reinterpret_cast(work), &lwork, &info); } inline void ormqr (char const side, char const trans, int const m, int const n, int const k, const std::complex* a, int const lda, const std::complex* tau, std::complex* c, int const ldc, std::complex* work, int const lwork, int& info) { LAPACK_ZUNMQR (&side, &trans, &m, &n, &k, reinterpret_cast(a), &lda, reinterpret_cast(tau), reinterpret_cast(c), &ldc, reinterpret_cast(work), &lwork, &info); } template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); int const k = traits::vector_size (tau); int const lwork = traits::vector_size (work); assert ( side=='L' || side=='R' ); assert ( trans=='N' || trans=='C' || trans=='T' ); assert ( (side=='L' ? m >= k : n >= k ) ); assert ( (side=='L' ? m == traits::matrix_size1 (a) : n == traits::matrix_size1 (a) ) ); assert (traits::matrix_size2 (a)==k); assert ( (side=='L' ? lwork >= n : lwork >= m ) ); int info; ormqr (side, trans, m, n, k, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (tau), traits::matrix_storage (c), traits::leading_dimension (c), traits::vector_storage (work), lwork, info); return info; } } // namespace detail // Function that allocates temporary arrays for optimal execution time. template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, optimal_workspace ) { typedef typename A::value_type value_type ; int const n_w = (side=='L' ? traits::matrix_size2 (c) : traits::matrix_size1 (c) ); traits::detail::array work( std::max(1,n_w*32) ); return detail::ormqr( side, trans, a, tau, c, work ); } // Function that allocates temporary arrays with minimal size template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, minimal_workspace ) { typedef typename A::value_type value_type ; int const n_w = (side=='L' ? traits::matrix_size2 (c) : traits::matrix_size1 (c) ); traits::detail::array work( std::max(1,n_w) ); return detail::ormqr( side, trans, a, tau, c, work ); } // Function that uses auxiliary array in workspace // The calling sequence is ormqr(side, trans, a, tau, c, workspace( work_array ) ) // where work_array is an array with the same value_type as a and c . template inline int ormqr (char side, char trans, const A& a, const Tau& tau, C& c, detail::workspace1 workspace ) { typedef typename A::value_type value_type ; return detail::ormqr( side, trans, a, tau, c, workspace.w_ ); } } }}} #endif kml_src/boost/numeric/bindings/lapack/posv.hpp000644 000765 000024 00000026172 10265665640 022502 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_POSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_POSV_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A symmetric or Hermitian positive definite matrix // ///////////////////////////////////////////////////////////////////// /* * posv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric or Hermitian positive * definite matrix and X and B are N-by-NRHS matrices. * * The Cholesky decomposition is used to factor A as * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is a lower triangular * matrix. The factored form of A is then used to solve the system of * equations A * X = B. * * If UPLO = 'U', the leading N-by-N upper triangular part of A * contains the upper triangular part of the matrix A, and the * strictly lower triangular part of A is not referenced. * If UPLO = 'L', the leading N-by-N lower triangular part of A * contains the lower triangular part of the matrix A, and the * strictly upper triangular part of A is not referenced. */ namespace detail { inline void posv (char const uplo, int const n, int const nrhs, float* a, int const lda, float* b, int const ldb, int* info) { LAPACK_SPOSV (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void posv (char const uplo, int const n, int const nrhs, double* a, int const lda, double* b, int const ldb, int* info) { LAPACK_DPOSV (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void posv (char const uplo, int const n, int const nrhs, traits::complex_f* a, int const lda, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPOSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } inline void posv (char const uplo, int const n, int const nrhs, traits::complex_d* a, int const lda, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPOSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } template inline int posv (char const uplo, SymmMatrA& a, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); int info; posv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int posv (char const uplo, SymmMatrA& a, MatrB& b) { assert (uplo == 'U' || uplo == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::posv (uplo, a, b); } template inline int posv (SymmMatrA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef traits::matrix_traits matraits; typedef typename matraits::value_type val_t; BOOST_STATIC_ASSERT( (traits::detail::symm_herm_compatible< val_t, typename matraits::matrix_structure >::value ) ) ; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::posv (uplo, a, b); } /* * potrf() computes the Cholesky factorization of a symmetric * or Hermitian positive definite matrix A. The factorization has * the form * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is lower triangular. */ namespace detail { inline void potrf (char const uplo, int const n, float* a, int const lda, int* info) { LAPACK_SPOTRF (&uplo, &n, a, &lda, info); } inline void potrf (char const uplo, int const n, double* a, int const lda, int* info) { LAPACK_DPOTRF (&uplo, &n, a, &lda, info); } inline void potrf (char const uplo, int const n, traits::complex_f* a, int const lda, int* info) { LAPACK_CPOTRF (&uplo, &n, traits::complex_ptr (a), &lda, info); } inline void potrf (char const uplo, int const n, traits::complex_d* a, int const lda, int* info) { LAPACK_ZPOTRF (&uplo, &n, traits::complex_ptr (a), &lda, info); } template inline int potrf (char const uplo, SymmMatrA& a) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); int info; potrf (uplo, n, traits::matrix_storage (a), traits::leading_dimension (a), &info); return info; } } template inline int potrf (char const uplo, SymmMatrA& a) { assert (uplo == 'U' || uplo == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::potrf (uplo, a); } template inline int potrf (SymmMatrA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef traits::matrix_traits matraits; typedef typename matraits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename matraits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::potrf (uplo, a); } /* * potrs() solves a system of linear equations A*X = B with * a symmetric or Hermitian positive definite matrix A using * the Cholesky factorization computed by potrf(). */ namespace detail { inline void potrs (char const uplo, int const n, int const nrhs, float const* a, int const lda, float* b, int const ldb, int* info) { LAPACK_SPOTRS (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void potrs (char const uplo, int const n, int const nrhs, double const* a, int const lda, double* b, int const ldb, int* info) { LAPACK_DPOTRS (&uplo, &n, &nrhs, a, &lda, b, &ldb, info); } inline void potrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const lda, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPOTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } inline void potrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const lda, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPOTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, traits::complex_ptr (b), &ldb, info); } template inline int potrs (char const uplo, SymmMatrA const& a, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); int info; potrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int potrs (char const uplo, SymmMatrA const& a, MatrB& b) { assert (uplo == 'U' || uplo == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::potrs (uplo, a, b); } template inline int potrs (SymmMatrA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef traits::matrix_traits matraits; typedef traits::matrix_traits mbtraits; typedef typename matraits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename matraits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename mbtraits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::potrs (uplo, a, b); } // TO DO: potri() } }}} #endif kml_src/boost/numeric/bindings/lapack/ppsv.hpp000644 000765 000024 00000020740 10265665640 022476 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl Toon Knapen 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_PPSV_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A symmetric or Hermitian positive definite matrix // stored in packed format // ///////////////////////////////////////////////////////////////////// /* * ppsv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric or Hermitian positive * definite matrix stored in packed format and X and B are N-by-NRHS * matrices. * * The Cholesky decomposition is used to factor A as * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is a lower triangular * matrix. The factored form of A is then used to solve the system of * equations A * X = B. * * Only upper or lower triangle of the symmetric matrix A is stored, * packed columnwise in a linear array AP. */ namespace detail { inline void ppsv (char const uplo, int const n, int const nrhs, float* ap, float* b, int const ldb, int* info) { LAPACK_SPPSV (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void ppsv (char const uplo, int const n, int const nrhs, double* ap, double* b, int const ldb, int* info) { LAPACK_DPPSV (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void ppsv (char const uplo, int const n, int const nrhs, traits::complex_f* ap, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } inline void ppsv (char const uplo, int const n, int const nrhs, traits::complex_d* ap, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } } template inline int ppsv (SymmMatrA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_pack_t< typename traits::matrix_traits::value_type >::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; detail::ppsv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } /* * pptrf() computes the Cholesky factorization of a symmetric * or Hermitian positive definite matrix A in packed storage. * The factorization has the form * A = U^T * U or A = U^H * U, if UPLO = 'U', * A = L * L^T or A = L * L^H, if UPLO = 'L', * where U is an upper triangular matrix and L is lower triangular. */ namespace detail { inline void pptrf (char const uplo, int const n, float* ap, int* info) { LAPACK_SPPTRF (&uplo, &n, ap, info); } inline void pptrf (char const uplo, int const n, double* ap, int* info) { LAPACK_DPPTRF (&uplo, &n, ap, info); } inline void pptrf (char const uplo, int const n, traits::complex_f* ap, int* info) { LAPACK_CPPTRF (&uplo, &n, traits::complex_ptr (ap), info); } inline void pptrf (char const uplo, int const n, traits::complex_d* ap, int* info) { LAPACK_ZPPTRF (&uplo, &n, traits::complex_ptr (ap), info); } } template inline int pptrf (SymmMatrA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_pack_t< typename traits::matrix_traits::value_type >::type >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); char uplo = traits::matrix_uplo_tag (a); int info; detail::pptrf (uplo, n, traits::matrix_storage (a), &info); return info; } /* * pptrs() solves a system of linear equations A*X = B with * a symmetric or Hermitian positive definite matrix A in packed * storage using the Cholesky factorization computed by pptrf(). */ namespace detail { inline void pptrs (char const uplo, int const n, int const nrhs, float const* ap, float* b, int const ldb, int* info) { LAPACK_SPPTRS (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void pptrs (char const uplo, int const n, int const nrhs, double const* ap, double* b, int const ldb, int* info) { LAPACK_DPPTRS (&uplo, &n, &nrhs, ap, b, &ldb, info); } inline void pptrs (char const uplo, int const n, int const nrhs, traits::complex_f const* ap, traits::complex_f* b, int const ldb, int* info) { LAPACK_CPPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } inline void pptrs (char const uplo, int const n, int const nrhs, traits::complex_d const* ap, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZPPTRS (&uplo, &n, &nrhs, traits::complex_ptr (ap), traits::complex_ptr (b), &ldb, info); } } template inline int pptrs (SymmMatrA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_pack_t< typename traits::matrix_traits::value_type >::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; detail::pptrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } // TO DO: pptri() } }}} #endif kml_src/boost/numeric/bindings/lapack/spsv.hpp000644 000765 000024 00000022626 10265665640 022506 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl & Toon Knapen 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SPSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_SPSV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B with A symmetric matrix // stored in packed format // ///////////////////////////////////////////////////////////////////// /* * spsv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric matrix stored in packed * format and X and B are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^T, if UPLO = 'U', * A = L * D * L^T, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is symmetric and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. * The factored form of A is then used to solve the system * of equations A * X = B. */ namespace detail { inline void spsv (char const uplo, int const n, int const nrhs, float* ap, int* ipiv, float* b, int const ldb, int* info) { LAPACK_SSPSV (&uplo, &n, &nrhs, ap, ipiv, b, &ldb, info); } inline void spsv (char const uplo, int const n, int const nrhs, double* ap, int* ipiv, double* b, int const ldb, int* info) { LAPACK_DSPSV (&uplo, &n, &nrhs, ap, ipiv, b, &ldb, info); } inline void spsv (char const uplo, int const n, int const nrhs, traits::complex_f* ap, int* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CSPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } inline void spsv (char const uplo, int const n, int const nrhs, traits::complex_d* ap, int* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZSPSV (&uplo, &n, &nrhs, traits::complex_ptr (ap), ipiv, traits::complex_ptr (b), &ldb, info); } template inline int spsv (SymmA& a, IVec& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); char uplo = traits::matrix_uplo_tag (a); int info; spsv (uplo, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int spsv (SymmA& a, IVec& i, MatrB& b) { assert (traits::matrix_size1 (a) == traits::vector_size (i)); return detail::spsv (a, i, b); } template inline int spsv (SymmA& a, MatrB& b) { // with 'internal' pivot vector int info = -101; traits::detail::array i (traits::matrix_size1 (a)); if (i.valid()) info = detail::spsv (a, i, b); return info; } /* * sptrf() computes the factorization of a symmetric matrix A * in packed storage using the Bunch-Kaufman diagonal pivoting * method. The form of the factorization is * A = U * D * U^T or A = L * D * L^T * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is symmetric and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void sptrf (char const uplo, int const n, float* ap, int* ipiv, int* info) { LAPACK_SSPTRF (&uplo, &n, ap, ipiv, info); } inline void sptrf (char const uplo, int const n, double* ap, int* ipiv, int* info) { LAPACK_DSPTRF (&uplo, &n, ap, ipiv, info); } inline void sptrf (char const uplo, int const n, traits::complex_f* ap, int* ipiv, int* info) { LAPACK_CSPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } inline void sptrf (char const uplo, int const n, traits::complex_d* ap, int* ipiv, int* info) { LAPACK_ZSPTRF (&uplo, &n, traits::complex_ptr (ap), ipiv, info); } } template inline int sptrf (SymmA& a, IVec& i) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::sptrf (uplo, n, traits::matrix_storage (a), traits::vector_storage (i), &info); return info; } /* * sptrs() solves a system of linear equations A*X = B with * a symmetric matrix A in packed storage using the factorization * A = U * D * U^T or A = L * D * L^T * computed by sptrf(). */ namespace detail { inline void sptrs (char const uplo, int const n, int const nrhs, float const* a, int const* ipiv, float* b, int const ldb, int* info) { LAPACK_SSPTRS (&uplo, &n, &nrhs, a, ipiv, b, &ldb, info); } inline void sptrs (char const uplo, int const n, int const nrhs, double const* a, int const* ipiv, double* b, int const ldb, int* info) { LAPACK_DSPTRS (&uplo, &n, &nrhs, a, ipiv, b, &ldb, info); } inline void sptrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CSPTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), ipiv, traits::complex_ptr (b), &ldb, info); } inline void sptrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZSPTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), ipiv, traits::complex_ptr (b), &ldb, info); } } template inline int sptrs (SymmA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); char uplo = traits::matrix_uplo_tag (a); int info; detail::sptrs (uplo, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (i), #else traits::matrix_storage_const (a), traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } // TO DO: sptri } }}} #endif kml_src/boost/numeric/bindings/lapack/syev.hpp000644 000765 000024 00000011460 10265665640 022473 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen, Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYEV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_SYEV_HPP #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif #include namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Eigendecomposition of a real symmetric matrix A = Q * D * Q' // /////////////////////////////////////////////////////////////////// /* * syev() computes the eigendecomposition of a N x N matrix * A = Q * D * Q', where Q is a N x N orthogonal matrix and * D is a diagonal matrix. The diagonal elements D(i,i) is an * eigenvalue of A and Q(:,i) is a corresponding eigenvector. * * On return of syev, A is overwritten by Q and w contains the main * diagonal of D. * * int syev (char jobz, char uplo, A& a, W& w, minimal_workspace ) ; * jobz : 'V' : compute eigenvectors * 'N' : do not compute eigenvectors * uplo : 'U' : only the upper triangular part of A is used on input. * 'L' : only the lower triangular part of A is used on input. */ namespace detail { inline void syev (char const jobz, char const uplo, int const n, float* a, int const lda, float* w, float* work, int const lwork, int& info) { LAPACK_SSYEV (&jobz, &uplo, &n, a, &lda, w, work, &lwork, &info); } inline void syev (char const jobz, char const uplo, int const n, double* a, int const lda, double* w, double* work, int const lwork, int& info) { LAPACK_DSYEV (&jobz, &uplo, &n, a, &lda, w, work, &lwork, &info); } template inline int syev (char jobz, char uplo, A& a, W& w, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert ( n>0 ); assert (traits::matrix_size2 (a)==n); assert (traits::leading_dimension (a)>=n); assert (traits::vector_size (w)==n); assert (3*n-1 <= traits::vector_size (work)); assert ( uplo=='U' || uplo=='L' ); assert ( jobz=='N' || jobz=='V' ); int info; detail::syev (jobz, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (w), traits::vector_storage (work), traits::vector_size (work), info); return info; } } // namespace detail // Function that allocates work arrays template inline int syev (char jobz, char uplo, A& a, W& w, optimal_workspace ) { typedef typename A::value_type value_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,34*n) ); return detail::syev(jobz, uplo, a, w, work); } // syev() // Function that allocates work arrays template inline int syev (char jobz, char uplo, A& a, W& w, minimal_workspace ) { typedef typename A::value_type value_type ; int const n = traits::matrix_size1 (a); traits::detail::array work( std::max(1,3*n-1) ); return detail::syev(jobz, uplo, a, w, work); } // syev() // Function that allocates work arrays template inline int syev (char jobz, char uplo, A& a, W& w, detail::workspace1 workspace ) { typedef typename A::value_type value_type ; return detail::syev(jobz, uplo, a, w, workspace.w_); } // syev() } }}} #endif kml_src/boost/numeric/bindings/lapack/sysv.hpp000644 000765 000024 00000051066 10265665640 022517 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_SYSV_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_SYSV_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B with A symmetric matrix // ///////////////////////////////////////////////////////////////////// namespace detail { inline int sytrf_block (float, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "SSYTRF", ul2, n); } inline int sytrf_block (double, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "DSYTRF", ul2, n); } inline int sytrf_block (traits::complex_f, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "CSYTRF", ul2, n); } inline int sytrf_block (traits::complex_d, int const ispec, char const ul, int const n) { char ul2[2] = "x"; ul2[0] = ul; return ilaenv (ispec, "ZSYTRF", ul2, n); } } template inline int sytrf_block (char const q, char const ul, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::sytrf_block (val_t(), ispec, ul, n); } template inline int sytrf_block (char const q, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int ispec = (q == 'O' ? 1 : 2); return detail::sytrf_block (val_t(), ispec, ul, n); } template inline int sytrf_work (char const q, char const ul, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (q == 'O' || q == 'M'); assert (ul == 'U' || ul == 'L'); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::sytrf_block (val_t(), 1, ul, n); return lw; } template inline int sytrf_work (char const q, SymmA const& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif assert (q == 'O' || q == 'M'); char ul = traits::matrix_uplo_tag (a); int n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif int lw = -13; if (q == 'M') lw = 1; if (q == 'O') lw = n * detail::sytrf_block (val_t(), 1, ul, n); return lw; } template inline int sysv_work (char const q, char const ul, SymmA const& a) { return sytrf_work (q, ul, a); } template inline int sysv_work (char const q, SymmA const& a) { return sytrf_work (q, a); } /* * sysv() computes the solution to a system of linear equations * A * X = B, where A is an N-by-N symmetric matrix and X and B * are N-by-NRHS matrices. * * The diagonal pivoting method is used to factor A as * A = U * D * U^T, if UPLO = 'U', * A = L * D * L^T, if UPLO = 'L', * where U (or L) is a product of permutation and unit upper * (lower) triangular matrices, and D is symmetric and block * diagonal with 1-by-1 and 2-by-2 diagonal blocks. * The factored form of A is then used to solve the system * of equations A * X = B. */ namespace detail { inline void sysv (char const uplo, int const n, int const nrhs, float* a, int const lda, int* ipiv, float* b, int const ldb, float* w, int const lw, int* info) { LAPACK_SSYSV (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, w, &lw, info); } inline void sysv (char const uplo, int const n, int const nrhs, double* a, int const lda, int* ipiv, double* b, int const ldb, double* w, int const lw, int* info) { LAPACK_DSYSV (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, w, &lw, info); } inline void sysv (char const uplo, int const n, int const nrhs, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* b, int const ldb, traits::complex_f* w, int const lw, int* info) { LAPACK_CSYSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } inline void sysv (char const uplo, int const n, int const nrhs, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* b, int const ldb, traits::complex_d* w, int const lw, int* info) { LAPACK_ZSYSV (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, traits::complex_ptr (w), &lw, info); } template inline int sysv (char const ul, SymmA& a, IVec& i, MatrB& b, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; sysv (ul, n, traits::matrix_size2 (b), traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::matrix_storage (b), traits::leading_dimension (b), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int sysv (char const ul, SymmA& a, IVec& i, MatrB& b, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (traits::vector_size (w) >= 1); return detail::sysv (ul, a, i, b, w); } template inline int sysv (SymmA& a, IVec& i, MatrB& b, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (traits::vector_size (w) >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::sysv (uplo, a, i, b, w); } template inline int sysv (char const ul, SymmA& a, MatrB& b) { // with 'internal' pivot and work vectors assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = sytrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sysv (ul, a, i, b, w); } return info; } template inline int sysv (SymmA& a, MatrB& b) { // with 'internal' pivot and work vectors #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); char uplo = traits::matrix_uplo_tag (a); int info = -101; traits::detail::array i (n); if (i.valid()) { info = -102; int lw = sytrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sysv (uplo, a, i, b, w); } return info; } /* * sytrf() computes the factorization of a symmetric matrix A using * the Bunch-Kaufman diagonal pivoting method. The form of the * factorization is * A = U * D * U^T or A = L * D * L^T * where U (or L) is a product of permutation and unit upper (lower) * triangular matrices, and D is symmetric and block diagonal with * 1-by-1 and 2-by-2 diagonal blocks. */ namespace detail { inline void sytrf (char const uplo, int const n, float* a, int const lda, int* ipiv, float* w, int const lw, int* info) { LAPACK_SSYTRF (&uplo, &n, a, &lda, ipiv, w, &lw, info); } inline void sytrf (char const uplo, int const n, double* a, int const lda, int* ipiv, double* w, int const lw, int* info) { LAPACK_DSYTRF (&uplo, &n, a, &lda, ipiv, w, &lw, info); } inline void sytrf (char const uplo, int const n, traits::complex_f* a, int const lda, int* ipiv, traits::complex_f* w, int const lw, int* info) { LAPACK_CSYTRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } inline void sytrf (char const uplo, int const n, traits::complex_d* a, int const lda, int* ipiv, traits::complex_d* w, int const lw, int* info) { LAPACK_ZSYTRF (&uplo, &n, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (w), &lw, info); } template inline int sytrf (char const ul, SymmA& a, IVec& i, Work& w) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::vector_size (i)); int info; sytrf (ul, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (i), traits::vector_storage (w), traits::vector_size (w), &info); return info; } } template inline int sytrf (char const ul, SymmA& a, IVec& i, Work& w) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (traits::vector_size (w) >= 1); return detail::sytrf (ul, a, i, w); } template inline int sytrf (SymmA& a, IVec& i, Work& w) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif assert (traits::vector_size (w) >= 1); char uplo = traits::matrix_uplo_tag (a); return detail::sytrf (uplo, a, i, w); } template inline int sytrf (char const ul, SymmA& a, Ivec& i) { // with 'internal' work vector assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int info = -101; int lw = sytrf_work ('O', ul, a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sytrf (ul, a, i, w); return info; } template inline int sytrf (SymmA& a, Ivec& i) { // with 'internal' work vector #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); int info = -101; int lw = sytrf_work ('O', a); assert (lw >= 1); // paranoia ? #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmA::value_type val_t; #endif traits::detail::array w (lw); if (w.valid()) info = detail::sytrf (uplo, a, i, w); return info; } /* * sytrs() solves a system of linear equations A*X = B with * a symmetric matrix A using the factorization * A = U * D * U^T or A = L * D * L^T * computed by sytrf(). */ namespace detail { inline void sytrs (char const uplo, int const n, int const nrhs, float const* a, int const lda, int const* ipiv, float* b, int const ldb, int* info) { LAPACK_SSYTRS (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void sytrs (char const uplo, int const n, int const nrhs, double const* a, int const lda, int const* ipiv, double* b, int const ldb, int* info) { LAPACK_DSYTRS (&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, info); } inline void sytrs (char const uplo, int const n, int const nrhs, traits::complex_f const* a, int const lda, int const* ipiv, traits::complex_f* b, int const ldb, int* info) { LAPACK_CSYTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } inline void sytrs (char const uplo, int const n, int const nrhs, traits::complex_d const* a, int const lda, int const* ipiv, traits::complex_d* b, int const ldb, int* info) { LAPACK_ZSYTRS (&uplo, &n, &nrhs, traits::complex_ptr (a), &lda, ipiv, traits::complex_ptr (b), &ldb, info); } template inline int sytrs (char const ul, SymmA const& a, IVec const& i, MatrB& b) { int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (n == traits::matrix_size1 (b)); assert (n == traits::vector_size (i)); int info; sytrs (ul, n, traits::matrix_size2 (b), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (i), #else traits::vector_storage_const (i), #endif traits::matrix_storage (b), traits::leading_dimension (b), &info); return info; } } template inline int sytrs (char const ul, SymmA const& a, IVec const& i, MatrB& b) { assert (ul == 'U' || ul == 'L'); #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif return detail::sytrs (ul, a, i, b); } template inline int sytrs (SymmA const& a, IVec const& i, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif char uplo = traits::matrix_uplo_tag (a); return detail::sytrs (uplo, a, i, b); } // TO DO: sytri } }}} #endif kml_src/boost/numeric/bindings/lapack/trevc.hpp000644 000765 000024 00000012111 10265665640 022622 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TREVC_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_TREVC_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Compute eigenvectors of Schur matrix (computed by gees). // /////////////////////////////////////////////////////////////////// /* * trevc() computes the eigenvectors using the Schur factorization * * Let A = U * S * herm(U), then trecv computes the eigenvectors of * S, and may optionally apply them to U. * * To compute the Schur factorization, see gees. */ namespace detail { inline void trevc (char const side, char const howmny, const logical_t* select, int const n, float* t, int const ldt, float* vl, int const ldvl, float* vr, int const ldvr, int const mm, int& m, float* work, int& info) { LAPACK_STREVC (&side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info); } inline void trevc (char const side, char const howmny, const logical_t* select, int const n, double* t, int const ldt, double* vl, int const ldvl, double* vr, int const ldvr, int const mm, int& m, double* work, int& info) { LAPACK_DTREVC (&side, &howmny, select, &n, t, &ldt, vl, &ldvl, vr, &ldvr, &mm, &m, work, &info); } inline void trevc (char const side, char const howmny, const logical_t* select, int const n, std::complex* t, int const ldt, std::complex* vl, int const ldvl, std::complex* vr, int const ldvr, int const mm, int& m, std::complex* work, int& info) { LAPACK_CTREVC (&side, &howmny, select, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr, &mm, &m, traits::complex_ptr(work+n), traits::complex_ptr(work), &info); } inline void trevc (char const side, char const howmny, const logical_t* select, int const n, std::complex* t, int const ldt, std::complex* vl, int const ldvl, std::complex* vr, int const ldvr, int const mm, int& m, std::complex* work, int& info) { LAPACK_ZTREVC (&side, &howmny, select, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(vl), &ldvl, traits::complex_ptr(vr), &ldvr, &mm, &m, traits::complex_ptr(work+n), traits::complex_ptr(work), &info); } } // Compute Schur factorization with Schur vectors template inline int trevc (char const side, char const howmny, MatrT& t, VL& vl, VR& vr, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (t); assert (n == traits::matrix_size2 (t)); assert (n == traits::matrix_size1 (vl)); assert (n == traits::matrix_size2 (vl)); assert (n == traits::matrix_size1 (vr)); assert (n == traits::matrix_size2 (vr)); assert (3*n <= traits::vector_size (work)); logical_t* select=0; int mm=n; int m; int info; detail::trevc (side, howmny, select, n, traits::matrix_storage (t), traits::leading_dimension (t), traits::matrix_storage (vl), traits::leading_dimension (vl), traits::matrix_storage (vr), traits::leading_dimension (vr), mm, m, traits::vector_storage (work), info); return info; } } }}} #endif kml_src/boost/numeric/bindings/lapack/trexc.hpp000644 000765 000024 00000010761 10265665640 022635 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Toon Knapen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * KF acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_LAPACK_TREXC_HPP #define BOOST_NUMERIC_BINDINGS_LAPACK_TREXC_HPP #include #include #include #include #include // #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace lapack { /////////////////////////////////////////////////////////////////// // // Reorder the Schur factorization of a matrix. // /////////////////////////////////////////////////////////////////// /* * trexc() reorders the Schur factorization of a matrix * A = Q*T*Q**T, so that the diagonal block of T with row * index IFST is moved to row ILST. */ namespace detail { inline int trexc_work_size( int const n, float ) {return n;} inline int trexc_work_size( int const n, double ) {return n;} inline int trexc_work_size( int const n, std::complex ) {return 0;} inline int trexc_work_size( int const n, std::complex ) {return 0;} } // Get the minimum size of the work array. template int trexc_work_size(const MatrT& t) { return detail::trexc_work_size( traits::matrix_size1(t), typename MatrT::value_type() ); } namespace detail { inline void trexc (char const compq, int const n, float* t, int const ldt, float* q, int const ldq, int& ifst, int& ilst, float* work, int& info) { LAPACK_STREXC (&compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info); } inline void trexc (char const compq, int const n, double* t, int const ldt, double* q, int const ldq, int& ifst, int& ilst, double* work, int& info) { LAPACK_DTREXC (&compq, &n, t, &ldt, q, &ldq, &ifst, &ilst, work, &info); } inline void trexc (char const compq, int const n, std::complex* t, int const ldt, std::complex* q, int const ldq, int& ifst, int& ilst, float* work, int& info) { LAPACK_CTREXC (&compq, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(q), &ldq, &ifst, &ilst, &info); } inline void trexc (char const compq, int const n, std::complex* t, int const ldt, std::complex* q, int const ldq, int& ifst, int& ilst, double* work, int& info) { LAPACK_ZTREXC (&compq, &n, traits::complex_ptr(t), &ldt, traits::complex_ptr(q), &ldq, &ifst, &ilst, &info); } } // Reorder Schur factorization with Schur vectors template inline int trexc (char const compq, MatrT& t, Q& q, int& ifst, int& ilst, Work& work) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (t); assert (n == traits::matrix_size2 (t)); assert (n == traits::matrix_size1 (q)); assert (n == traits::matrix_size2 (q)); assert (trexc_work_size(t) <= traits::vector_size (work)); int info; detail::trexc (compq, n, traits::matrix_storage (t), traits::leading_dimension (t), traits::matrix_storage (q), traits::leading_dimension (q), ifst, ilst, traits::vector_storage (work), info); return info; } } }}} #endif kml_src/boost/numeric/bindings/lapack/workspace.hpp000644 000765 000024 00000006136 10265665640 023507 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Karl Meerbergen & Kresimir Fresl 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Authors assume no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * 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 #include #include namespace boost { namespace numeric { namespace bindings { /* * 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) * */ namespace lapack { // Four classes are introduced to distinguish between the different type of memory allocations struct minimal_workspace {} ; struct optimal_workspace {} ; namespace detail { template struct workspace1 { W& w_ ; workspace1(W& w) : w_( w ) {} }; // struct workspace1 template struct workspace2 { W& w_ ; WR& wr_ ; workspace2(W& w, WR& wr) : w_(w) , wr_(wr) {} }; // struct workspace2 } template detail::workspace1 workspace(W& w) { return detail::workspace1(w) ; } // workspace() template detail::workspace2 workspace(W& w, WR& wr) { return detail::workspace2(w, wr) ; } // workspace() /// Select the number of workspaces depending on the value_type template struct n_workspace_args { }; template <> struct n_workspace_args< float > { static const int value = 1 ; }; template <> struct n_workspace_args< double > { static const int value = 1 ; }; template <> struct n_workspace_args< traits::complex_f > { static const int value = 2 ; }; template <> struct n_workspace_args< traits::complex_d > { static const int value = 2 ; }; } }}} #endif kml_src/boost/numeric/bindings/blas/blas.h000644 000765 000024 00000020512 10265665640 021552 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright (C) 2002, 2003 Si-Lab b.v.b.a and Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H /* * const-correct prototypes for BLAS functions * */ #include #include extern "C" { // // Level 1 // void BLAS_SSCAL(const int *n, const float* alpha, float* x, const int* incx); void BLAS_DSCAL(const int *n, const double* alpha, double* x, const int* incx); void BLAS_CSCAL(const int *n, const fcomplex_t* alpha, fcomplex_t* x, const int* incx); void BLAS_ZSCAL(const int *n, const dcomplex_t* alpha, dcomplex_t* x, const int* incx); void BLAS_SAXPY(const int *n, const float* alpha, const float* x, const int* incx, float* y, const int* incy); void BLAS_DAXPY(const int *n, const double* alpha, const double* x, const int* incx, double* y, const int* incy); void BLAS_CAXPY(const int *n, const fcomplex_t* alpha, const fcomplex_t* x, const int* incx, fcomplex_t* y, const int* incy); void BLAS_ZAXPY(const int *n, const dcomplex_t* alpha, const dcomplex_t* x, const int* incx, dcomplex_t* y, const int* incy); float BLAS_SDOT (const int *n, const float *x, const int *incx, const float *y, const int *incy); double BLAS_DDOT (const int *n, const double *x, const int *incx, const double *y, const int *incy); void BLAS_CDOTU(fcomplex_t* ret, const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy); void BLAS_ZDOTU(dcomplex_t* ret, const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy); void BLAS_CDOTC(fcomplex_t* ret, const int *n, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy); void BLAS_ZDOTC(dcomplex_t* ret, const int *n, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy); float BLAS_SNRM2(const int *n, const float *x, const int *incx); double BLAS_DNRM2(const int *n, const double *x, const int *incx); float BLAS_SCNRM2(const int *n, const fcomplex_t *x, const int *incx); double BLAS_DZNRM2(const int *n, const dcomplex_t *x, const int *incx); float BLAS_SASUM(const int *n, const float *x, const int *incx); double BLAS_DASUM(const int *n, const double *x, const int *incx); float BLAS_SCASUM(const int *n, const fcomplex_t *x, const int *incx); double BLAS_DZASUM(const int *n, const dcomplex_t *x, const int *incx); void BLAS_SCOPY( const int *n, const float *x, const int *incx, float *y, const int *incy); void BLAS_DCOPY( const int *n, const double *x, const int *incx, double *y, const int *incy); void BLAS_CCOPY( const int *n, const fcomplex_t *x, const int *incx, fcomplex_t *y, const int *incy); void BLAS_ZCOPY( const int *n, const dcomplex_t *x, const int *incx, dcomplex_t *y, const int *incy); // // Level 2 // void BLAS_SGEMV(const char *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) ; void BLAS_DGEMV(const char *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) ; void BLAS_CGEMV(const char *trans, const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *a, const int *lda, const fcomplex_t *x, const int *incx, const fcomplex_t *beta, fcomplex_t *y, const int *incy) ; void BLAS_ZGEMV(const char *trans, const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *a, const int *lda, const dcomplex_t *x, const int *incx, const dcomplex_t *beta, dcomplex_t *y, const int *incy) ; void BLAS_SGER (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); void BLAS_DGER (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); void BLAS_CGERU(const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy, fcomplex_t *a, const int *lda); void BLAS_ZGERU(const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy, dcomplex_t *a, const int *lda); void BLAS_CGERC(const int *m, const int *n, const fcomplex_t *alpha, const fcomplex_t *x, const int *incx, const fcomplex_t *y, const int *incy, fcomplex_t *a, const int *lda); void BLAS_ZGERC(const int *m, const int *n, const dcomplex_t *alpha, const dcomplex_t *x, const int *incx, const dcomplex_t *y, const int *incy, dcomplex_t *a, const int *lda); // // Level 3 // void BLAS_SGEMM(const char *transa, const char *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); void BLAS_DGEMM(const char *transa, const char *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); void BLAS_CGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const fcomplex_t *alpha, const fcomplex_t *a, const int *lda, const fcomplex_t *b, const int *ldb, const fcomplex_t *beta, fcomplex_t *c, const int *ldc); void BLAS_ZGEMM(const char *transa, const char *transb, const int *m, const int *n, const int *k, const dcomplex_t *alpha, const dcomplex_t *a, const int *lda, const dcomplex_t *b, const int *ldb, const dcomplex_t *beta, dcomplex_t *c, const int *ldc); void BLAS_SSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const float* alpha, const float* a, const int* lda, const float* beta, float* c, const int* ldc ); void BLAS_DSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const double* alpha, const double* a, const int* lda, const double* beta, double* c, const int* ldc ); void BLAS_CSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const fcomplex_t* alpha, const fcomplex_t* a, const int* lda, const fcomplex_t* beta, fcomplex_t* c, const int* ldc ); void BLAS_ZSYRK ( const char* uplo, const char* trans, const int* n, const int* k, const dcomplex_t* alpha, const dcomplex_t* a, const int* lda, const dcomplex_t* beta, dcomplex_t* c, const int* ldc ); void BLAS_CHERK ( const char* uplo, const char* trans, const int* n, const int* k, const float* alpha, const fcomplex_t* a, const int* lda, const float* beta, fcomplex_t* c, const int* ldc ); void BLAS_ZHERK ( const char* uplo, const char* trans, const int* n, const int* k, const double* alpha, const dcomplex_t* a, const int* lda, const double* beta, dcomplex_t* c, const int* ldc ); void BLAS_STRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, float const* alpha, float const* a, int const* lda, float* b, int const* ldb ); void BLAS_DTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, double const* alpha, double const* a, int const* lda, double* b, int const* ldb ); void BLAS_CTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, fcomplex_t const* alpha, fcomplex_t const* a, int const* lda, fcomplex_t* b, int const* ldb ); void BLAS_ZTRSM( const char* side, const char* uplo, const char* transa, const char* diag, const int* m, const int* n, dcomplex_t const* alpha, dcomplex_t const* a, int const* lda, dcomplex_t* b, int const* ldb ); } #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H kml_src/boost/numeric/bindings/blas/blas.hpp000644 000765 000024 00000000434 10265665640 022113 0ustar00pawelmstaff000000 000000 #ifndef boost_blasbindings_blasbindings_hpp #define boost_blasbindings_blasbindings_hpp #include #include #include #endif // boost_blasbindings_blasbindings_hpp kml_src/boost/numeric/bindings/blas/blas1.hpp000644 000765 000024 00000016601 10265665640 022177 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen and Kresimir Fresl #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_HPP #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { // x <- alpha * x template < typename value_type, typename vector_type > void scal(const value_type &alpha, vector_type &x ) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif const int n = traits::vector_size( x ) ; const int stride = traits::vector_stride( x ) ; value_type *x_ptr = traits::vector_storage( x ) ; detail::scal( n, alpha, x_ptr, stride ) ; } // y <- alpha * x + y template < typename value_type, typename vector_type_x, typename vector_type_y > void axpy(const value_type& alpha, const vector_type_x &x, vector_type_y &y ) { #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< value_type, typename vector_type_x::value_type >::value ) ) ; BOOST_STATIC_ASSERT( ( is_same< value_type, typename vector_type_y::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; BOOST_STATIC_ASSERT( ( is_same< value_type, typename traits::vector_traits< vector_type_y >::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; value_type *y_ptr = traits::vector_storage( y ) ; detail::axpy( n, alpha, x_ptr, stride_x, y_ptr, stride_y ) ; } // dot <- x^T * y (real vectors) template < typename vector_type_x, typename vector_type_y > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits< vector_type_x >::value_type #else typename vector_type_x::value_type #endif dot(const vector_type_x &x, const vector_type_y &y) { #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< typename vector_type_y::value_type, typename vector_type_x::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< typename traits::vector_traits< vector_type_y >::value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; typedef typename vector_type_x::value_type value_type ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; return detail::dot( n, x_ptr, stride_x, y_ptr, stride_y ) ; } // dotu <- x^T * y (complex vectors) template < typename vector_type_x, typename vector_type_y > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits< vector_type_x >::value_type #else typename vector_type_x::value_type #endif dotu(const vector_type_x &x, const vector_type_y &y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< typename traits::vector_traits< vector_type_y >::value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< typename vector_type_y::value_type, typename vector_type_x::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; typedef typename vector_type_x::value_type value_type ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type ret ; detail::dotu( ret, n, x_ptr, stride_x, y_ptr, stride_y ) ; return ret; } // dotc <- x^H * y (complex vectors) template < typename vector_type_x, typename vector_type_y > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits< vector_type_x >::value_type #else typename vector_type_x::value_type #endif dotc(const vector_type_x &x, const vector_type_y &y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( is_same< typename traits::vector_traits< vector_type_y >::value_type, typename traits::vector_traits< vector_type_x >::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( is_same< typename vector_type_y::value_type, typename vector_type_x::value_type >::value ) ) ; #endif assert( traits::vector_size( x ) == traits::vector_size( y ) ) ; typedef typename vector_type_x::value_type value_type ; const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type ret ; detail::dotc( ret, n, x_ptr, stride_x, y_ptr, stride_y ) ; return ret; } // nrm2 <- ||x||_2 template < typename vector_type > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::type_traits< typename traits::vector_traits< vector_type >::value_type >::real_type #else typename traits::type_traits< typename vector_type::value_type >::real_type #endif nrm2(const vector_type &x) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::vector_traits< vector_type >::value_type value_type; #else typedef vector_type::value_type value_type ; #endif const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const value_type *x_ptr = traits::vector_storage( x ) ; return detail::nrm2( n, x_ptr, stride_x ) ; } // asum <- ||x||_1 // .. for now works only with real vectors template < typename vector_type > #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::type_traits< typename traits::vector_traits< vector_type >::value_type >::real_type #else typename traits::type_traits< typename vector_type::value_type >::real_type #endif asum(const vector_type &x) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::vector_traits< vector_type >::value_type value_type; #else typedef vector_type::value_type value_type ; #endif const int n = traits::vector_size( x ) ; const int stride_x = traits::vector_stride( x ) ; const value_type *x_ptr = traits::vector_storage( x ) ; return detail::asum( n, x_ptr, stride_x ) ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_HPP kml_src/boost/numeric/bindings/blas/blas1_overloads.hpp000644 000765 000024 00000010704 10265665640 024253 0ustar00pawelmstaff000000 000000 // Copyright (C) Toon Knapen 2003 // // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { namespace detail { using namespace boost::numeric::bindings::traits ; // x *= alpha inline void scal(const int& n, const float& alpha, float* x, const int& incx) { BLAS_SSCAL( &n, &alpha, x , &incx ) ; } inline void scal(const int& n, const double& alpha, double* x, const int& incx) { BLAS_DSCAL( &n, &alpha, x , &incx ) ; } inline void scal(const int& n, const complex_f& alpha, complex_f* x, const int& incx) { BLAS_CSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; } inline void scal(const int& n, const complex_d& alpha, complex_d* x, const int& incx) { BLAS_ZSCAL( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx ) ; } // y += alpha * x inline void axpy(const int& n, const float & alpha, const float * x, const int& incx, float * y, const int& incy) { BLAS_SAXPY( &n, &alpha , x , &incx, y , &incy ) ; } inline void axpy(const int& n, const double & alpha, const double * x, const int& incx, double * y, const int& incy) { BLAS_DAXPY( &n, &alpha , x , &incx, y , &incy ) ; } inline void axpy(const int& n, const complex_f& alpha, const complex_f* x, const int& incx, complex_f* y, const int& incy) { BLAS_CAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } inline void axpy(const int& n, const complex_d& alpha, const complex_d* x, const int& incx, complex_d* y, const int& incy) { BLAS_ZAXPY( &n, complex_ptr( &alpha ), complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } // x^T . y inline float dot(const int& n, const float * x, const int& incx, const float * y, const int& incy) { return BLAS_SDOT( &n, x, &incx, y, &incy ) ; } inline double dot(const int& n, const double* x, const int& incx, const double* y, const int& incy) { return BLAS_DDOT( &n, x, &incx, y, &incy ) ; } // x^T . y inline void dotu(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { BLAS_CDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } inline void dotu(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { BLAS_ZDOTU( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } // x^H . y inline void dotc(complex_f& ret, const int& n, const complex_f* x, const int& incx, const complex_f* y, const int& incy) { BLAS_CDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } inline void dotc(complex_d& ret, const int& n, const complex_d* x, const int& incx, const complex_d* y, const int& incy) { BLAS_ZDOTC( complex_ptr( &ret ), &n, complex_ptr( x ), &incx, complex_ptr( y ), &incy ) ; } // euclidean norm inline float nrm2(const int& n, const float* x, const int& incx) { return BLAS_SNRM2( &n, x, &incx ) ; } inline double nrm2(const int& n, const double* x, const int& incx) { return BLAS_DNRM2( &n, x, &incx ) ; } inline float nrm2(const int& n, const complex_f* x, const int& incx) { return BLAS_SCNRM2( &n, complex_ptr(x), &incx ) ; } inline double nrm2(const int& n, const complex_d* x, const int& incx) { return BLAS_DZNRM2( &n, complex_ptr(x), &incx ) ; } // 1-norm inline float asum(const int& n, const float* x, const int& incx) { return BLAS_SASUM( &n, x, &incx ) ; } inline double asum(const int& n, const double* x, const int& incx) { return BLAS_DASUM( &n, x, &incx ) ; } inline float asum(const int& n, const complex_f* x, const int& incx) { return BLAS_SCASUM( &n, complex_ptr(x), &incx ) ; } inline double asum(const int& n, const complex_d* x, const int& incx) { return BLAS_DZASUM( &n, complex_ptr(x), &incx ) ; } }}}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS1_OVERLOADS_HPP kml_src/boost/numeric/bindings/blas/blas2.hpp000644 000765 000024 00000013313 10265665640 022175 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen and Kresimir Fresl 2003 #ifndef BOOST_BINDINGS_BLAS_BLAS2_HPP #define BOOST_BINDINGS_BLAS_BLAS2_HPP #include #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { // y <- alpha * op (A) * x + beta * y // op (A) == A || A^T || A^H // ! CAUTION this function assumes that all matrices involved are column-major matrices template < typename matrix_type, typename vector_type_x, typename vector_type_y, typename value_type > inline void gemv(const char TRANS, const value_type& alpha, const matrix_type &a, const vector_type_x &x, const value_type& beta, vector_type_y &y ) { // precondition: matrix_type must be dense or dense_proxy /* not all compilers can handle the traits BOOST_STATIC_ASSERT( ( boost::is_same< typename mtraits::matrix_structure, boost::numeric::bindings::traits::general_t >::value ) ) ; */ const int m = traits::matrix_size1( a ) ; const int n = traits::matrix_size2( a ) ; assert ( traits::vector_size( x ) >= (TRANS == traits::NO_TRANSPOSE ? n : m) ) ; assert ( traits::vector_size( y ) >= (TRANS == traits::NO_TRANSPOSE ? m : n) ) ; const int lda = traits::leading_dimension( a ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *a_ptr = traits::matrix_storage( a ) ; const value_type *x_ptr = traits::vector_storage( x ) ; value_type *y_ptr = traits::vector_storage( y ) ; detail::gemv( TRANS, m, n, alpha, a_ptr, lda, x_ptr, stride_x, beta, y_ptr, stride_y ); } // A <- alpha * x * trans(y) ( outer product ), alpha, x and y are real-valued // ! CAUTION this function assumes that all matrices involved are column-major matrices template < typename vector_type_x, typename vector_type_y, typename value_type, typename matrix_type > inline void ger( const value_type& alpha, const vector_type_x &x, const vector_type_y &y, matrix_type &a ) { // precondition: matrix_type must be dense or dense_proxy /* not all compilers can handle the traits BOOST_STATIC_ASSERT( ( boost::is_same< typename mtraits::matrix_structure, boost::numeric::bindings::traits::general_t >::value ) ) ; */ const int m = traits::matrix_size1( a ) ; const int n = traits::matrix_size2( a ) ; assert ( traits::vector_size( x ) <= m ) ; assert ( traits::vector_size( y ) <= n ) ; const int lda = traits::leading_dimension( a ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type *a_ptr = traits::matrix_storage( a ) ; detail::ger( m, n, alpha, x_ptr, stride_x, y_ptr, stride_y, a_ptr, lda ); } /* // A <- alpha * x * trans(y) ( outer product ), alpha, x and y are complex-valued template < typename vector_type_x, typename vector_type_y, typename value_type, typename matrix_type > inline void geru( const value_type& alpha, const vector_type_x &x, const vector_type_y &y, matrix_type &a ) { // precondition: matrix_type must be dense or dense_proxy // not all compilers can handle the traits // BOOST_STATIC_ASSERT( ( boost::is_same< typename mtraits::matrix_structure, // boost::numeric::bindings::traits::general_t // >::value ) ) ; // BOOST_STATIC_ASSERT( ( boost::is_same< x.value_type(), FEMTown::Complex() >::value ) ) ; const int m = traits::matrix_size1( a ) ; const int n = traits::matrix_size2( a ) ; assert ( traits::vector_size( x ) <= m ) ; assert ( traits::vector_size( y ) <= n ) ; const int lda = traits::leading_dimension( a ) ; const int stride_x = traits::vector_stride( x ) ; const int stride_y = traits::vector_stride( y ) ; const value_type *x_ptr = traits::vector_storage( x ) ; const value_type *y_ptr = traits::vector_storage( y ) ; value_type *a_ptr = traits::matrix_storage( a ) ; detail::geru( m, n, alpha, x_ptr, stride_x, y_ptr, stride_y, a_ptr, lda ); } */ /* // y <- alpha * A * x + beta * y template < typename matrix_type, typename vector_type_x, typename vector_type_y > inline void gemv(const typename traits::matrix_traits::value_type &alpha, const matrix_type &a, const vector_type_x &x, const typename traits::vector_traits::value_type &beta, vector_type_y &y ) { gemv( traits::NO_TRANSPOSE, alpha, a, x, beta, y ); } // y <- A * x template < typename matrix_type, typename vector_type_x, typename vector_type_y > inline void gemv(const matrix_type &a, const vector_type_x &x, vector_type_y &y) { typedef typename traits::matrix_traits::value_type val_t; gemv( traits::NO_TRANSPOSE, (val_t) 1, a, x, (val_t) 0, y ); } */ }}}} #endif // BOOST_BINDINGS_BLAS_BLAS2_HPP kml_src/boost/numeric/bindings/blas/blas2_overloads.hpp000644 000765 000024 00000006615 10265665640 024262 0ustar00pawelmstaff000000 000000 // Copyright (C) Toon Knapen 2003 // // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS2_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS2_OVERLOADS_HPP #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { namespace detail { using namespace boost::numeric::bindings::traits ; inline void gemv( char TRANS, const int& m, const int& n, const float & alpha, const float * a_ptr, const int& lda, const float * x_ptr, const int& incx, const float & beta, float * y_ptr, const int& incy ) { BLAS_SGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; } inline void gemv( char TRANS, const int& m, const int& n, const double & alpha, const double * a_ptr, const int& lda, const double * x_ptr, const int& incx, const double & beta, double * y_ptr, const int& incy ) { BLAS_DGEMV( &TRANS, &m, &n, ( &alpha ), ( a_ptr ), &lda, ( x_ptr ), &incx, ( &beta ), ( y_ptr ), &incy ) ; } inline void gemv( char TRANS, const int& m, const int& n, const complex_f& alpha, const complex_f* a_ptr, const int& lda, const complex_f* x_ptr, const int& incx, const complex_f& beta, complex_f* y_ptr, const int& incy ) { BLAS_CGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; } inline void gemv( char TRANS, const int& m, const int& n, const complex_d& alpha, const complex_d* a_ptr, const int& lda, const complex_d* x_ptr, const int& incx, const complex_d& beta, complex_d* y_ptr, const int& incy ) { BLAS_ZGEMV( &TRANS, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( x_ptr ), &incx, complex_ptr( &beta ), complex_ptr( y_ptr ), &incy ) ; } inline void ger( const int& m, const int& n, const float & alpha, const float * x_ptr, const int& incx, const float * y_ptr, const int& incy, float * a_ptr, const int& lda ) { BLAS_SGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; } inline void ger( const int& m, const int& n, const double & alpha, const double * x_ptr, const int& incx, const double * y_ptr, const int& incy, double * a_ptr, const int& lda ) { BLAS_DGER( &m, &n, &alpha, x_ptr, &incx, y_ptr, &incy, a_ptr, &lda ) ; } /* inline void geru( const int& m, const int& n, const complex_f & alpha, const complex_f * x_ptr, const int& incx, complex_f * y_ptr, const int& incy, complex_f * a_ptr, const int& lda ) { BLAS_CGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; } inline void geru( const int& m, const int& n, const complex_d & alpha, const complex_d * x_ptr, const int& incx, complex_d * y_ptr, const int& incy, complex_d * a_ptr, const int& lda ) { BLAS_ZGERU( &m, &n, complex_ptr( &alpha ), complex_ptr( x_ptr ), &incx, complex_ptr( y_ptr ), &incy, complex_ptr( a_ptr ), &lda ) ; } */ }}}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS2_OVERLOADS_HPP kml_src/boost/numeric/bindings/blas/blas3.hpp000644 000765 000024 00000013242 10265665640 022177 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen and Kresimir Fresl #ifndef BOOST_BINDINGS_BLAS_BLAS3_HPP #define BOOST_BINDINGS_BLAS_BLAS3_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { // C <- alpha * op (A) * op (B) + beta * C // op (X) == X || X^T || X^H template < typename value_type, typename matrix_type_a, typename matrix_type_b, typename matrix_type_c > // ! CAUTION this function assumes that all matrices involved are column-major matrices void gemm(const char TRANSA, const char TRANSB, const value_type& alpha, const matrix_type_a &a, const matrix_type_b &b, const value_type &beta, matrix_type_c &c ) { const int m = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ; const int n = TRANSB == traits::NO_TRANSPOSE ? traits::matrix_size2( b ) : traits::matrix_size1( b ); const int k = TRANSA == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ; assert( k == ( TRANSB == traits::NO_TRANSPOSE ? traits::matrix_size1( b ) : traits::matrix_size2( b ) ) ) ; assert( m == traits::matrix_size1( c ) ); assert( n == traits::matrix_size2( c ) ); const int lda = traits::leading_dimension( a ); const int ldb = traits::leading_dimension( b ); const int ldc = traits::leading_dimension( c ); const value_type *a_ptr = traits::matrix_storage( a ) ; const value_type *b_ptr = traits::matrix_storage( b ) ; value_type *c_ptr = traits::matrix_storage( c ) ; detail::gemm( TRANSA, TRANSB, m, n, k, alpha, a_ptr, lda, b_ptr, ldb, beta, c_ptr, ldc ) ; } // C <- alpha * A * B + beta * C template < typename value_type, typename matrix_type_a, typename matrix_type_b, typename matrix_type_c > void gemm(const value_type& alpha, const matrix_type_a &a, const matrix_type_b &b, const value_type &beta, matrix_type_c &c ) { gemm( traits::NO_TRANSPOSE, traits::NO_TRANSPOSE, alpha, a, b, beta, c ) ; } // C <- A * B // ! CAUTION this function assumes that all matrices involved are column-major matrices template < typename matrix_type_a, typename matrix_type_b, typename matrix_type_c > void gemm(const matrix_type_a &a, const matrix_type_b &b, matrix_type_c &c) { typedef typename traits::matrix_traits::value_type val_t; gemm( traits::NO_TRANSPOSE, traits::NO_TRANSPOSE, (val_t) 1, a, b, (val_t) 0, c ) ; } // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C template < typename value_type, typename matrix_type_a, typename matrix_type_c > void syrk( char uplo, char trans, const value_type& alpha, const matrix_type_a& a, const value_type& beta, matrix_type_c& c) { const int n = traits::matrix_size1( c ); assert( n == traits::matrix_size2( c ) ); const int k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ; assert( n == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ); const int lda = traits::leading_dimension( a ); const int ldc = traits::leading_dimension( c ); const value_type *a_ptr = traits::matrix_storage( a ) ; value_type *c_ptr = traits::matrix_storage( c ) ; detail::syrk( uplo, trans, n, k, alpha, a_ptr, lda, beta, c_ptr, ldc ); } // syrk() // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C template < typename real_type, typename matrix_type_a, typename matrix_type_c > void herk( char uplo, char trans, const real_type& alpha, const matrix_type_a& a, const real_type& beta, matrix_type_c& c) { typedef typename matrix_type_c::value_type value_type ; const int n = traits::matrix_size1( c ); assert( n == traits::matrix_size2( c ) ); const int k = trans == traits::NO_TRANSPOSE ? traits::matrix_size2( a ) : traits::matrix_size1( a ) ; assert( n == traits::NO_TRANSPOSE ? traits::matrix_size1( a ) : traits::matrix_size2( a ) ); const int lda = traits::leading_dimension( a ); const int ldc = traits::leading_dimension( c ); const value_type *a_ptr = traits::matrix_storage( a ) ; value_type *c_ptr = traits::matrix_storage( c ) ; detail::herk( uplo, trans, n, k, alpha, a_ptr, lda, beta, c_ptr, ldc ); } // herk() // B <- alpha * op( A^-1 ) // B <- alpha * B op( A^-1 ) // op( A ) = A, A^T, A^H template < class T, class A, class B > void trsm( char side, char uplo, char transa, char diag, T const& alpha, A const& a, B& b ) { const int m = traits::matrix_size1( b ) ; const int n = traits::matrix_size2( b ) ; assert( ( side=='L' && m==traits::matrix_size2( a ) && m==traits::matrix_size1( a ) ) || ( side=='R' && n==traits::matrix_size2( a ) && n==traits::matrix_size1( a ) ) ) ; assert( side=='R' || side=='L' ) ; assert( uplo=='U' || uplo=='L' ) ; assert( ( side=='L' && m==traits::matrix_size1( a ) ) || ( side=='R' && n==traits::matrix_size1( a ) ) ) ; detail::trsm( side, uplo, transa, diag, m, n, alpha, traits::matrix_storage( a ), traits::leading_dimension( a ), traits::matrix_storage( b ), traits::leading_dimension( b ) ) ; } }}}} #endif // BOOST_BINDINGS_BLAS_BLAS3_HPP kml_src/boost/numeric/bindings/blas/blas3_overloads.hpp000644 000765 000024 00000014416 10265665640 024261 0ustar00pawelmstaff000000 000000 // Copyright (C) Toon Knapen 2003 // // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP #include #include namespace boost { namespace numeric { namespace bindings { namespace blas { namespace detail { using namespace boost::numeric::bindings::traits ; inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const float & alpha, const float * a_ptr, const int& lda, const float * b_ptr, const int& ldb, const float & beta, float * c_ptr, const int& ldc ) { BLAS_SGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; } inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const double & alpha, const double * a_ptr, const int& lda, const double * b_ptr, const int& ldb, const double & beta, double * c_ptr, const int& ldc ) { BLAS_DGEMM( &TRANSA, &TRANSB, &m, &n, &k, ( &alpha ), ( a_ptr ), &lda, ( b_ptr ), &ldb, ( &beta ), ( c_ptr ), &ldc ) ; } inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const complex_f& alpha, const complex_f* a_ptr, const int& lda, const complex_f* b_ptr, const int& ldb, const complex_f& beta, complex_f* c_ptr, const int& ldc ) { BLAS_CGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; } inline void gemm( char TRANSA, char TRANSB, const int& m, const int& n, const int& k, const complex_d& alpha, const complex_d* a_ptr, const int& lda, const complex_d* b_ptr, const int& ldb, const complex_d& beta, complex_d* c_ptr, const int& ldc ) { BLAS_ZGEMM( &TRANSA, &TRANSB, &m, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc ) ; } // // SYRK // inline void syrk( char uplo, char trans, const int& n, const int& k, const float& alpha, const float* a_ptr, const int lda, const float& beta, float* c_ptr, const int& ldc) { BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void syrk( char uplo, char trans, const int& n, const int& k, const double& alpha, const double* a_ptr, const int lda, const double& beta, double* c_ptr, const int& ldc) { BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void syrk( char uplo, char trans, const int& n, const int& k, const complex_f& alpha, const complex_f* a_ptr, const int lda, const complex_f& beta, complex_f* c_ptr, const int& ldc) { BLAS_CSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc); } inline void syrk( char uplo, char trans, const int& n, const int& k, const complex_d& alpha, const complex_d* a_ptr, const int lda, const complex_d& beta, complex_d* c_ptr, const int& ldc) { BLAS_ZSYRK( &uplo, &trans, &n, &k, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( &beta ), complex_ptr( c_ptr ), &ldc); } // // HERK // inline void herk( char uplo, char trans, const int& n, const int& k, const float& alpha, const float* a_ptr, const int lda, const float& beta, float* c_ptr, const int& ldc) { BLAS_SSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void herk( char uplo, char trans, const int& n, const int& k, const double& alpha, const double* a_ptr, const int lda, const double& beta, double* c_ptr, const int& ldc) { BLAS_DSYRK( &uplo, &trans, &n, &k, &alpha, a_ptr, &lda, &beta, c_ptr, &ldc); } inline void herk( char uplo, char trans, const int& n, const int& k, const float& alpha, const complex_f* a_ptr, const int lda, const float& beta, complex_f* c_ptr, const int& ldc) { BLAS_CHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ), &lda, &beta, complex_ptr( c_ptr ), &ldc); } inline void herk( char uplo, char trans, const int& n, const int& k, const double& alpha, const complex_d* a_ptr, const int lda, const double& beta, complex_d* c_ptr, const int& ldc) { BLAS_ZHERK( &uplo, &trans, &n, &k, &alpha, complex_ptr( a_ptr ), &lda, &beta, complex_ptr( c_ptr ), &ldc); } // // trsm // inline void trsm( char side, char uplo, char transa, char diag, int m, int n, float const& alpha, float const* a_ptr, int lda, float* b_ptr, int ldb ) { BLAS_STRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ; } inline void trsm( char side, char uplo, char transa, char diag, int m, int n, double const& alpha, double const* a_ptr, int lda, double* b_ptr, int ldb ) { BLAS_DTRSM( &side, &uplo, &transa, &diag, &m, &n, &alpha, a_ptr, &lda, b_ptr, &ldb ) ; } inline void trsm( char side, char uplo, char transa, char diag, int m, int n, complex_f const& alpha, complex_f const* a_ptr, int lda, complex_f* b_ptr, int ldb ) { BLAS_CTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ; } inline void trsm( char side, char uplo, char transa, char diag, int m, int n, complex_d const& alpha, complex_d const* a_ptr, int lda, complex_d* b_ptr, int ldb ) { BLAS_ZTRSM( &side, &uplo, &transa, &diag, &m, &n, complex_ptr( &alpha ), complex_ptr( a_ptr ), &lda, complex_ptr( b_ptr ), &ldb ) ; } }}}}} #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS3_OVERLOADS_HPP kml_src/boost/numeric/bindings/blas/blas_names.h000644 000765 000024 00000005000 10265665640 022730 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright (C) 2002, 2003 Si-Lab b.v.b.a and Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H #define BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H #include // // level 1 // #define BLAS_SSCAL FORTRAN_ID( sscal ) #define BLAS_DSCAL FORTRAN_ID( dscal ) #define BLAS_CSCAL FORTRAN_ID( cscal ) #define BLAS_ZSCAL FORTRAN_ID( zscal ) #define BLAS_SAXPY FORTRAN_ID( saxpy ) #define BLAS_DAXPY FORTRAN_ID( daxpy ) #define BLAS_CAXPY FORTRAN_ID( caxpy ) #define BLAS_ZAXPY FORTRAN_ID( zaxpy ) #define BLAS_SDOT FORTRAN_ID( sdot ) #define BLAS_DDOT FORTRAN_ID( ddot ) #define BLAS_CDOTU FORTRAN_ID( cdotu ) #define BLAS_ZDOTU FORTRAN_ID( zdotu ) #define BLAS_CDOTC FORTRAN_ID( cdotc ) #define BLAS_ZDOTC FORTRAN_ID( zdotc ) #define BLAS_SNRM2 FORTRAN_ID( snrm2 ) #define BLAS_DNRM2 FORTRAN_ID( dnrm2 ) #define BLAS_SCNRM2 FORTRAN_ID( scnrm2 ) #define BLAS_DZNRM2 FORTRAN_ID( dznrm2 ) #define BLAS_SASUM FORTRAN_ID( sasum ) #define BLAS_DASUM FORTRAN_ID( dasum ) #define BLAS_SCASUM FORTRAN_ID( scasum ) #define BLAS_DZASUM FORTRAN_ID( dzasum ) #define BLAS_SCOPY FORTRAN_ID( scopy ) #define BLAS_DCOPY FORTRAN_ID( dcopy ) #define BLAS_CCOPY FORTRAN_ID( ccopy ) #define BLAS_ZCOPY FORTRAN_ID( zcopy ) // // level 2 // #define BLAS_SGEMV FORTRAN_ID( sgemv ) #define BLAS_DGEMV FORTRAN_ID( dgemv ) #define BLAS_CGEMV FORTRAN_ID( cgemv ) #define BLAS_ZGEMV FORTRAN_ID( zgemv ) #define BLAS_SGER FORTRAN_ID( sger ) #define BLAS_DGER FORTRAN_ID( dger ) #define BLAS_CGERU FORTRAN_ID( cgeru ) #define BLAS_ZGERU FORTRAN_ID( zgeru ) #define BLAS_CGERC FORTRAN_ID( cgerc ) #define BLAS_ZGERC FORTRAN_ID( zgerc ) // // level 3 // #define BLAS_SGEMM FORTRAN_ID( sgemm ) #define BLAS_DGEMM FORTRAN_ID( dgemm ) #define BLAS_CGEMM FORTRAN_ID( cgemm ) #define BLAS_ZGEMM FORTRAN_ID( zgemm ) #define BLAS_SSYRK FORTRAN_ID( ssyrk ) #define BLAS_DSYRK FORTRAN_ID( dsyrk ) #define BLAS_CSYRK FORTRAN_ID( csyrk ) #define BLAS_ZSYRK FORTRAN_ID( zsyrk ) #define BLAS_CHERK FORTRAN_ID( cherk ) #define BLAS_ZHERK FORTRAN_ID( zherk ) #define BLAS_STRSM FORTRAN_ID( strsm ) #define BLAS_DTRSM FORTRAN_ID( dtrsm ) #define BLAS_CTRSM FORTRAN_ID( ctrsm ) #define BLAS_ZTRSM FORTRAN_ID( ztrsm ) #endif // BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H kml_src/boost/numeric/bindings/atlas/cblas.h000644 000765 000024 00000102147 10327225052 022071 0ustar00pawelmstaff000000 000000 #ifndef CBLAS_H #ifndef CBLAS_ENUM_DEFINED_H #define CBLAS_ENUM_DEFINED_H enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102 }; enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113, AtlasConj=114}; enum CBLAS_UPLO {CblasUpper=121, CblasLower=122}; enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132}; enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}; #endif #ifndef CBLAS_ENUM_ONLY #define CBLAS_H #define CBLAS_INDEX int int cblas_errprn(int ierr, int info, char *form, ...); /* * =========================================================================== * Prototypes for level 1 BLAS functions (complex are recast as routines) * =========================================================================== */ float cblas_sdsdot(const int N, const float alpha, const float *X, const int incX, const float *Y, const int incY); double cblas_dsdot(const int N, const float *X, const int incX, const float *Y, const int incY); float cblas_sdot(const int N, const float *X, const int incX, const float *Y, const int incY); double cblas_ddot(const int N, const double *X, const int incX, const double *Y, const int incY); /* * Functions having prefixes Z and C only */ void cblas_cdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu); void cblas_cdotc_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotc); void cblas_zdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu); void cblas_zdotc_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotc); /* * Functions having prefixes S D SC DZ */ float cblas_snrm2(const int N, const float *X, const int incX); float cblas_sasum(const int N, const float *X, const int incX); double cblas_dnrm2(const int N, const double *X, const int incX); double cblas_dasum(const int N, const double *X, const int incX); float cblas_scnrm2(const int N, const void *X, const int incX); float cblas_scasum(const int N, const void *X, const int incX); double cblas_dznrm2(const int N, const void *X, const int incX); double cblas_dzasum(const int N, const void *X, const int incX); /* * Functions having standard 4 prefixes (S D C Z) */ CBLAS_INDEX cblas_isamax(const int N, const float *X, const int incX); CBLAS_INDEX cblas_idamax(const int N, const double *X, const int incX); CBLAS_INDEX cblas_icamax(const int N, const void *X, const int incX); CBLAS_INDEX cblas_izamax(const int N, const void *X, const int incX); /* * =========================================================================== * Prototypes for level 1 BLAS routines * =========================================================================== */ /* * Routines with standard 4 prefixes (s, d, c, z) */ void cblas_sswap(const int N, float *X, const int incX, float *Y, const int incY); void cblas_scopy(const int N, const float *X, const int incX, float *Y, const int incY); void cblas_saxpy(const int N, const float alpha, const float *X, const int incX, float *Y, const int incY); void catlas_saxpby(const int N, const float alpha, const float *X, const int incX, const float beta, float *Y, const int incY); void catlas_sset (const int N, const float alpha, float *X, const int incX); void cblas_dswap(const int N, double *X, const int incX, double *Y, const int incY); void cblas_dcopy(const int N, const double *X, const int incX, double *Y, const int incY); void cblas_daxpy(const int N, const double alpha, const double *X, const int incX, double *Y, const int incY); void catlas_daxpby(const int N, const double alpha, const double *X, const int incX, const double beta, double *Y, const int incY); void catlas_dset (const int N, const double alpha, double *X, const int incX); void cblas_cswap(const int N, void *X, const int incX, void *Y, const int incY); void cblas_ccopy(const int N, const void *X, const int incX, void *Y, const int incY); void cblas_caxpy(const int N, const void *alpha, const void *X, const int incX, void *Y, const int incY); void catlas_caxpby(const int N, const void *alpha, const void *X, const int incX, const void *beta, void *Y, const int incY); void catlas_cset (const int N, const void *alpha, void *X, const int incX); void cblas_zswap(const int N, void *X, const int incX, void *Y, const int incY); void cblas_zcopy(const int N, const void *X, const int incX, void *Y, const int incY); void cblas_zaxpy(const int N, const void *alpha, const void *X, const int incX, void *Y, const int incY); void catlas_zaxpby(const int N, const void *alpha, const void *X, const int incX, const void *beta, void *Y, const int incY); void catlas_zset (const int N, const void *alpha, void *X, const int incX); /* * Routines with S and D prefix only */ void cblas_srotg(float *a, float *b, float *c, float *s); void cblas_srotmg(float *d1, float *d2, float *b1, const float b2, float *P); void cblas_srot(const int N, float *X, const int incX, float *Y, const int incY, const float c, const float s); void cblas_srotm(const int N, float *X, const int incX, float *Y, const int incY, const float *P); void cblas_drotg(double *a, double *b, double *c, double *s); void cblas_drotmg(double *d1, double *d2, double *b1, const double b2, double *P); void cblas_drot(const int N, double *X, const int incX, double *Y, const int incY, const double c, const double s); void cblas_drotm(const int N, double *X, const int incX, double *Y, const int incY, const double *P); /* * Routines with S D C Z CS and ZD prefixes */ void cblas_sscal(const int N, const float alpha, float *X, const int incX); void cblas_dscal(const int N, const double alpha, double *X, const int incX); void cblas_cscal(const int N, const void *alpha, void *X, const int incX); void cblas_zscal(const int N, const void *alpha, void *X, const int incX); void cblas_csscal(const int N, const float alpha, void *X, const int incX); void cblas_zdscal(const int N, const double alpha, void *X, const int incX); /* * Extra reference routines provided by ATLAS, but not mandated by the standard */ void cblas_crotg(void *a, void *b, void *c, void *s); void cblas_zrotg(void *a, void *b, void *c, void *s); void cblas_csrot(const int N, void *X, const int incX, void *Y, const int incY, const float c, const float s); void cblas_zdrot(const int N, void *X, const int incX, void *Y, const int incY, const double c, const double s); /* * =========================================================================== * Prototypes for level 2 BLAS * =========================================================================== */ /* * Routines with standard 4 prefixes (S, D, C, Z) */ void cblas_sgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, 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); void cblas_sgbmv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, 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); void cblas_strmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *A, const int lda, float *X, const int incX); void cblas_stbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const float *A, const int lda, float *X, const int incX); void cblas_stpmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *Ap, float *X, const int incX); void cblas_strsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *A, const int lda, float *X, const int incX); void cblas_stbsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const float *A, const int lda, float *X, const int incX); void cblas_stpsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *Ap, float *X, const int incX); void cblas_dgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, 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); void cblas_dgbmv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, 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); void cblas_dtrmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *A, const int lda, double *X, const int incX); void cblas_dtbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const double *A, const int lda, double *X, const int incX); void cblas_dtpmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *Ap, double *X, const int incX); void cblas_dtrsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *A, const int lda, double *X, const int incX); void cblas_dtbsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const double *A, const int lda, double *X, const int incX); void cblas_dtpsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *Ap, double *X, const int incX); void cblas_cgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_cgbmv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const int KL, const int KU, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_ctrmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ctbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ctpmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); void cblas_ctrsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ctbsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ctpsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); void cblas_zgemv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zgbmv(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const int KL, const int KU, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_ztrmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ztbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ztpmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); void cblas_ztrsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ztbsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ztpsv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); /* * Routines with S and D prefixes only */ void cblas_ssymv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO 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); void cblas_ssbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO 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); void cblas_sspmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *Ap, const float *X, const int incX, const float beta, float *Y, const int incY); void cblas_sger(const enum CBLAS_ORDER 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); void cblas_ssyr(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, float *A, const int lda); void cblas_sspr(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, float *Ap); void cblas_ssyr2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, const float *Y, const int incY, float *A, const int lda); void cblas_sspr2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, const float *Y, const int incY, float *A); void cblas_dsymv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO 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); void cblas_dsbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO 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); void cblas_dspmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *Ap, const double *X, const int incX, const double beta, double *Y, const int incY); void cblas_dger(const enum CBLAS_ORDER 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); void cblas_dsyr(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, double *A, const int lda); void cblas_dspr(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, double *Ap); void cblas_dsyr2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, const double *Y, const int incY, double *A, const int lda); void cblas_dspr2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, const double *Y, const int incY, double *A); /* * Routines with C and Z prefixes only */ void cblas_chemv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_chbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int K, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_chpmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *Ap, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_cgeru(const enum CBLAS_ORDER Order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_cgerc(const enum CBLAS_ORDER Order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_cher(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const void *X, const int incX, void *A, const int lda); void cblas_chpr(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const void *X, const int incX, void *A); void cblas_cher2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_chpr2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *Ap); void cblas_zhemv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zhbmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int K, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zhpmv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *Ap, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zgeru(const enum CBLAS_ORDER Order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_zgerc(const enum CBLAS_ORDER Order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_zher(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const void *X, const int incX, void *A, const int lda); void cblas_zhpr(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const void *X, const int incX, void *A); void cblas_zher2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_zhpr2(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *Ap); /* * =========================================================================== * Prototypes for level 3 BLAS * =========================================================================== */ /* * Routines with standard 4 prefixes (S, D, C, Z) */ void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE 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); void cblas_ssymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO 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); void cblas_ssyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const float alpha, const float *A, const int lda, const float beta, float *C, const int ldc); void cblas_ssyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE 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); void cblas_strmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const float alpha, const float *A, const int lda, float *B, const int ldb); void cblas_strsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const float alpha, const float *A, const int lda, float *B, const int ldb); void cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE 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); void cblas_dsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO 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); void cblas_dsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const double alpha, const double *A, const int lda, const double beta, double *C, const int ldc); void cblas_dsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE 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); void cblas_dtrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const double alpha, const double *A, const int lda, double *B, const int ldb); void cblas_dtrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const double alpha, const double *A, const int lda, double *B, const int ldb); void cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_csymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_csyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *beta, void *C, const int ldc); void cblas_csyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_ctrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); void cblas_ctrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); void cblas_zgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_zsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_zsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *beta, void *C, const int ldc); void cblas_zsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_ztrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); void cblas_ztrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); /* * Routines with prefixes C and Z only */ void cblas_chemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_cherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const float alpha, const void *A, const int lda, const float beta, void *C, const int ldc); void cblas_cher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const float beta, void *C, const int ldc); void cblas_zhemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_zherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const double alpha, const void *A, const int lda, const double beta, void *C, const int ldc); void cblas_zher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const double beta, void *C, const int ldc); int cblas_errprn(int ierr, int info, char *form, ...); #endif /* end #ifdef CBLAS_ENUM_ONLY */ #endif kml_src/boost/numeric/bindings/atlas/cblas.hpp000644 000765 000024 00000001361 10265665640 022441 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_HPP #include #include #include #endif kml_src/boost/numeric/bindings/atlas/cblas1.hpp000644 000765 000024 00000030135 10265665640 022523 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_1_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_1_HPP #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_TYPE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { // x_i <- alpha for all i template inline void set (T const& alpha, Vct& x) { detail::set (traits::vector_size (x), alpha, traits::vector_storage (x), traits::vector_stride (x)); } // y <- x template inline void copy (VctX const& x, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::copy (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::vector_storage (y), traits::vector_stride (y)); } // x <-> y template inline void swap (VctX& x, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::swap (traits::vector_size (x), traits::vector_storage (x), traits::vector_stride (x), traits::vector_storage (y), traits::vector_stride (y)); } // x <- alpha * x template inline void scal (T const& alpha, Vct& x) { #ifndef BOOST_NUMERIC_BINDINGS_NO_TYPE_CHECK typedef traits::vector_traits vtraits; BOOST_STATIC_ASSERT( (boost::is_same::value || boost::is_same::real_type >::value )); #endif detail::scal (traits::vector_size (x), alpha, traits::vector_storage (x), traits::vector_stride (x)); } // y <- alpha * x + y template inline void axpy (T const& alpha, VctX const& x, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::axpy (traits::vector_size (x), alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::vector_storage (y), traits::vector_stride (y)); } // y <- x + y template inline void xpy (VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::vector_traits::value_type val_t; #else typedef typename VctX::value_type val_t; #endif axpy ((val_t) 1, x, y); } // y <- alpha * x + beta * y template inline void axpby (T const& alpha, VctX const& x, T const& beta, VctY& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::axpby (traits::vector_size (x), alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } /////////////////////////////////////////// // dot <- x^T * y // .. real & complex types template inline #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename VctX::value_type #endif dot (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); return detail::dot (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y)); } // dot <- x^T * y // .. float only -- with double accumulation template inline double dsdot (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); return cblas_dsdot (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y)); } // apdot <- alpha + x^T * y // .. float only -- computation uses double precision template inline float sdsdot (float const alpha, VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); return cblas_sdsdot (traits::vector_size (x), alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y)); } // dotu <- x^T * y // .. complex types only // .. function template inline #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename VctX::value_type #endif dotu (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type val; #else typename VctX::value_type val; #endif detail::dotu (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); return val; } // .. procedure template inline void dotu (VctX const& x, VctY const& y, #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type& val #else typename VctX::value_type& val #endif ) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::dotu (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); } // dotc <- x^H * y // .. complex types only // .. function template inline #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename VctX::value_type #endif dotc (VctX const& x, VctY const& y) { assert (traits::vector_size (y) >= traits::vector_size (x)); #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type val; #else typename VctX::value_type val; #endif detail::dotc (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); return val; } // .. procedure template inline void dotc (VctX const& x, VctY const& y, #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type& val #else typename VctX::value_type& val #endif ) { assert (traits::vector_size (y) >= traits::vector_size (x)); detail::dotc (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), &val); } // nrm2 <- ||x||_2 template inline typename traits::type_traits< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename Vct::value_type #endif >::real_type nrm2 (Vct const& x) { return detail::nrm2 (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x)); } // asum <- ||re (x)|| + ||im (x)|| template inline typename traits::type_traits< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::vector_traits::value_type #else typename Vct::value_type #endif >::real_type asum (Vct const& x) { return detail::asum (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x)); } // iamax <- 1st i: max (|re (x_i)| + |im (x_i)|) template inline CBLAS_INDEX iamax (Vct const& x) { return detail::iamax (traits::vector_size (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x)); } // TO DO: plane rotations } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_1_HPP kml_src/boost/numeric/bindings/atlas/cblas1_overloads.hpp000644 000765 000024 00000027633 10265665640 024612 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS1_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS1_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // dot <- x^T * y // .. real types: calls cblas_xdot // .. complex types: calls cblas_xdotu inline float dot (int const N, float const* X, int const incX, float const* Y, int const incY) { return cblas_sdot (N, X, incX, Y, incY); } inline double dot (int const N, double const* X, int const incX, double const* Y, int const incY) { return cblas_ddot (N, X, incX, Y, incY); } inline traits::complex_f dot (int const N, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY) { traits::complex_f val; cblas_cdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (&val)); return val; } inline traits::complex_d dot (int const N, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY) { traits::complex_d val; cblas_zdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (&val)); return val; } // dotu <- x^T * y // .. complex types only inline void dotu (int const N, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* val) { cblas_cdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } inline void dotu (int const N, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* val) { cblas_zdotu_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } // dotc <- x^H * y // .. complex types only inline void dotc (int const N, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* val) { cblas_cdotc_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } inline void dotc (int const N, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* val) { cblas_zdotc_sub (N, static_cast (X), incX, static_cast (Y), incY, static_cast (val)); } // nrm2 <- ||x||_2 inline float nrm2 (int const N, float const* X, int const incX) { return cblas_snrm2 (N, X, incX); } inline double nrm2 (int const N, double const* X, int const incX) { return cblas_dnrm2 (N, X, incX); } inline float nrm2 (int const N, traits::complex_f const* X, int const incX) { return cblas_scnrm2 (N, static_cast (X), incX); } inline double nrm2 (int const N, traits::complex_d const* X, int const incX) { return cblas_dznrm2 (N, static_cast (X), incX); } // asum <- ||re (x)|| + ||im (x)|| inline float asum (int const N, float const* X, int const incX) { return cblas_sasum (N, X, incX); } inline double asum (int const N, double const* X, int const incX) { return cblas_dasum (N, X, incX); } inline float asum (int const N, traits::complex_f const* X, int const incX) { return cblas_scasum (N, static_cast (X), incX); } inline double asum (int const N, traits::complex_d const* X, int const incX) { return cblas_dzasum (N, static_cast (X), incX); } // iamax <- 1st i: max (|re (x_i)| + |im (x_i)|) inline CBLAS_INDEX iamax (int const N, float const* X, int const incX) { return cblas_isamax (N, X, incX); } inline CBLAS_INDEX iamax (int const N, double const* X, int const incX) { return cblas_idamax (N, X, incX); } inline CBLAS_INDEX iamax (int const N, traits::complex_f const* X, int const incX) { return cblas_icamax (N, static_cast (X), incX); } inline CBLAS_INDEX iamax (int const N, traits::complex_d const* X, int const incX) { return cblas_izamax (N, static_cast (X), incX); } // x <-> y inline void swap (int const N, float* X, int const incX, float* Y, int const incY) { cblas_sswap (N, X, incX, Y, incY); } inline void swap (int const N, double* X, int const incX, double* Y, int const incY) { cblas_dswap (N, X, incX, Y, incY); } inline void swap (int const N, traits::complex_f* X, int const incX, traits::complex_f* Y, int const incY) { cblas_cswap (N, static_cast (X), incX, static_cast (Y), incY); } inline void swap (int const N, traits::complex_d* X, int const incX, traits::complex_d* Y, int const incY) { cblas_zswap (N, static_cast (X), incX, static_cast (Y), incY); } // y <- x inline void copy (int const N, float const* X, int const incX, float* Y, int const incY) { cblas_scopy (N, X, incX, Y, incY); } inline void copy (int const N, double const* X, int const incX, double* Y, int const incY) { cblas_dcopy (N, X, incX, Y, incY); } inline void copy (int const N, traits::complex_f const* X, int const incX, traits::complex_f* Y, int const incY) { cblas_ccopy (N, static_cast (X), incX, static_cast (Y), incY); } inline void copy (int const N, traits::complex_d const* X, int const incX, traits::complex_d* Y, int const incY) { cblas_zcopy (N, static_cast (X), incX, static_cast (Y), incY); } // y <- alpha * x + y inline void axpy (int const N, float const alpha, float const* X, int const incX, float* Y, int const incY) { cblas_saxpy (N, alpha, X, incX, Y, incY); } inline void axpy (int const N, double const alpha, double const* X, int const incX, double* Y, int const incY) { cblas_daxpy (N, alpha, X, incX, Y, incY); } inline void axpy (int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f* Y, int const incY) { cblas_caxpy (N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY); } inline void axpy (int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d* Y, int const incY) { cblas_zaxpy (N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY); } // y <- alpha * x + beta * y inline void axpby (int const N, float const alpha, float const* X, int const incX, float const beta, float* Y, int const incY) { catlas_saxpby (N, alpha, X, incX, beta, Y, incY); } inline void axpby (int const N, double const alpha, double const* X, int const incX, double const beta, double* Y, int const incY) { catlas_daxpby (N, alpha, X, incX, beta, Y, incY); } inline void axpby (int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { catlas_caxpby (N, static_cast (&alpha), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void axpby (int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { catlas_zaxpby (N, static_cast (&alpha), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // x_i <- alpha for all i inline void set (int const N, float const alpha, float* X, int const incX) { catlas_sset (N, alpha, X, incX); } inline void set (int const N, double const alpha, double* X, int const incX) { catlas_dset (N, alpha, X, incX); } inline void set (int const N, traits::complex_f const& alpha, traits::complex_f* X, int const incX) { catlas_cset (N, static_cast (&alpha), static_cast (X), incX); } inline void set (int const N, traits::complex_d const& alpha, traits::complex_d* X, int const incX) { catlas_zset (N, static_cast (&alpha), static_cast (X), incX); } // x <- alpha * x inline void scal (int const N, float const alpha, float* X, int const incX) { cblas_sscal (N, alpha, X, incX); } inline void scal (int const N, double const alpha, double* X, int const incX) { cblas_dscal (N, alpha, X, incX); } inline void scal (int const N, traits::complex_f const& alpha, traits::complex_f* X, int const incX) { cblas_cscal (N, static_cast (&alpha), static_cast (X), incX); } inline void scal (int const N, float const alpha, traits::complex_f* X, int const incX) { cblas_csscal (N, alpha, static_cast (X), incX); } inline void scal (int const N, traits::complex_d const& alpha, traits::complex_d* X, int const incX) { cblas_zscal (N, static_cast (&alpha), static_cast (X), incX); } inline void scal (int const N, double const alpha, traits::complex_d* X, int const incX) { cblas_zdscal (N, alpha, static_cast (X), incX); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS1_OVERLOADS_HPP kml_src/boost/numeric/bindings/atlas/cblas2.hpp000644 000765 000024 00000125133 10265665640 022527 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002, 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_2_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_2_HPP #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { // y <- alpha * op (A) * x + beta * y // op (A) == A || A^T || A^H template inline void gemv (CBLAS_TRANSPOSE const TransA, T const& alpha, Matr const& a, VctX const& x, T const& beta, VctY& y ) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= (TransA == CblasNoTrans ? n : m)); assert (traits::vector_size (y) >= (TransA == CblasNoTrans ? m : n)); // .. what about AtlasConj? CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::gemv (stor_ord, TransA, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- alpha * A * x + beta * y template inline void gemv (T const& alpha, Matr const& a, VctX const& x, T const& beta, VctY& y) { gemv (CblasNoTrans, alpha, a, x, beta, y); } // y <- A * x template inline void gemv (Matr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif gemv (CblasNoTrans, (val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A real symmetric matrix (T == float | double) // [from 'dsymv.f':] /* [...] with UPLO = 'U' or 'u', the leading n by n upper * triangular part of the array A must contain the upper triangular * part of the symmetric matrix and the strictly lower triangular * part of A is not referenced. * [...] with UPLO = 'L' or 'l', the leading n by n lower * triangular part of the array A must contain the lower triangular * part of the symmetric matrix and the strictly upper * triangular part of A is not referenced. */ template inline void symv (CBLAS_UPLO const uplo, T const& alpha, SymmMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmMatr::orientation_category #endif >::value); detail::symv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } template inline void symv (T const& alpha, SymmMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmMatr::packed_category #endif >::value); detail::symv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void symv (SymmMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmMatr::value_type val_t; #endif symv ((val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A real symmetric matrix (T == float | double) in packed form // [from 'dspmv.f' (description assumes column major order):] /* A is an array of DIMENSION ( ( n*( n + 1 ) )/2 ). * Before entry with UPLO = 'U' or 'u', the array A must contain * the upper triangular part of the symmetric matrix packed * sequentially, column by column, so that A( 1 ) contains a(1,1), * A( 2 ) and A( 3 ) contain a(1,2) and a(2,2) respectively, and * so on. * Before entry with UPLO = 'L' or 'l', the array A must contain * the lower triangular part of the symmetric matrix packed * sequentially, column by column, so that A( 1 ) contains a(1,1), * A( 2 ) and A( 3 ) contain a(2,1) and a(3,1) respectively, and * so on. */ template inline void spmv (T const& alpha, SymmMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmMatr::packed_category #endif >::value); detail::spmv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (x), #else traits::matrix_storage_const (a), traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void spmv (SymmMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmMatr::value_type val_t; #endif spmv ((val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A complex hermitian matrix // (T == std::complex | std::complex) template inline void hemv (CBLAS_UPLO const uplo, T const& alpha, HermMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermMatr::orientation_category #endif >::value); detail::hemv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } template inline void hemv (T const& alpha, HermMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermMatr::packed_category #endif >::value); detail::hemv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void hemv (HermMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermMatr::value_type val_t; #endif hemv ((val_t) 1, a, x, (val_t) 0, y); } // y <- alpha * A * x + beta * y // A complex hermitian matrix in packed form // (T == std::complex | std::complex) template inline void hpmv (T const& alpha, HermMatr const& a, VctX const& x, T const& beta, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermMatr::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermMatr::packed_category #endif >::value); detail::hpmv (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), traits::vector_storage (x), #else traits::matrix_storage_const (a), traits::vector_storage_const (x), #endif traits::vector_stride (x), beta, traits::vector_storage (y), traits::vector_stride (y)); } // y <- A * x template inline void hpmv (HermMatr const& a, VctX const& x, VctY& y) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermMatr::value_type val_t; #endif hpmv ((val_t) 1, a, x, (val_t) 0, y); } // A <- alpha * x * y^T + A // .. real & complex types template inline void ger (T const& alpha, VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= m); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::ger (stor_ord, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^T + A template inline void ger (VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif ger ((val_t) 1, x, y, a); } // A <- alpha * x * y^T + A // .. complex types only template inline void geru (T const& alpha, VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= m); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::geru (stor_ord, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^T + A template inline void geru (VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif geru ((val_t) 1, x, y, a); } // A <- alpha * x * y^H + A // .. complex types only template inline void gerc (T const& alpha, VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (x) >= m); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename Matr::orientation_category #endif >::value); detail::gerc (stor_ord, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^H + A template inline void gerc (VctX const& x, VctY const& y, Matr& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename Matr::value_type val_t; #endif gerc ((val_t) 1, x, y, a); } // A <- alpha * x * x^T + A // A real symmetric (see leading comments for 'symv()') template inline void syr (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); detail::syr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void syr (T const& alpha, VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::syr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * x^T + A template inline void syr (VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif syr ((val_t) 1, x, a); } // A <- alpha * x * x^T + A // A real symmetric in packed form (see leading comments for 'spmv()') template inline void spr (T const& alpha, VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::spr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a)); } // A <- x * x^T + A template inline void spr (VctX const& x, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif spr ((val_t) 1, x, a); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric (see leading comments for 'symv()') template inline void syr2 (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); detail::syr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void syr2 (T const& alpha, VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::syr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^T + y * x^T + A template inline void syr2 (VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif syr2 ((val_t) 1, x, y, a); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric in packed form (see leading comments for 'spmv()') template inline void spr2 (T const& alpha, VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmM::packed_category #endif >::value); detail::spr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a)); } // A <- x * y^T + y * x^T + A template inline void spr2 (VctX const& x, VctY const& y, SymmM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmM::value_type val_t; #endif spr2 ((val_t) 1, x, y, a); } // A <- alpha * x * x^H + A // A hermitian template inline void her (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); detail::her (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void her (T const& alpha, VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::her (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * x^H + A template inline void her (VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; her ((real_t) 1, x, a); } // A <- alpha * x * x^H + A // A hermitian in packed form template inline void hpr (T const& alpha, VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::hpr (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), traits::matrix_storage (a)); } // A <- x * x^H + A template inline void hpr (VctX const& x, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; hpr ((real_t) 1, x, a); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian template inline void her2 (CBLAS_UPLO const uplo, T const& alpha, VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); detail::her2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } template inline void her2 (T const& alpha, VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::her2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a), traits::leading_dimension (a)); } // A <- x * y^H + y * x^H + A template inline void her2 (VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif her2 ((val_t) 1, x, y, a); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian in packed form template inline void hpr2 (T const& alpha, VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_packed_t >::value)); #endif int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (x) >= n); assert (traits::vector_size (y) >= n); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermM::orientation_category #endif >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermM::packed_category #endif >::value); detail::hpr2 (stor_ord, uplo, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (x), #else traits::vector_storage_const (x), #endif traits::vector_stride (x), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (y), #else traits::vector_storage_const (y), #endif traits::vector_stride (y), traits::matrix_storage (a)); } // A <- x * y^H + y * x^H + A template inline void hpr2 (VctX const& x, VctY const& y, HermM& a) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermM::value_type val_t; #endif hpr2 ((val_t) 1, x, y, a); } } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_2_HPP kml_src/boost/numeric/bindings/atlas/cblas2_overloads.hpp000644 000765 000024 00000044213 10265665640 024604 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002, 2003 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS2_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS2_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // y <- alpha * op (A) * x + beta * y inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, float const alpha, float const* A, int const lda, float const* X, int const incX, float const beta, float* Y, int const incY) { cblas_sgemv (Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); } inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, double const alpha, double const* A, int const lda, double const* X, int const incX, double const beta, double* Y, int const incY) { cblas_dgemv (Order, TransA, M, N, alpha, A, lda, X, incX, beta, Y, incY); } inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { cblas_cgemv (Order, TransA, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void gemv (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { cblas_zgemv (Order, TransA, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // y <- alpha * A * x + beta * y // A real symmetric inline void symv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* A, int const lda, float const* X, int const incX, float const beta, float* Y, int const incY) { cblas_ssymv (Order, Uplo, N, alpha, A, lda, X, incX, beta, Y, incY); } inline void symv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* A, int const lda, double const* X, int const incX, double const beta, double* Y, int const incY) { cblas_dsymv (Order, Uplo, N, alpha, A, lda, X, incX, beta, Y, incY); } // y <- alpha * A * x + beta * y // A real symmetric in packed form inline void spmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* Ap, float const* X, int const incX, float const beta, float* Y, int const incY) { cblas_sspmv (Order, Uplo, N, alpha, Ap, X, incX, beta, Y, incY); } inline void spmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* Ap, double const* X, int const incX, double const beta, double* Y, int const incY) { cblas_dspmv (Order, Uplo, N, alpha, Ap, X, incX, beta, Y, incY); } // y <- alpha * A * x + beta * y // A complex hermitian inline void hemv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { cblas_chemv (Order, Uplo, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void hemv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { cblas_zhemv (Order, Uplo, N, static_cast (&alpha), static_cast (A), lda, static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // y <- alpha * A * x + beta * y // A complex hermitian in packed form inline void hpmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* Ap, traits::complex_f const* X, int const incX, traits::complex_f const& beta, traits::complex_f* Y, int const incY) { cblas_chpmv (Order, Uplo, N, static_cast (&alpha), static_cast (Ap), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } inline void hpmv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* Ap, traits::complex_d const* X, int const incX, traits::complex_d const& beta, traits::complex_d* Y, int const incY) { cblas_zhpmv (Order, Uplo, N, static_cast (&alpha), static_cast (Ap), static_cast (X), incX, static_cast (&beta), static_cast (Y), incY); } // A <- alpha * x * y^T + A // .. real types: calls cblas_xger // .. complex types: calls cblas_xgeru inline void ger (CBLAS_ORDER const Order, int const M, int const N, float const alpha, float const* X, int const incX, float const* Y, int const incY, float* A, int const lda) { cblas_sger (Order, M, N, alpha, X, incX, Y, incY, A, lda); } inline void ger (CBLAS_ORDER const Order, int const M, int const N, double const alpha, double const* X, int const incX, double const* Y, int const incY, double* A, int const lda) { cblas_dger (Order, M, N, alpha, X, incX, Y, incY, A, lda); } inline void ger (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void ger (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * y^T + A // .. complex types only inline void geru (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void geru (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zgeru (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * y^H + A // .. complex types only inline void gerc (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cgerc (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void gerc (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zgerc (Order, M, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * x^T + A // A real symmetric inline void syr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float* A, int const lda) { cblas_ssyr (Order, Uplo, N, alpha, X, incX, A, lda); } inline void syr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double* A, int const lda) { cblas_dsyr (Order, Uplo, N, alpha, X, incX, A, lda); } // A <- alpha * x * x^T + A // A real symmetric in packed form inline void spr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float* Ap) { cblas_sspr (Order, Uplo, N, alpha, X, incX, Ap); } inline void spr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double* Ap) { cblas_dspr (Order, Uplo, N, alpha, X, incX, Ap); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric inline void syr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float const* Y, int const incY, float* A, int const lda) { cblas_ssyr2 (Order, Uplo, N, alpha, X, incX, Y, incY, A, lda); } inline void syr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double const* Y, int const incY, double* A, int const lda) { cblas_dsyr2 (Order, Uplo, N, alpha, X, incX, Y, incY, A, lda); } // A <- alpha * x * y^T + alpha * y * x^T + A // A real symmetric in packed form inline void spr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, float const* X, int const incX, float const* Y, int const incY, float* Ap) { cblas_sspr2 (Order, Uplo, N, alpha, X, incX, Y, incY, Ap); } inline void spr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, double const* X, int const incX, double const* Y, int const incY, double* Ap) { cblas_dspr2 (Order, Uplo, N, alpha, X, incX, Y, incY, Ap); } // A <- alpha * x * x^H + A // A hermitian inline void her (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, traits::complex_f const* X, int const incX, traits::complex_f* A, int const lda) { cblas_cher (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (A), lda); } inline void her (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, traits::complex_d const* X, int const incX, traits::complex_d* A, int const lda) { cblas_zher (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (A), lda); } // A <- alpha * x * x^H + A // A hermitian in packed form inline void hpr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float const alpha, traits::complex_f const* X, int const incX, traits::complex_f* Ap) { cblas_chpr (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (Ap)); } inline void hpr (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double const alpha, traits::complex_d const* X, int const incX, traits::complex_d* Ap) { cblas_zhpr (Order, Uplo, N, alpha, static_cast (X), incX, static_cast (Ap)); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian inline void her2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* A, int const lda) { cblas_cher2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } inline void her2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* A, int const lda) { cblas_zher2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (A), lda); } // A <- alpha * x * y^H + y * (alpha * x)^H + A // A hermitian in packed form inline void hpr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f const& alpha, traits::complex_f const* X, int const incX, traits::complex_f const* Y, int const incY, traits::complex_f* Ap) { cblas_chpr2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (Ap)); } inline void hpr2 (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d const& alpha, traits::complex_d const* X, int const incX, traits::complex_d const* Y, int const incY, traits::complex_d* Ap) { cblas_zhpr2 (Order, Uplo, N, static_cast (&alpha), static_cast (X), incX, static_cast (Y), incY, static_cast (Ap)); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS2_OVERLOADS_HPP kml_src/boost/numeric/bindings/atlas/cblas3.hpp000644 000765 000024 00000117357 10265665640 022541 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_3_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_3_HPP #include #include #include #include #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { // C <- alpha * op (A) * op (B) + beta * C // op (A) == A || A^T || A^H template inline void gemm (CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c ) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (TransA == CblasNoTrans || TransA == CblasTrans || TransA == CblasConjTrans); assert (TransB == CblasNoTrans || TransB == CblasTrans || TransB == CblasConjTrans); int const m = TransA == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a); int const n = TransB == CblasNoTrans ? traits::matrix_size2 (b) : traits::matrix_size1 (b); int const k = TransA == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (m == traits::matrix_size1 (c)); assert (n == traits::matrix_size2 (c)); #ifndef NDEBUG int const k1 = TransB == CblasNoTrans ? traits::matrix_size1 (b) : traits::matrix_size2 (b); assert (k == k1); #endif // .. what about AtlasConj? CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); detail::gemm (stor_ord, TransA, TransB, m, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } // C <- alpha * A * B + beta * C template inline void gemm (T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c) { gemm (CblasNoTrans, CblasNoTrans, alpha, a, b, beta, c) ; } // C <- A * B template inline void gemm (MatrA const& a, MatrB const& b, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename MatrC::value_type val_t; #endif gemm (CblasNoTrans, CblasNoTrans, (val_t) 1, a, b, (val_t) 0, c); } // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T namespace detail { template inline void symm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (side == CblasLeft || side == CblasRight); assert (uplo == CblasUpper || uplo == CblasLower); int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (side == CblasLeft ? m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a) : n == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); symm (stor_ord, side, uplo, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T template inline void symm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::symm (side, uplo, alpha, a, b, beta, c); } template inline void symm (CBLAS_SIDE const side, T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); detail::symm (side, uplo, alpha, a, b, beta, c); } #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace detail { // C <- alpha * A * B + beta * C ; A == A^T struct symm_left { template static void f (T const& alpha, SymmA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); symm (stor_ord, CblasLeft, uplo, m, n, alpha, traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; // C <- alpha * A * B + beta * C ; B == B^T struct symm_right { template static void f (T const& alpha, MatrA const& a, SymmB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (n == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); assert (m == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); symm (stor_ord, CblasRight, uplo, m, n, alpha, traits::matrix_storage (b), traits::leading_dimension (b), traits::matrix_storage (a), traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; } // detail // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T template inline void symm (T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif typedef typename boost::mpl::if_c< boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value, detail::symm_left, detail::symm_right >::type functor; functor::f (alpha, a, b, beta, c); } // C <- A * B // C <- B * A template inline void symm (MatrA const& a, MatrB const& b, MatrC& c) { typedef typename traits::matrix_traits::value_type val_t; symm ((val_t) 1, a, b, (val_t) 0, c); } #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^H namespace detail { template inline void hemm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (side == CblasLeft || side == CblasRight); assert (uplo == CblasUpper || uplo == CblasLower); int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (side == CblasLeft ? m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a) : n == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermA::orientation_category #endif >::value); hemm (stor_ord, side, uplo, m, n, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^H template inline void hemm (CBLAS_SIDE const side, CBLAS_UPLO const uplo, T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::hemm (side, uplo, alpha, a, b, beta, c); } template inline void hemm (CBLAS_SIDE const side, T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermA::packed_category #endif >::value); detail::hemm (side, uplo, alpha, a, b, beta, c); } #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS namespace detail { // C <- alpha * A * B + beta * C ; A == A^H struct hemm_left { template static void f (T const& alpha, HermA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (m == traits::matrix_size1 (a) && m == traits::matrix_size2 (a)); assert (m == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); hemm (stor_ord, CblasLeft, uplo, m, n, alpha, traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; // C <- alpha * A * B + beta * C ; B == B^H struct hemm_right { template static void f (T const& alpha, MatrA const& a, HermB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif int const m = traits::matrix_size1 (c); int const n = traits::matrix_size2 (c); assert (n == traits::matrix_size1 (b) && n == traits::matrix_size2 (b)); assert (m == traits::matrix_size1 (a) && n == traits::matrix_size2 (a)); CBLAS_ORDER const stor_ord = enum_cast (storage_order< typename traits::matrix_traits::ordering_type >::value); CBLAS_UPLO const uplo = enum_cast (uplo_triang< typename traits::matrix_traits::uplo_type >::value); hemm (stor_ord, CblasRight, uplo, m, n, alpha, traits::matrix_storage (b), traits::leading_dimension (b), traits::matrix_storage (a), traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } }; } template inline void hemm (T const& alpha, MatrA const& a, MatrB const& b, T const& beta, MatrC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif typedef typename boost::mpl::if_c< boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value, detail::hemm_left, detail::hemm_right >::type functor; functor::f (alpha, a, b, beta, c); } // C <- A * B // C <- B * A template inline void hemm (MatrA const& a, MatrB const& b, MatrC& c) { typedef typename traits::matrix_traits::value_type val_t; hemm ((val_t) 1, a, b, (val_t) 0, c); } #endif // BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C // C == C^T namespace detail { template inline void syrk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmC::orientation_category #endif >::value); syrk (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C // C == C^T template inline void syrk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::syrk (uplo, trans, alpha, a, beta, c); } template inline void syrk (CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmC::packed_category #endif >::value); detail::syrk (uplo, trans, alpha, a, beta, c); } // C <- A * A^T + C // C <- A^T * A + C template inline void syrk (CBLAS_TRANSPOSE trans, MatrA const& a, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmC::value_type val_t; #endif syrk (trans, (val_t) 1, a, (val_t) 0, c); } // C <- alpha * A * B^T + conj(alpha) * B * A^T + beta * C // C <- alpha * A^T * B + conj(alpha) * B^T * A + beta * C // C == C^T namespace detail { template inline void syr2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (k == (trans == CblasNoTrans ? traits::matrix_size2 (b) : traits::matrix_size1 (b))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmC::orientation_category #endif >::value); syr2k (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B^T + conj(alpha) * B * A^T + beta * C // C <- alpha * A^T * B + conj(alpha) * B^T * A + beta * C // C == C^T template inline void syr2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::syr2k (uplo, trans, alpha, a, b, beta, c); } template inline void syr2k (CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, MatrB const& b, T const& beta, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::symmetric_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmC::packed_category #endif >::value); detail::syr2k (uplo, trans, alpha, a, b, beta, c); } // C <- A * B^T + B * A^T + C // C <- A^T * B + B^T * A + C template inline void syr2k (CBLAS_TRANSPOSE trans, MatrA const& a, MatrB const& b, SymmC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename SymmC::value_type val_t; #endif syr2k (trans, (val_t) 1, a, b, (val_t) 0, c); } // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C // C == C^H namespace detail { template inline void herk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermC::orientation_category #endif >::value); herk (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C // C == C^H template inline void herk (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::herk (uplo, trans, alpha, a, beta, c); } template inline void herk (CBLAS_TRANSPOSE trans, T const& alpha, MatrA const& a, T const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermC::packed_category #endif >::value); detail::herk (uplo, trans, alpha, a, beta, c); } // C <- A * A^H + C // C <- A^H * A + C template inline void herk (CBLAS_TRANSPOSE trans, MatrA const& a, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermC::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; herk (trans, (real_t) 1, a, (real_t) 0, c); } // C <- alpha * A * B^H + conj(alpha) * B * A^H + beta * C // C <- alpha * A^H * B + conj(alpha) * B^H * A + beta * C // C == C^H namespace detail { template inline void her2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T1 const& alpha, MatrA const& a, MatrB const& b, T2 const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); assert (trans == CblasNoTrans || trans == CblasConjTrans); int const n = traits::matrix_size1 (c); assert (n == traits::matrix_size2 (c)); int const k = trans == CblasNoTrans ? traits::matrix_size2 (a) : traits::matrix_size1 (a); assert (k == (trans == CblasNoTrans ? traits::matrix_size2 (b) : traits::matrix_size1 (b))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (a) : traits::matrix_size2 (a))); assert (n == (trans == CblasNoTrans ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename HermC::orientation_category #endif >::value); her2k (stor_ord, uplo, trans, n, k, alpha, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (b), #else traits::matrix_storage_const (b), #endif traits::leading_dimension (b), beta, traits::matrix_storage (c), traits::leading_dimension (c)); } } // detail // C <- alpha * A * B^H + conj(alpha) * B * A^H + beta * C // C <- alpha * A^H * B + conj(alpha) * B^H * A + beta * C // C == C^H template inline void her2k (CBLAS_UPLO const uplo, CBLAS_TRANSPOSE trans, T1 const& alpha, MatrA const& a, MatrB const& b, T2 const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif detail::her2k (uplo, trans, alpha, a, b, beta, c); } template inline void her2k (CBLAS_TRANSPOSE trans, T1 const& alpha, MatrA const& a, MatrB const& b, T2 const& beta, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::hermitian_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename HermC::packed_category #endif >::value); detail::her2k (uplo, trans, alpha, a, b, beta, c); } // C <- A * B^H + B * A^H + C // C <- A^H * B + B^H * A + C template inline void her2k (CBLAS_TRANSPOSE trans, MatrA const& a, MatrB const& b, HermC& c) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typedef typename traits::matrix_traits::value_type val_t; #else typedef typename HermC::value_type val_t; #endif typedef typename traits::type_traits::real_type real_t; her2k (trans, (val_t) 1, a, b, (real_t) 0, c); } } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS_LEVEL_3_HPP kml_src/boost/numeric/bindings/atlas/cblas3_overloads.hpp000644 000765 000024 00000034611 10265665640 024606 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS3_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS3_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // C <- alpha * op (A) * op (B) + beta * C inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, float const alpha, float const* A, int const lda, float const* B, int const ldb, float const beta, float* C, int const ldc) { cblas_sgemm (Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, double const alpha, double const* A, int const lda, double const* B, int const ldb, double const beta, double* C, int const ldc) { cblas_dgemm (Order, TransA, TransB, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_cgemm (Order, TransA, TransB, M, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void gemm (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const TransA, CBLAS_TRANSPOSE const TransB, int const M, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zgemm (Order, TransA, TransB, M, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^T inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, float const alpha, float const* A, int const lda, float const* B, int const ldb, float const beta, float* C, int const ldc) { cblas_ssymm (Order, Side, Uplo, M, N, alpha, A, lda, B, ldb, beta, C, ldc); } inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, double const alpha, double const* A, int const lda, double const* B, int const ldb, double const beta, double* C, int const ldc) { cblas_dsymm (Order, Side, Uplo, M, N, alpha, A, lda, B, ldb, beta, C, ldc); } inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_csymm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void symm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zsymm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * B + beta * C // C <- alpha * B * A + beta * C // A == A^H inline void hemm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_chemm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void hemm (CBLAS_ORDER const Order, CBLAS_SIDE const Side, CBLAS_UPLO const Uplo, int const M, int const N, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zhemm (Order, Side, Uplo, M, N, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * A^T + beta * C // C <- alpha * A^T * A + beta * C // C == C^T inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, float const alpha, float const* A, int const lda, float const beta, float* C, int const ldc) { cblas_ssyrk (Order, Uplo, Trans, N, K, alpha, A, lda, beta, C, ldc); } inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, double const alpha, double const* A, int const lda, double const beta, double* C, int const ldc) { cblas_dsyrk (Order, Uplo, Trans, N, K, alpha, A, lda, beta, C, ldc); } inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_csyrk (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (&beta), static_cast (C), ldc); } inline void syrk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zsyrk (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * B^T + conj(alpha) * B * A^T + beta * C // C <- alpha * A^T * B + conj(alpha) * B^T * A + beta * C // C == C^T inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, float const alpha, float const* A, int const lda, float const* B, int const ldb, float const beta, float* C, int const ldc) { cblas_ssyr2k (Order, Uplo, Trans, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, double const alpha, double const* A, int const lda, double const* B, int const ldb, double const beta, double* C, int const ldc) { cblas_dsyr2k (Order, Uplo, Trans, N, K, alpha, A, lda, B, ldb, beta, C, ldc); } inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, traits::complex_f const& beta, traits::complex_f* C, int const ldc) { cblas_csyr2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } inline void syr2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, traits::complex_d const& beta, traits::complex_d* C, int const ldc) { cblas_zsyr2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, static_cast (&beta), static_cast (C), ldc); } // C <- alpha * A * A^H + beta * C // C <- alpha * A^H * A + beta * C // C == C^H inline void herk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, float alpha, traits::complex_f const* A, int const lda, float beta, traits::complex_f* C, int const ldc) { cblas_cherk (Order, Uplo, Trans, N, K, alpha, static_cast (A), lda, beta, static_cast (C), ldc); } inline void herk (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, double alpha, traits::complex_d const* A, int const lda, double beta, traits::complex_d* C, int const ldc) { cblas_zherk (Order, Uplo, Trans, N, K, alpha, static_cast (A), lda, beta, static_cast (C), ldc); } // C <- alpha * A * B^H + conj(alpha) * B * A^H + beta * C // C <- alpha * A^H * B + conj(alpha) * B^H * A + beta * C // C == C^H inline void her2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_f const& alpha, traits::complex_f const* A, int const lda, traits::complex_f const* B, int const ldb, float beta, traits::complex_f* C, int const ldc) { cblas_cher2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, beta, static_cast (C), ldc); } inline void her2k (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, CBLAS_TRANSPOSE const Trans, int const N, int const K, traits::complex_d const& alpha, traits::complex_d const* A, int const lda, traits::complex_d const* B, int const ldb, double beta, traits::complex_d* C, int const ldc) { cblas_zher2k (Order, Uplo, Trans, N, K, static_cast (&alpha), static_cast (A), lda, static_cast (B), ldb, beta, static_cast (C), ldc); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CBLAS3_OVERLOADS_HPP kml_src/boost/numeric/bindings/atlas/cblas_enum.hpp000644 000765 000024 00000004447 10265665640 023475 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_ENUM_HPP #define BOOST_NUMERIC_BINDINGS_CBLAS_ENUM_HPP #include #include #ifdef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { template struct storage_order {}; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS template<> struct storage_order { // 'ename' - como (in enum_cast<>): // a template argument may not reference an unnamed type enum ename { value = CblasRowMajor }; }; template<> struct storage_order { enum ename { value = CblasColMajor }; }; #else template<> struct storage_order { enum ename { value = CblasRowMajor }; }; template<> struct storage_order { enum ename { value = CblasColMajor }; }; #endif template struct uplo_triang {}; #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS template<> struct uplo_triang { enum ename { value = CblasUpper }; }; template<> struct uplo_triang { enum ename { value = CblasLower }; }; #else template<> struct uplo_triang { enum ename { value = CblasUpper }; }; template<> struct uplo_triang { enum ename { value = CblasLower }; }; #endif // g++ 3.0.4 rejects 'static_cast (e2)' template E1 enum_cast (E2 e2) { return static_cast (static_cast (e2)); } } }}} #endif kml_src/boost/numeric/bindings/atlas/cblas_inc.hpp000644 000765 000024 00000002064 10327225052 023257 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ ////////////////////////////////////////////////////////////////////////// // // ATLAS (Automatically Tuned Linear Algebra Software) // // ''At present, it provides C and Fortran77 interfaces to a portably // efficient BLAS implementation, as well as a few routines from LAPACK.'' // // see: http://math-atlas.sourceforge.net/ // ////////////////////////////////////////////////////////////////////////// #ifndef BOOST_NUMERIC_BINDINGS_CBLAS_INC_H #define BOOST_NUMERIC_BINDINGS_CBLAS_INC_H extern "C" { #include } #endif kml_src/boost/numeric/bindings/atlas/clapack.h000644 000765 000024 00000020041 10327225052 022373 0ustar00pawelmstaff000000 000000 /* * Automatically Tuned Linear Algebra Software v3.6.0 * (C) Copyright 1999 R. Clint Whaley * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions, and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the ATLAS group or the names of its contributers may * not be used to endorse or promote products derived from this * software without specific written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ATLAS GROUP OR ITS CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * */ #ifndef CLAPACK_H #define CLAPACK_H #include "cblas.h" #ifndef ATLAS_ORDER #define ATLAS_ORDER CBLAS_ORDER #endif #ifndef ATLAS_UPLO #define ATLAS_UPLO CBLAS_UPLO #endif #ifndef ATLAS_DIAG #define ATLAS_DIAG CBLAS_DIAG #endif int clapack_sgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, float *A, const int lda, int *ipiv, float *B, const int ldb); int clapack_sgetrf(const enum CBLAS_ORDER Order, const int M, const int N, float *A, const int lda, int *ipiv); int clapack_sgetrs (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans, const int N, const int NRHS, const float *A, const int lda, const int *ipiv, float *B, const int ldb); int clapack_sgetri(const enum CBLAS_ORDER Order, const int N, float *A, const int lda, const int *ipiv); int clapack_sposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, const int NRHS, float *A, const int lda, float *B, const int ldb); int clapack_spotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, float *A, const int lda); int clapack_spotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int NRHS, const float *A, const int lda, float *B, const int ldb); int clapack_spotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, float *A, const int lda); int clapack_slauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, float *A, const int lda); int clapack_strtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo, const enum ATLAS_DIAG Diag,const int N, float *A, const int lda); int clapack_dgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, double *A, const int lda, int *ipiv, double *B, const int ldb); int clapack_dgetrf(const enum CBLAS_ORDER Order, const int M, const int N, double *A, const int lda, int *ipiv); int clapack_dgetrs (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans, const int N, const int NRHS, const double *A, const int lda, const int *ipiv, double *B, const int ldb); int clapack_dgetri(const enum CBLAS_ORDER Order, const int N, double *A, const int lda, const int *ipiv); int clapack_dposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, const int NRHS, double *A, const int lda, double *B, const int ldb); int clapack_dpotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, double *A, const int lda); int clapack_dpotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int NRHS, const double *A, const int lda, double *B, const int ldb); int clapack_dpotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, double *A, const int lda); int clapack_dlauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, double *A, const int lda); int clapack_dtrtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo, const enum ATLAS_DIAG Diag,const int N, double *A, const int lda); int clapack_cgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, void *A, const int lda, int *ipiv, void *B, const int ldb); int clapack_cgetrf(const enum CBLAS_ORDER Order, const int M, const int N, void *A, const int lda, int *ipiv); int clapack_cgetrs (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans, const int N, const int NRHS, const void *A, const int lda, const int *ipiv, void *B, const int ldb); int clapack_cgetri(const enum CBLAS_ORDER Order, const int N, void *A, const int lda, const int *ipiv); int clapack_cposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, const int NRHS, void *A, const int lda, void *B, const int ldb); int clapack_cpotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, void *A, const int lda); int clapack_cpotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int NRHS, const void *A, const int lda, void *B, const int ldb); int clapack_cpotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, void *A, const int lda); int clapack_clauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, void *A, const int lda); int clapack_ctrtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo, const enum ATLAS_DIAG Diag,const int N, void *A, const int lda); int clapack_zgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS, void *A, const int lda, int *ipiv, void *B, const int ldb); int clapack_zgetrf(const enum CBLAS_ORDER Order, const int M, const int N, void *A, const int lda, int *ipiv); int clapack_zgetrs (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans, const int N, const int NRHS, const void *A, const int lda, const int *ipiv, void *B, const int ldb); int clapack_zgetri(const enum CBLAS_ORDER Order, const int N, void *A, const int lda, const int *ipiv); int clapack_zposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, const int NRHS, void *A, const int lda, void *B, const int ldb); int clapack_zpotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, void *A, const int lda); int clapack_zpotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const int N, const int NRHS, const void *A, const int lda, void *B, const int ldb); int clapack_zpotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, void *A, const int lda); int clapack_zlauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo, const int N, void *A, const int lda); int clapack_ztrtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo, const enum ATLAS_DIAG Diag,const int N, void *A, const int lda); #endif kml_src/boost/numeric/bindings/atlas/clapack.hpp000644 000765 000024 00000064203 10265665640 022757 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CLAPACK_HPP #define BOOST_NUMERIC_BINDINGS_CLAPACK_HPP #include #include #include #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS # include #endif #include // see libs/numeric/bindings/atlas/doc/index.html, section 2.5.2 //#define BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG #include #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK # include # include #endif namespace boost { namespace numeric { namespace bindings { namespace atlas { ///////////////////////////////////////////////////////////////////// // // general system of linear equations A * X = B // ///////////////////////////////////////////////////////////////////// // gesv(): 'driver' function // // [comments from 'clapack_dgesv.c':] /* clapack_xgesv computes the solution to a system of linear equations * A * X = B, * where A is an N-by-N matrix and X and B are N-by-NRHS matrices. */ // [but ATLAS FAQ says:] /* What's the deal with the RHS in the row-major factorization/solves? * Most users are confused by the row major factorization and related * solves. The right-hand side vectors are probably the biggest source * of confusion. The RHS array does not represent a matrix in the * mathematical sense, it is instead a pasting together of the various * RHS into one array for calling convenience. As such, RHS vectors are * always stored contiguously, regardless of the row/col major that is * chosen. This means that ldb/ldx is always independent of NRHS, and * dependant on N, regardless of the row/col major setting. */ // That is, it seems that, if B is row-major, it should be NRHS-by-N, // and RHS vectors should be its rows, not columns. // // [comments from 'clapack_dgesv.c':] /* The LU factorization used to factor A is dependent on the Order * parameter, as detailed in the leading comments of clapack_dgetrf. * The factored form of A is then used to solve the system of equations * A * X = B. * A is overwritten with the appropriate LU factorization, and B [...] * is overwritten with the solution X on output. */ // If B is row-major, solution vectors are its rows. template inline int gesv (MatrA& a, IVec& ipiv, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); assert (n == traits::vector_size (ipiv)); return detail::gesv (stor_ord, n, nrhs, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv), traits::matrix_storage (b), traits::leading_dimension (b)); } template inline int gesv (MatrA& a, MatrB& b) { // with 'internal' pivot vector #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); int *ipiv = new (std::nothrow) int[n]; int ierr = -101; // clapack_dgesv() errors: // if (ierr == 0), successful // if (ierr < 0), the -ierr argument had an illegal value // -- we will use -101 if allocation fails // if (ierr > 0), U(i-1,i-1) (or L(i-1,i-1)) is exactly zero if (ipiv) { ierr = detail::gesv (stor_ord, n, nrhs, traits::matrix_storage (a), traits::leading_dimension (a), ipiv, traits::matrix_storage (b), traits::leading_dimension (b)); delete[] ipiv; } return ierr; } template inline int lu_solve (MatrA& a, MatrB& b) { return gesv (a, b); } // getrf(): LU factorization of A // [comments from 'clapack_dgetrf.c':] /* Computes one of two LU factorizations based on the setting of * the Order parameter, as follows: * --------------------------------------------------------------- * Order == CblasColMajor * Column-major factorization of form * A = P * L * U * where P is a row-permutation matrix, L is lower triangular with * unit diagonal elements (lower trapezoidal if M > N), and U is * upper triangular (upper trapezoidal if M < N). * --------------------------------------------------------------- * Order == CblasRowMajor * Row-major factorization of form * A = P * L * U * where P is a column-permutation matrix, L is lower triangular * (lower trapezoidal if M > N), and U is upper triangular with * unit diagonals (upper trapezoidal if M < N). */ template inline int getrf (MatrA& a, IVec& ipiv) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const m = traits::matrix_size1 (a); int const n = traits::matrix_size2 (a); assert (traits::vector_size (ipiv) == (m < n ? m : n)); return detail::getrf (stor_ord, m, n, traits::matrix_storage (a), traits::leading_dimension (a), traits::vector_storage (ipiv)); } template inline int lu_factor (MatrA& a, IVec& ipiv) { return getrf (a, ipiv); } // getrs(): solves a system of linear equations // A * X = B or A' * X = B // using the LU factorization previously computed by getrf() template inline int getrs (CBLAS_TRANSPOSE const Trans, MatrA const& a, IVec const& ipiv, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif assert (Trans == CblasNoTrans || Trans == CblasTrans || Trans == CblasConjTrans); CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); assert (n == traits::vector_size (ipiv)); return detail::getrs (stor_ord, Trans, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (ipiv), #else traits::vector_storage_const (ipiv), #endif traits::matrix_storage (b), traits::leading_dimension (b)); } // getrs(): solves A * X = B (after getrf()) template inline int getrs (MatrA const& a, IVec const& ipiv, MatrB& b) { return getrs (CblasNoTrans, a, ipiv, b); } template inline int lu_substitute (MatrA const& a, IVec const& ipiv, MatrB& b) { return getrs (CblasNoTrans, a, ipiv, b); } // getri(): computes the inverse of a matrix A // using the LU factorization previously computed by getrf() template inline int getri (MatrA& a, IVec const& ipiv) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename MatrA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); assert (traits::vector_size (ipiv) == n); return detail::getri (stor_ord, n, traits::matrix_storage (a), traits::leading_dimension (a), #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::vector_storage (ipiv) #else traits::vector_storage_const (ipiv) #endif ); } template inline int lu_invert (MatrA& a, IVec& ipiv) { return getri (a, ipiv); } ///////////////////////////////////////////////////////////////////// // // system of linear equations A * X = B // with A symmetric or Hermitian positive definite matrix // ///////////////////////////////////////////////////////////////////// #ifndef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // posv(): 'driver' function // // [from 'dposv.f' (slightly edited):] /* XPOSV computes the solution to a system of linear equations * A * X = B, * where A is an N-by-N symmetric/Hermitian positive definite matrix * and X and B are N-by-NRHS matrices. [See also comments of gesv().] * * A -- On entry, the symmetric/Hermitian matrix A. * If UPLO = 'U', the leading N-by-N upper triangular part of A * contains the upper triangular part of the matrix A, and the * strictly lower triangular part of A is not referenced. * If UPLO = 'L', the leading N-by-N lower triangular part of A * contains the lower triangular part of the matrix A, and the * strictly upper triangular part of A is not referenced. * * On exit, if INFO = 0, the factor U or L from the Cholesky * factorization A = U**T*U or A = L*L**T * [or A = U**H*U or A = L*L**H]. * * B -- On entry, the right hand side matrix B. * On exit, if INFO = 0, the solution matrix X. */ namespace detail { template inline int posv (CBLAS_UPLO const uplo, SymmA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); return posv (stor_ord, uplo, n, nrhs, traits::matrix_storage (a), traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); } } // detail template inline int posv (CBLAS_UPLO const uplo, SymmA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::posv (uplo, a, b); } template inline int posv (SymmA& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::posv (uplo, a, b); } template inline int cholesky_solve (SymmA& a, MatrB& b) { return posv (a, b); } #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // potrf(): Cholesky factorization of A namespace detail { template inline int potrf (CBLAS_UPLO const uplo, SymmA& a) { CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); return potrf (stor_ord, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a)); } } // detail template inline int potrf (CBLAS_UPLO const uplo, SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::potrf (uplo, a); } template inline int potrf (SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::potrf (uplo, a); } template inline int cholesky_factor (SymmA& a) { return potrf (a); } // potrs(): solves a system of linear equations A * X = B // using the Cholesky factorization computed by potrf() namespace detail { template inline int potrs (CBLAS_UPLO const uplo, SymmA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::ordering_type, typename traits::matrix_traits::ordering_type >::value)); #endif CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); int const nrhs = stor_ord == CblasColMajor ? traits::matrix_size2 (b) : traits::matrix_size1 (b); assert (n == traits::matrix_size2 (a)); assert (n == (stor_ord == CblasColMajor ? traits::matrix_size1 (b) : traits::matrix_size2 (b))); #ifndef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG return potrs (stor_ord, uplo, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); #else // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG int ierr; if (stor_ord == CblasColMajor) ierr = potrs (stor_ord, uplo, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); else // ATLAS bug with CblasRowMajor ierr = potrs_bug (stor_ord, uplo, n, nrhs, #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING traits::matrix_storage (a), #else traits::matrix_storage_const (a), #endif traits::leading_dimension (a), traits::matrix_storage (b), traits::leading_dimension (b)); return ierr; #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG } } // detail template inline int potrs (CBLAS_UPLO const uplo, SymmA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::potrs (uplo, a, b); } template inline int potrs (SymmA const& a, MatrB& b) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::potrs (uplo, a, b); } template inline int cholesky_substitute (SymmA const& a, MatrB& b) { return potrs (a, b); } #ifdef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // posv(): 'driver' function template inline int posv (CBLAS_UPLO const uplo, SymmA& a, MatrB& b) { int ierr = potrf (uplo, a); if (ierr == 0) ierr = potrs (uplo, a, b); return ierr; } template inline int posv (SymmA& a, MatrB& b) { int ierr = potrf (a); if (ierr == 0) ierr = potrs (a, b); return ierr; } template inline int cholesky_solve (SymmA& a, MatrB& b) { return posv (a, b); } #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // potri(): computes the inverse of a symmetric or Hermitian positive // definite matrix A using the Cholesky factorization // previously computed by potrf() namespace detail { template inline int potri (CBLAS_UPLO const uplo, SymmA& a) { CBLAS_ORDER const stor_ord = enum_cast (storage_order< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::ordering_type #else typename SymmA::orientation_category #endif >::value); int const n = traits::matrix_size1 (a); assert (n == traits::matrix_size2 (a)); return potri (stor_ord, uplo, n, traits::matrix_storage (a), traits::leading_dimension (a)); } } // detail template inline int potri (CBLAS_UPLO const uplo, SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, traits::general_t >::value)); #endif assert (uplo == CblasUpper || uplo == CblasLower); return detail::potri (uplo, a); } template inline int potri (SymmA& a) { #ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK typedef typename traits::matrix_traits::value_type val_t; BOOST_STATIC_ASSERT((boost::is_same< typename traits::matrix_traits::matrix_structure, typename traits::detail::symm_herm_t::type >::value)); #endif CBLAS_UPLO const uplo = enum_cast (uplo_triang< #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS typename traits::matrix_traits::uplo_type #else typename SymmA::packed_category #endif >::value); return detail::potri (uplo, a); } template inline int cholesky_invert (SymmA& a) { return potri (a); } } // namespace atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CLAPACK_HPP kml_src/boost/numeric/bindings/atlas/clapack_inc.hpp000644 000765 000024 00000002250 10327226054 023571 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ ////////////////////////////////////////////////////////////////////////// // // ATLAS (Automatically Tuned Linear Algebra Software) // // ''At present, it provides C and Fortran77 interfaces to a portably // efficient BLAS implementation, as well as a few routines from LAPACK.'' // // see: http://math-atlas.sourceforge.net/ // ////////////////////////////////////////////////////////////////////////// #ifndef BOOST_NUMERIC_BINDINGS_CLAPACK_INC_H #define BOOST_NUMERIC_BINDINGS_CLAPACK_INC_H extern "C" { /* see footnote [2] in libs/numeric/bindings/lapack/doc/index.html */ /* #include */ #include } #endif kml_src/boost/numeric/bindings/atlas/clapack_overloads.hpp000644 000765 000024 00000030674 10265665640 025042 0ustar00pawelmstaff000000 000000 /* * * Copyright (c) Kresimir Fresl 2002 * * Permission to copy, modify, use and distribute this software * for any non-commercial or commercial purpose is granted provided * that this license appear on all copies of the software source code. * * Author assumes no responsibility whatsoever for its use and makes * no guarantees about its quality, correctness or reliability. * * Author acknowledges the support of the Faculty of Civil Engineering, * University of Zagreb, Croatia. * */ #ifndef BOOST_NUMERIC_BINDINGS_CLAPACK_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_CLAPACK_OVERLOADS_HPP #include #include namespace boost { namespace numeric { namespace bindings { namespace atlas { namespace detail { // // general system of linear equations A * X = B // // 'driver' function -- factor and solve inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, float* A, int const lda, int* ipiv, float* B, int const ldb) { return clapack_sgesv (Order, N, NRHS, A, lda, ipiv, B, ldb); } inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, double* A, int const lda, int* ipiv, double* B, int const ldb) { return clapack_dgesv (Order, N, NRHS, A, lda, ipiv, B, ldb); } inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, traits::complex_f* A, int const lda, int* ipiv, traits::complex_f* B, int const ldb) { return clapack_cgesv (Order, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } inline int gesv (CBLAS_ORDER const Order, int const N, int const NRHS, traits::complex_d* A, int const lda, int* ipiv, traits::complex_d* B, int const ldb) { return clapack_zgesv (Order, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } // LU factorization inline int getrf (CBLAS_ORDER const Order, int const M, int const N, float* A, int const lda, int* ipiv) { return clapack_sgetrf (Order, M, N, A, lda, ipiv); } inline int getrf (CBLAS_ORDER const Order, int const M, int const N, double* A, int const lda, int* ipiv) { return clapack_dgetrf (Order, M, N, A, lda, ipiv); } inline int getrf (CBLAS_ORDER const Order, int const M, int const N, traits::complex_f* A, int const lda, int* ipiv) { return clapack_cgetrf (Order, M, N, static_cast (A), lda, ipiv); } inline int getrf (CBLAS_ORDER const Order, int const M, int const N, traits::complex_d* A, int const lda, int* ipiv) { return clapack_zgetrf (Order, M, N, static_cast (A), lda, ipiv); } // solve (using factorization computed by getrf()) inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, float const* A, int const lda, int const* ipiv, float* B, int const ldb) { return clapack_sgetrs (Order, Trans, N, NRHS, A, lda, ipiv, B, ldb); } inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, double const* A, int const lda, int const* ipiv, double* B, int const ldb) { return clapack_dgetrs (Order, Trans, N, NRHS, A, lda, ipiv, B, ldb); } inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, traits::complex_f const* A, int const lda, int const* ipiv, traits::complex_f* B, int const ldb) { return clapack_cgetrs (Order, Trans, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } inline int getrs (CBLAS_ORDER const Order, CBLAS_TRANSPOSE const Trans, int const N, int const NRHS, traits::complex_d const* A, int const lda, int const* ipiv, traits::complex_d* B, int const ldb) { return clapack_zgetrs (Order, Trans, N, NRHS, static_cast (A), lda, ipiv, static_cast (B), ldb); } // invert (using factorization computed by getrf()) inline int getri (CBLAS_ORDER const Order, int const N, float* A, int const lda, int const* ipiv) { return clapack_sgetri (Order, N, A, lda, ipiv); } inline int getri (CBLAS_ORDER const Order, int const N, double* A, int const lda, int const* ipiv) { return clapack_dgetri (Order, N, A, lda, ipiv); } inline int getri (CBLAS_ORDER const Order, int const N, traits::complex_f* A, int const lda, int const* ipiv) { return clapack_cgetri (Order, N, static_cast (A), lda, ipiv); } inline int getri (CBLAS_ORDER const Order, int const N, traits::complex_d* A, int const lda, int const* ipiv) { return clapack_zgetri (Order, N, static_cast (A), lda, ipiv); } // // system of linear equations A * X = B // with A symmetric positive definite matrix // // 'driver' function -- factor and solve inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, float* A, int const lda, float* B, int const ldb) { return clapack_sposv (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, double* A, int const lda, double* B, int const ldb) { return clapack_dposv (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_f* A, int const lda, traits::complex_f* B, int const ldb) { return clapack_cposv (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } inline int posv (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_d* A, int const lda, traits::complex_d* B, int const ldb) { return clapack_zposv (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } // Cholesky factorization inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float* A, int const lda) { return clapack_spotrf (Order, Uplo, N, A, lda); } inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double* A, int const lda) { return clapack_dpotrf (Order, Uplo, N, A, lda); } inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f* A, int const lda) { return clapack_cpotrf (Order, Uplo, N, static_cast (A), lda); } inline int potrf (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d* A, int const lda) { return clapack_zpotrf (Order, Uplo, N, static_cast (A), lda); } // solve (using factorization computed by potrf()) inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, float const* A, int const lda, float* B, int const ldb) { return clapack_spotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, double const* A, int const lda, double* B, int const ldb) { return clapack_dpotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_f const* A, int const lda, traits::complex_f* B, int const ldb) { return clapack_cpotrs (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } inline int potrs (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_d const* A, int const lda, traits::complex_d* B, int const ldb) { return clapack_zpotrs (Order, Uplo, N, NRHS, static_cast (A), lda, static_cast (B), ldb); } #ifdef BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // .. ATLAS bug with row major hermitian matrices // .... symmetric matrices are OK, but to simplify generic potrs() ... inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, float const* A, int const lda, float* B, int const ldb) { return clapack_spotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, double const* A, int const lda, double* B, int const ldb) { return clapack_dpotrs (Order, Uplo, N, NRHS, A, lda, B, ldb); } inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_f const* A, int const lda, traits::complex_f* B, int const ldb) { int sz = N * lda; traits::complex_f* A1 = new traits::complex_f[sz]; for (int i = 0; i < sz; ++i) A1[i] = std::conj (A[i]); int r = clapack_cpotrs (Order, Uplo, N, NRHS, static_cast (A1), lda, static_cast (B), ldb); delete[] A1; return r; } inline int potrs_bug (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, int const NRHS, traits::complex_d const* A, int const lda, traits::complex_d* B, int const ldb) { int sz = N * lda; traits::complex_d* A1 = new traits::complex_d[sz]; for (int i = 0; i < sz; ++i) A1[i] = std::conj (A[i]); int r = clapack_zpotrs (Order, Uplo, N, NRHS, static_cast (A1), lda, static_cast (B), ldb); delete[] A1; return r; } #endif // BOOST_NUMERIC_BINDINGS_ATLAS_POTRF_BUG // invert (using factorization computed by potrf()) inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, float* A, int const lda) { return clapack_spotri (Order, Uplo, N, A, lda); } inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, double* A, int const lda) { return clapack_dpotri (Order, Uplo, N, A, lda); } inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_f* A, int const lda) { return clapack_cpotri (Order, Uplo, N, static_cast (A), lda); } inline int potri (CBLAS_ORDER const Order, CBLAS_UPLO const Uplo, int const N, traits::complex_d* A, int const lda) { return clapack_zpotri (Order, Uplo, N, static_cast (A), lda); } }} // namepaces detail & atlas }}} #endif // BOOST_NUMERIC_BINDINGS_CLAPACK_OVERLOADS_HPP kml_src/boost/numeric/bindings/amos/amos.h000644 000765 000024 00000003745 10265665640 021617 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_H #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_H #include #include extern "C" { void AMOS_DBESI(const double* z, const double* fnu, const int* kode, const int* n, double* cy, int* nz ) ; void AMOS_CBESI(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, int* ierr) ; void AMOS_ZBESI(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, int* ierr) ; void AMOS_DBESJ(const double * z, const double* fnu, const int* n, double* cy, int* nz ) ; void AMOS_CBESJ(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, int* ierr) ; void AMOS_ZBESJ(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, int* ierr) ; void AMOS_DBESY(const double * z, const double* fnu, const int* n, double* cy ) ; void AMOS_CBESY(const fcomplex_t* z, const float* fnu, const int* kode, const int* n, fcomplex_t* cy, int* nz, fcomplex_t *cwrk, int* ierr) ; void AMOS_ZBESY(const double* zr, const double* zi, const double* fnu, const int* kode, const int* n, double* cyr, double* cyi, int* nz, double *cwrkr, double *cwrki, int* ierr) ; } #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP kml_src/boost/numeric/bindings/amos/amos.hpp000644 000765 000024 00000007210 10265665640 022146 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP #include #include #include #include #include namespace boost { namespace numeric { namespace bindings { namespace amos { template < typename vector_type, typename value_type > int besi(const value_type& z, // std::complex< float > or std::complex< double > const typename traits::type_traits< value_type >::real_type fnu, // float or double int kode, vector_type& cy, int& nz) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif int n = traits::vector_size( cy ) ; value_type * cy_ptr = traits::vector_storage( cy ) ; int error = 0 ; detail::besi( z, fnu, kode, n, cy_ptr, nz, error ) ; return error ; } template < typename vector_type, typename value_type > int besj(const value_type& z, const typename traits::type_traits< value_type >::real_type fnu, int kode, vector_type& cy, int& nz) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif int n = traits::vector_size( cy ) ; value_type * cy_ptr = traits::vector_storage( cy ) ; int error = 0 ; detail::besj( z, fnu, kode, n, cy_ptr, nz, error ) ; return error ; } template < typename vector_type, typename value_type > int besy(const value_type& z, const typename traits::type_traits< value_type >::real_type fnu, int kode, vector_type& cy, int& nz) { #ifndef BOOST_NUMERIC_BINDINGS_POOR_MANS_TRAITS BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename traits::vector_traits::value_type >::value ) ) ; #else BOOST_STATIC_ASSERT( ( boost::is_same< value_type, typename vector_type::value_type >::value ) ) ; #endif int n = traits::vector_size( cy ) ; value_type * cy_ptr = traits::vector_storage( cy ) ; int error = 0 ; value_type * cwrk = new value_type[n]; detail::besy( z, fnu, kode, n, cy_ptr, nz, cwrk, error ) ; delete[] cwrk ; return error ; } }}}} #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_HPP kml_src/boost/numeric/bindings/amos/amos_names.h000644 000765 000024 00000001543 10265665640 022774 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_NAMES_H #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_NAMES_H #include #define AMOS_DBESI FORTRAN_ID( dbesi ) #define AMOS_CBESI FORTRAN_ID( cbesi ) #define AMOS_ZBESI FORTRAN_ID( zbesi ) #define AMOS_DBESJ FORTRAN_ID( dbesj ) #define AMOS_CBESJ FORTRAN_ID( cbesj ) #define AMOS_ZBESJ FORTRAN_ID( zbesj ) #define AMOS_DBESY FORTRAN_ID( dbesy ) #define AMOS_CBESY FORTRAN_ID( cbesy ) #define AMOS_ZBESY FORTRAN_ID( zbesy ) #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_NAMES_HPP kml_src/boost/numeric/bindings/amos/amos_overloads.hpp000644 000765 000024 00000004056 10265665640 024231 0ustar00pawelmstaff000000 000000 // Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // Copyright Toon Knapen #ifndef BOOST_NUMERIC_BINDINGS_AMOS_AMOS_OVERLOADS_HPP #define BOOST_NUMERIC_BINDINGS_AMOS_AMOS_OVERLOADS_HPP #include #include #include namespace boost { namespace numeric { namespace bindings { namespace amos { namespace detail { using namespace ::boost::numeric::bindings::traits ; // // BESI // //inline //void besi(const fcomplex * z, const fcomplex * fnu, const int * kode, const int * n, fcomplex* cy, int * nz, int * error) ; inline void besi(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, int& error) { AMOS_DBESI( &z, &fnu, &kode, &n, cy, &nz ) ; } inline void besi(const complex_f& z, const float& fnu, const int& kode, const int& n, complex_f* cy, int & nz, int & error) { AMOS_CBESI( complex_ptr( &z ), &fnu, &kode, &n, complex_ptr( cy ), &nz, &error ) ; } // inline // void besi(const complex_d* z, const double* fnu, const int * kode, const int * n, complex_d* cy, int * nz, int * error) ; // // BESJ // inline void besj(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, int& error) { AMOS_DBESJ( &z, &fnu, &n, cy, &nz ) ; } inline void besj(const complex_f& z, const float& fnu, const int& kode, const int& n, complex_f* cy, int & nz, int & error) { AMOS_CBESJ( complex_ptr( &z ), &fnu, &kode, &n, complex_ptr( cy ), &nz, &error ) ; } // // BESY // inline void besy(const double& z, const double& fnu, const int& kode, const int& n, double* cy, int& nz, double* wrk, int& error) { AMOS_DBESY( &z, &fnu, &n, cy ) ; } }}}}} #endif // BOOST_NUMERIC_BINDINGS_AMOS_AMOS_OVERLOADS_HPP