stk/0000775000175000017500000000000012617165722010306 5ustar bectbectstk/COPYING0000664000175000017500000010451312617165714011346 0ustar bectbect GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . stk/doc/0000775000175000017500000000000012617165714011054 5ustar bectbectstk/doc/README0000664000175000017500000001440112617165714011734 0ustar bectbectREADME Copyright Notice Copyright (C) 2011-2014 SUPELEC Authors: Julien Bect Emmanuel Vazquez README Copying Permission Statement This file is part of STK: a Small (Matlab/Octave) Toolbox for Kriging (http://sourceforge.net/projects/kriging) STK is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. STK 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 STK. If not, see . ------------------------------------------------------------------------ STK : a Small (Matlab/Octave) Toolbox for Kriging ================================================= o General information Version: 2.3.4 Authors: See AUTHORS file Maintainers: Julien Bect Emmanuel Vazquez Description: The STK is a (not so) Small Toolbox for Kriging. Its primary focus is on the interpolation/regression technique known as kriging, which is very closely related to Splines and Radial Basis Functions, and can be interpreted as a non-parametric Bayesian method using a Gaussian Process (GP) prior. The STK also provides tools for the sequential and non-sequential design of experiments. Even though it is, currently, mostly geared towards the Design and Analysis of Computer Experiments (DACE), the STK can be useful for other applications areas (such as Geostatistics, Machine Learning, Non-parametric Regression, etc.). Copyright: Large portions are Copyright (C) 2011-2014 SUPELEC. See individual copyright notices for more details. License: GNU General Public License, version 3 (GPLv3). See COPYING for the full license. URL: http://sourceforge.net/projects/kriging o Quick Start Run stk_init.m in Matlab(TM) or GNU Octave. Once the STK is properly initialized, you should be able to run the examples located in the 'examples' directory. o Requirements and recommendations for use with GNU Octave The STK works with GNU Octave 3.2.2 or newer. Note that the STK relies on some mex files that are compiled during the initialization. Thus, your installation must be able to compile mex files. In Debian 6.0 (Squeeze) or gNewSense 3.0 (Parkes), for instance, this means installing octave3.2-headers in addition to the base octave3.2 package. The sqp() function internally relies on the GLPK library, which is shipped with most (but not all) versions of Octave. The STK will not start if GLPK is not installed. o Requirements and recommendations for use with Matlab The STK works with Matlab R2007a or newer. The Optimization Toolbox is recommended. The Parallel Computing Toolbox is optional. o Content This toolbox is called the Small (Matlab/Octave) Toolbox for Kriging (STK). Note that the STK is meant to be compatible with Octave and Matlab(TM), and can be automatically configured with both software products. However, some optional features, such as the possibility to use parallel computing in some functions, are not yet available when using Octave. The STK is free software and is released under the terms of the GNU General Public License, version 3, as published by the Free Software Foundation, and is made available at the web address http://kriging.sourceforge.net. By publishing this toolbox, the idea is to provide a convenient and flexible research tool for working with kriging-based methods. The code of the toolbox is meant to be easily understandable, modular, and reusable. By way of illustration, it is very easy to use this toolbox for implementing the EGO algorithm of (Jones et al. 98). Besides, this toolbox can serve as a basis for the implementation of advanced algorithms such as Stepwise Uncertainty Reduction algorithms (see, e.g., Bect et al. 2010) The toolbox consists of three parts: a. The first part is the implementation of a number of covariance functions, and tools to compute covariance vectors and matrices. The structure of the STK makes it possible to use any kind of covariances: stationary or non-stationary covariances, aniso- tropic covariances, generalized covariances, etc. b. The second part is the implementation of a REMAP procedure to estimate the parameters of the covariance. This makes it possible to deal with generalized covariances and to take into account prior knowledge about the parameters of the covariance. c. The third part consists of prediction procedures. In its current form, the STK has been optimized to deal with moderately large data sets. o References J. Bect, D. Ginsbourger, L. Li, V. Picheny, and E. Vazquez. Sequential design of computer experiments for the estimation of a probability of failure. Statistics and Computing, pages 1-21, 2011. DOI: 10.1007/s11222-011-9241-4. D. R. Jones, M. Schonlau, and William J. Welch. Efficient global optimization of expensive black-box functions. Journal of Global Optimization, 13(4):455-492, 1998. o Ways to get help, report bugs, ask for new features... Use the "help" mailing-list: kriging-help@lists.sourceforge.net https://sourceforge.net/p/kriging/mailman to ask for help on STK, and the ticket manager: https://sourceforge.net/p/kriging/tickets to report bugs or ask for new features. stk/doc/AUTHORS0000664000175000017500000000116212617165714012124 0ustar bectbectSTK is mainly developped and maintained by (alphabetical order): BECT Julien VAZQUEZ Emmanuel The following people have helped develop the toolbox in various ways (from providing ideas and bug reports to actually contributing code): BENASSI Romain DABOUSSI Elias DRAUG Carnë DUTRIEUX Héloïse FELIOT Paul FRASNEDO Sophie JAN Benoit KETTANI Othmane KRAUTH Alexandra LI Ling PIERA-MARTINEZ Miguel RAHALI Elham RAVISANKAR Ashwin RESSEGUIER Valentin STROH Rémi VILLEMONTEIX Julien Individual copyright notices are provided at the beginning of each file in the toolbox. stk/src/0000775000175000017500000000000012617165721011074 5ustar bectbectstk/src/stk_gpquadform_matrixy.c0000664000175000017500000001210612617165717016050 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2013 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" static void gpquadfrom_matrixy ( double* x, double* y, double* rx2, double* ry2, double* h, size_t nx, size_t ny, size_t dim ) { size_t i, j, kx, ky; double diff, lambda; for (i = 0; i < nx; i++) { for (j = 0; j < ny; j++) { /* compute distance between x[i,:] and y[j,:] */ lambda = 0.0; for (kx = i, ky = j; kx < dim * nx; kx += nx, ky += ny) { diff = x[kx] - y[ky]; lambda += (diff * diff) / (rx2[kx] + ry2[ky]); } /* store the result in h */ h[i + nx * j] = lambda; } } } mxArray* compute_gpquadfrom_matrixy ( const mxArray* x, const mxArray* y, const mxArray* rx, const mxArray* ry ) { size_t k, d, mx, my; double u, *p, *rx2, *ry2; mxArray *h; if((!stk_is_realmatrix(x)) || (!stk_is_realmatrix(y)) || (!stk_is_realmatrix(rx)) || (!stk_is_realmatrix(ry))) mexErrMsgTxt("Input arguments should be real-valued double-precision array."); /* Check that the all input arguments have the same number of columns */ d = mxGetN(x); if ((mxGetN(y) != d) || (mxGetN(rx) != d) || (mxGetN(ry) != d)) mexErrMsgTxt("All input arguments should have the same number of columns."); /* Check that rx and ry have the appropriate number of rows */ if (mxGetM(rx) != (mx = mxGetM(x))) mexErrMsgTxt("x and rx should have the same number of rows."); if (mxGetM(ry) != (my = mxGetM(y))) mexErrMsgTxt("y and ry should have the same number of rows."); /* Compute rx^2 */ rx2 = mxCalloc(mx * d, sizeof(double)); p = mxGetPr(rx); for(k = 0; k < mx * d; k++) { u = p[k]; if(u <= 0) mexErrMsgTxt("rx should have (strictly) positive entries."); rx2[k] = u * u; } /* Compute ry^2 */ ry2 = mxCalloc(my * d, sizeof(double)); p = mxGetPr(ry); for(k = 0; k < my * d; k++) { u = p[k]; if(u <= 0) mexErrMsgTxt("ry should have (strictly) positive entries."); ry2[k] = u * u; } /* Create a matrix for the return argument */ h = mxCreateDoubleMatrix(mx, my, mxREAL); /* Do the actual computations in a subroutine */ gpquadfrom_matrixy(mxGetPr(x), mxGetPr(y), rx2, ry2, mxGetPr(h), mx, my, d); /* Free allocated memory */ mxFree(rx2); mxFree(ry2); return h; } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { if (nlhs > 1) /* Check number of output arguments */ mexErrMsgTxt("Too many output arguments."); if (nrhs != 4) /* Check number of input arguments */ mexErrMsgTxt("Incorrect number of input arguments."); plhs[0] = compute_gpquadfrom_matrixy(prhs[0], prhs[1], prhs[2], prhs[3]); } stk/src/stk_distrib_bivnorm0_cdf.c0000664000175000017500000004146712617165720016224 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2014 Supelec * * * * Author: Julien Bect * * * * Based on mvndstpack.f by Yihong Ge and Alan Genz * * (see original copyright notice below) * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" double bvu (double h, double k, double rho); double mvnphi (double z); #define MAX(a,b) ((a) >= (b) ? (a) : (b)) #define BIGNUM 40.0 /* this is BIG for a normal deviate */ #define ARGIN_UPPER prhs[0] /* n x 2 */ #define ARGIN_RHO prhs[1] /* n x 1 */ #define ARGOUT_PROBA plhs[0] /* n x 1 */ #define ARGOUT_QROBA plhs[1] /* n x 1 */ void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { size_t n; int i; double *u1, *u2, *rho, *proba, *qroba; double q01, q10, q11; mxArray *mxProba, *mxQroba; /*--- check number of input / output arguments -------------------------*/ if (nrhs != 2) { mexErrMsgTxt ("Incorrect number of input arguments."); } if (nlhs > 2) { mexErrMsgTxt ("Too many output arguments."); } /*--- check input arguments types -------------------------------------*/ if ((! stk_is_realmatrix (ARGIN_UPPER)) || (mxGetN (ARGIN_UPPER) != 2)) { mexErrMsgTxt ("Input argument #1 (upper) should be a real " "double-precision matrix with two columns."); } if ((! stk_is_realmatrix (ARGIN_RHO)) || (mxGetN (ARGIN_RHO) != 1)) { mexErrMsgTxt ("Input argument #2 (rho) should be a real " "double-precision column vector."); } n = mxGetM (ARGIN_UPPER); if (mxGetM (ARGIN_RHO) != n) { mexErrMsgTxt ("Input arguments #1 (upper) and #2 (rho) should " "have the same number of rows"); } /*--- prepare the output argument --------------------------------------*/ mxProba = mxCreateDoubleMatrix (n, 1, mxREAL); mxQroba = mxCreateDoubleMatrix (n, 1, mxREAL); /*--- get pointers to the actual data ----------------------------------*/ u1 = mxGetPr (ARGIN_UPPER); u2 = u1 + n; rho = mxGetPr (ARGIN_RHO); proba = mxGetPr (mxProba); qroba = mxGetPr (mxQroba); /*--- compute probabilities --------------------------------------------*/ for (i = 0; i < n; i++) { if ((u1[i] < - BIGNUM) || (u2[i] < - BIGNUM)) { proba[i] = 0.0; qroba[i] = 1.0; } else if (u1[i] > BIGNUM) { if (u2[i] < 0) { proba[i] = mvnphi (u2[i]); qroba[i] = 1 - proba[i]; } else { qroba[i] = mvnphi (- u2[i]); proba[i] = 1 - qroba[i]; } } else if (u2[i] > BIGNUM) { if (u1[i] < 0) { proba[i] = mvnphi (u1[i]); qroba[i] = 1 - proba[i]; } else { qroba[i] = mvnphi (- u1[i]); proba[i] = 1 - qroba[i]; } } else if ((u1[i] < 0) || (u2[i] < 0)) { proba[i] = bvu (- u1[i], - u2[i], rho[i]); qroba[i] = 1 - proba[i]; } else { q11 = bvu (u1[i], u2[i], rho[i]); q10 = (mvnphi (- u1[i])) - q11; q10 = MAX(q10, 0); q01 = (mvnphi (- u2[i])) - q11; q01 = MAX(q01, 0); qroba[i] = q11 + q01 + q10; proba[i] = 1 - qroba[i]; } } /*--- the end ----------------------------------------------------------*/ ARGOUT_PROBA = mxProba; if (nlhs > 1) ARGOUT_QROBA = mxQroba; else mxDestroyArray (mxQroba); } /************************************************************************** * * * The following code has been obtained by translating the Fortran code * * mvndstpack.f to C using f2c (version 20100827) and then extracting and * * manually cleaning up the relevant functions. * * * * mvndstpack.f was obtained by HTTP on 2014/12/09 from: * * * * http://www.math.wsu.edu/faculty/genz/software/fort77/mvtdstpack.f * * * * It is distributed under the following ("modified BSD") licence: * * * * Copyright (C) 2013, Alan Genz, All rights reserved. * * * * Redistribution and use in source and binary forms, with or without * * modification, are permitted provided 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 contributor name(s) may not 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 * * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR * * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF USE * * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * * **************************************************************************/ /************************************************************************** * * * A function for computing bivariate normal probabilities * * * * Yihong Ge * * Department of Computer Science and Electrical Engineering * * Washington State University * * Pullman, WA 99164-2752 * * * * and * * * * Alan Genz * * Department of Mathematics * * Washington State University * * Pullman, WA 99164-3113 * * Email : alangenz@wsu.edu * * * * double bvu (double h, double k, double *r__) * * * * Calculate the probability that X > h and Y > k for a standard * * bivariate Gaussian vector (X, Y) with correlation coefficient *r__ * * * **************************************************************************/ double bvu (double h, double k, double rho) { static struct { double e_1[3]; double fill_2[7]; double e_3[6]; double fill_4[4]; double e_5[10]; } equiv_122 = { .1713244923791705, .3607615730481384, .4679139345726904, {0}, .04717533638651177, .1069393259953183, .1600783285433464, .2031674267230659, .2334925365383547, .2491470458134029, {0}, .01761400713915212, .04060142980038694, .06267204833410906, .08327674157670475, .1019301198172404, .1181945319615184, .1316886384491766, .1420961093183821, .1491729864726037, .1527533871307259 }; #define w ((double *)&equiv_122) static struct { double e_1[3]; double fill_2[7]; double e_3[6]; double fill_4[4]; double e_5[10]; } equiv_123 = { -.9324695142031522, -.6612093864662647, -.238619186083197, {0}, -.9815606342467191, -.904117256370475, -.769902674194305, -.5873179542866171, -.3678314989981802, -.1252334085114692, {0}, -.9931285991850949, -.9639719272779138, -.9122344282513259, -.8391169718222188, -.7463319064601508, -.636053680726515, -.5108670019508271, -.3737060887154196, -.2277858511416451, -.07652652113349733 }; #define x ((double *)&equiv_123) /* System generated locals */ int i__1; double d__1, d__2; /* Local variables */ double a, b, c__, d__; int i__, lg, ng; double as; double bs, hk, hs, sn, rs, xs, bvn, asr; /* Gauss Legendre Points and Weights, N = 6 */ /* Gauss Legendre Points and Weights, N = 12 */ /* Gauss Legendre Points and Weights, N = 20 */ if (fabs(rho) < .3f) { ng = 1; lg = 3; } else if (fabs(rho) < .75f) { ng = 2; lg = 6; } else { ng = 3; lg = 10; } hk = h * k; bvn = 0.; if (fabs(rho) < .925f) { hs = (h * h + k * k) / 2; asr = asin(rho); i__1 = lg; for (i__ = 1; i__ <= i__1; ++i__) { sn = sin(asr * (x[i__ + ng * 10 - 11] + 1) / 2); bvn += w[i__ + ng * 10 - 11] * exp((sn * hk - hs) / (1 - sn * sn)); sn = sin(asr * (-x[i__ + ng * 10 - 11] + 1) / 2); bvn += w[i__ + ng * 10 - 11] * exp((sn * hk - hs) / (1 - sn * sn)); } d__1 = -h; d__2 = -k; bvn = bvn * asr / 12.566370614359172 + mvnphi(d__1) * mvnphi(d__2); } else { if (rho < 0.) { k = -k; hk = -hk; } if (fabs(rho) < 1.) { as = (1 - rho) * (rho + 1); a = sqrt(as); /* Computing 2nd power */ d__1 = h - k; bs = d__1 * d__1; c__ = (4 - hk) / 8; d__ = (12 - hk) / 16; bvn = a * exp(-(bs / as + hk) / 2) * (1 - c__ * (bs - as) * (1 - d__ * bs / 5) / 3 + c__ * d__ * as * as / 5); if (hk > -160.) { b = sqrt(bs); d__1 = -b / a; bvn -= exp(-hk / 2) * sqrt(6.283185307179586) * mvnphi(d__1) * b * (1 - c__ * bs * (1 - d__ * bs / 5) / 3); } a /= 2; i__1 = lg; for (i__ = 1; i__ <= i__1; ++i__) { /* Computing 2nd power */ d__1 = a * (x[i__ + ng * 10 - 11] + 1); xs = d__1 * d__1; rs = sqrt(1 - xs); bvn += a * w[i__ + ng * 10 - 11] * (exp(-bs / (xs * 2) - hk / (rs + 1)) / rs - exp(-(bs / xs + hk) / 2) * (c__ * xs * (d__ * xs + 1) + 1)); /* Computing 2nd power */ d__1 = -x[i__ + ng * 10 - 11] + 1; xs = as * (d__1 * d__1) / 4; rs = sqrt(1 - xs); /* Computing 2nd power */ d__1 = rs + 1; bvn += a * w[i__ + ng * 10 - 11] * exp(-(bs / xs + hk) / 2) * (exp(-hk * xs / (d__1 * d__1 * 2)) / rs - (c__ * xs * (d__ * xs + 1) + 1)); } bvn = -bvn / 6.283185307179586; } if (rho > 0.) { d__1 = - MAX(h,k); bvn += mvnphi(d__1); } else { bvn = -bvn; if (k > h) { if (h < 0.) { bvn = bvn + mvnphi(k) - mvnphi(h); } else { d__1 = - h; d__2 = - k; bvn = bvn + mvnphi(d__1) - mvnphi(d__2); } } } } return bvn; } /* bvu */ /************************************************************************** * * * Normal distribution probabilities accurate to 1d-15. * * Reference: J.L. Schonfelder, Math Comp 32(1978), pp 1232-1240. * * * **************************************************************************/ double mvnphi (double z) { static double a[44] = { .610143081923200417926465815756, -.434841272712577471828182820888,.176351193643605501125840298123, -.060710795609249414860051215825,.017712068995694114486147141191, -.004321119385567293818599864968,8.54216676887098678819832055e-4, -1.2715509060916274262889394e-4,1.1248167243671189468847072e-5, 3.13063885421820972630152e-7,-2.70988068537762022009086e-7, 3.0737622701407688440959e-8,2.515620384817622937314e-9, -1.02892992132031912759e-9,2.9944052119949939363e-11, 2.605178968726693629e-11,-2.634839924171969386e-12, -6.43404509890636443e-13,1.12457401801663447e-13, 1.7281533389986098e-14,-4.264101694942375e-15, -5.45371977880191e-16,1.58697607761671e-16,2.0899837844334e-17, -5.900526869409e-18,-9.41893387554e-19,2.1497735647e-19, 4.6660985008e-20,-7.243011862e-21,-2.387966824e-21,1.91177535e-22, 1.20482568e-22,-6.72377e-25,-5.747997e-24,-4.28493e-25, 2.44856e-25,4.3793e-26,-8.151e-27,-3.089e-27,9.3e-29,1.74e-28, 1.6e-29,-8e-30,-2e-30 }; /* Builtin functions */ double exp(double); /* Local variables */ double b; int i__; double p, t, bm, bp, xa; xa = fabs(z) / 1.414213562373095048801688724209; if (xa > 100.) { p = 0.; } else { t = (xa * 8 - 30) / (xa * 4 + 15); bm = 0.; b = 0.; for (i__ = 24; i__ >= 0; --i__) { bp = b; b = bm; bm = t * b - bp + a[i__]; } p = exp(-xa * xa) * (bm - bp) / 4; } if (z > 0.) { p = 1 - p; } return p; } /* mvnphi */ stk/src/stk_paretofind_mex.c0000664000175000017500000000775512617165716015147 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2014 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" typedef double SCALAR; typedef mxLogical LOGICAL; #include "pareto.h" #define ARGIN_X prhs[0] #define ARGOUT_NDPOS plhs[0] #define ARGOUT_DRANK plhs[1] void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int i, k, n, d, *tmp_ndpos, *tmp_drank; double *x, *ndpos, *drank; if (nrhs != 1) /* Check number of input arguments */ mexErrMsgTxt ("Incorrect number of input arguments."); if (nlhs > 3) /* Check number of output arguments */ mexErrMsgTxt ("Too many output arguments."); if (! stk_is_realmatrix (ARGIN_X)) mexErrMsgTxt ("The input should be a real-valued " "double-precision array."); /* Read input argument */ n = mxGetM (ARGIN_X); d = mxGetN (ARGIN_X); x = mxGetPr (ARGIN_X); /* Create a temporary arrays */ tmp_ndpos = (int *) mxCalloc (n, sizeof (int)); tmp_drank = (int *) mxCalloc (n, sizeof (int)); /* PRUNE */ k = pareto_find (x, tmp_ndpos, tmp_drank, n, d); /* ARGOUT #1: position of non-dominated points, in lexical order */ ARGOUT_NDPOS = mxCreateDoubleMatrix (k, 1, mxREAL); ndpos = mxGetPr (ARGOUT_NDPOS); for (i = 0; i < k; i++) ndpos[i] = (double) (1 + tmp_ndpos[i]); /* ARGOUT #2: rank of first dominating point */ if (nlhs > 1) { ARGOUT_DRANK = mxCreateDoubleMatrix (n, 1, mxREAL); drank = mxGetPr (ARGOUT_DRANK); for (i = 0; i < n; i++) drank[i] = (double) (1 + tmp_drank[i]); } /* Cleanup */ mxFree (tmp_ndpos); mxFree (tmp_drank); } stk/src/stk_isdominated_mex.c0000664000175000017500000001127612617165716015305 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2014 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" typedef double SCALAR; typedef mxLogical LOGICAL; #include "pareto.h" /* mimic ismember's syntax */ #define ARGIN_A prhs[0] /* n x d, double */ #define ARGIN_B prhs[1] /* k x d, double */ #define ARGOUT_ISDOM plhs[0] /* n x 1, logical */ #define ARGOUT_DRANK plhs[1] /* n x 1, double */ /* IMPORTANT: the rows of B are assumed to be */ /* SORTED in the LEXICAL ORDER */ void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int i, n, k, d, *tmp_drank; double *xa, *xb, *drank; mxLogical *isdom; /*--- Check number of input/output arguments --------------------*/ if (nrhs != 2) /* Check number of input arguments */ mexErrMsgTxt ("Incorrect number of input arguments."); if (nlhs > 2) /* Check number of output arguments */ mexErrMsgTxt ("Too many output arguments."); /*--- Check input types -----------------------------------------*/ if (! stk_is_realmatrix (ARGIN_A)) mexErrMsgTxt ("The first input argument should be a " "real-valued double-precision array."); xa = mxGetPr (ARGIN_A); if (! stk_is_realmatrix (ARGIN_B)) mexErrMsgTxt ("The second input argument should be a " "real-valued double-precision array."); xb = mxGetPr (ARGIN_B); /*--- Read dimensions -------------------------------------------*/ n = (int) mxGetM (ARGIN_A); d = (int) mxGetN (ARGIN_A); k = (int) mxGetM (ARGIN_B); if (d != mxGetN (ARGIN_B)) mexErrMsgTxt ("The two input arguments should have the " "same number of columns"); /*--- Create arrays ---------------------------------------------*/ ARGOUT_ISDOM = mxCreateLogicalMatrix (n, 1); isdom = mxGetLogicals (ARGOUT_ISDOM); tmp_drank = (int *) mxCalloc (n, sizeof (int)); /*--- Find dominated rows ---------------------------------------*/ is_dominated (xa, xb, isdom, tmp_drank, n, k, d); if (nlhs > 1) { ARGOUT_DRANK = mxCreateDoubleMatrix (n, 1, mxREAL); drank = mxGetPr (ARGOUT_DRANK); for (i = 0; i < n; i++) drank[i] = (double) (1 + tmp_drank[i]); } /*--- Cleanup --------------------------------------------------*/ mxFree (tmp_drank); } stk/src/primes.h0000664000175000017500000024064512617165720012556 0ustar bectbect#ifndef ___FIRST10000PRIMES_H___ #define ___FIRST10000PRIMES_H___ /* The First 10,000 Primes (the 10,000th is 104,729) For more information on primes see http://primes.utm.edu/ */ #define PRIMES_TABLE_SIZE 10000 unsigned int primes_table[PRIMES_TABLE_SIZE] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343, 10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487, 10499, 10501, 10513, 10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627, 10631, 10639, 10651, 10657, 10663, 10667, 10687, 10691, 10709, 10711, 10723, 10729, 10733, 10739, 10753, 10771, 10781, 10789, 10799, 10831, 10837, 10847, 10853, 10859, 10861, 10867, 10883, 10889, 10891, 10903, 10909, 10937, 10939, 10949, 10957, 10973, 10979, 10987, 10993, 11003, 11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 11093, 11113, 11117, 11119, 11131, 11149, 11159, 11161, 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257, 11261, 11273, 11279, 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383, 11393, 11399, 11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, 11497, 11503, 11519, 11527, 11549, 11551, 11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657, 11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 11743, 11777, 11779, 11783, 11789, 11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839, 11863, 11867, 11887, 11897, 11903, 11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, 11969, 11971, 11981, 11987, 12007, 12011, 12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 12107, 12109, 12113, 12119, 12143, 12149, 12157, 12161, 12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 12253, 12263, 12269, 12277, 12281, 12289, 12301, 12323, 12329, 12343, 12347, 12373, 12377, 12379, 12391, 12401, 12409, 12413, 12421, 12433, 12437, 12451, 12457, 12473, 12479, 12487, 12491, 12497, 12503, 12511, 12517, 12527, 12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589, 12601, 12611, 12613, 12619, 12637, 12641, 12647, 12653, 12659, 12671, 12689, 12697, 12703, 12713, 12721, 12739, 12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 12823, 12829, 12841, 12853, 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941, 12953, 12959, 12967, 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, 13049, 13063, 13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 13183, 13187, 13217, 13219, 13229, 13241, 13249, 13259, 13267, 13291, 13297, 13309, 13313, 13327, 13331, 13337, 13339, 13367, 13381, 13397, 13399, 13411, 13417, 13421, 13441, 13451, 13457, 13463, 13469, 13477, 13487, 13499, 13513, 13523, 13537, 13553, 13567, 13577, 13591, 13597, 13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681, 13687, 13691, 13693, 13697, 13709, 13711, 13721, 13723, 13729, 13751, 13757, 13759, 13763, 13781, 13789, 13799, 13807, 13829, 13831, 13841, 13859, 13873, 13877, 13879, 13883, 13901, 13903, 13907, 13913, 13921, 13931, 13933, 13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081, 14083, 14087, 14107, 14143, 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243, 14249, 14251, 14281, 14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389, 14401, 14407, 14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 14479, 14489, 14503, 14519, 14533, 14537, 14543, 14549, 14551, 14557, 14561, 14563, 14591, 14593, 14621, 14627, 14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713, 14717, 14723, 14731, 14737, 14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821, 14827, 14831, 14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, 14923, 14929, 14939, 14947, 14951, 14957, 14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 15077, 15083, 15091, 15101, 15107, 15121, 15131, 15137, 15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 15227, 15233, 15241, 15259, 15263, 15269, 15271, 15277, 15287, 15289, 15299, 15307, 15313, 15319, 15329, 15331, 15349, 15359, 15361, 15373, 15377, 15383, 15391, 15401, 15413, 15427, 15439, 15443, 15451, 15461, 15467, 15473, 15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569, 15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 15647, 15649, 15661, 15667, 15671, 15679, 15683, 15727, 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787, 15791, 15797, 15803, 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, 15913, 15919, 15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, 16061, 16063, 16067, 16069, 16073, 16087, 16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 16187, 16189, 16193, 16217, 16223, 16229, 16231, 16249, 16253, 16267, 16273, 16301, 16319, 16333, 16339, 16349, 16361, 16363, 16369, 16381, 16411, 16417, 16421, 16427, 16433, 16447, 16451, 16453, 16477, 16481, 16487, 16493, 16519, 16529, 16547, 16553, 16561, 16567, 16573, 16603, 16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 16673, 16691, 16693, 16699, 16703, 16729, 16741, 16747, 16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 16871, 16879, 16883, 16889, 16901, 16903, 16921, 16927, 16931, 16937, 16943, 16963, 16979, 16981, 16987, 16993, 17011, 17021, 17027, 17029, 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107, 17117, 17123, 17137, 17159, 17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239, 17257, 17291, 17293, 17299, 17317, 17321, 17327, 17333, 17341, 17351, 17359, 17377, 17383, 17387, 17389, 17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 17471, 17477, 17483, 17489, 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579, 17581, 17597, 17599, 17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, 17729, 17737, 17747, 17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863, 17881, 17891, 17903, 17909, 17911, 17921, 17923, 17929, 17939, 17957, 17959, 17971, 17977, 17981, 17987, 17989, 18013, 18041, 18043, 18047, 18049, 18059, 18061, 18077, 18089, 18097, 18119, 18121, 18127, 18131, 18133, 18143, 18149, 18169, 18181, 18191, 18199, 18211, 18217, 18223, 18229, 18233, 18251, 18253, 18257, 18269, 18287, 18289, 18301, 18307, 18311, 18313, 18329, 18341, 18353, 18367, 18371, 18379, 18397, 18401, 18413, 18427, 18433, 18439, 18443, 18451, 18457, 18461, 18481, 18493, 18503, 18517, 18521, 18523, 18539, 18541, 18553, 18583, 18587, 18593, 18617, 18637, 18661, 18671, 18679, 18691, 18701, 18713, 18719, 18731, 18743, 18749, 18757, 18773, 18787, 18793, 18797, 18803, 18839, 18859, 18869, 18899, 18911, 18913, 18917, 18919, 18947, 18959, 18973, 18979, 19001, 19009, 19013, 19031, 19037, 19051, 19069, 19073, 19079, 19081, 19087, 19121, 19139, 19141, 19157, 19163, 19181, 19183, 19207, 19211, 19213, 19219, 19231, 19237, 19249, 19259, 19267, 19273, 19289, 19301, 19309, 19319, 19333, 19373, 19379, 19381, 19387, 19391, 19403, 19417, 19421, 19423, 19427, 19429, 19433, 19441, 19447, 19457, 19463, 19469, 19471, 19477, 19483, 19489, 19501, 19507, 19531, 19541, 19543, 19553, 19559, 19571, 19577, 19583, 19597, 19603, 19609, 19661, 19681, 19687, 19697, 19699, 19709, 19717, 19727, 19739, 19751, 19753, 19759, 19763, 19777, 19793, 19801, 19813, 19819, 19841, 19843, 19853, 19861, 19867, 19889, 19891, 19913, 19919, 19927, 19937, 19949, 19961, 19963, 19973, 19979, 19991, 19993, 19997, 20011, 20021, 20023, 20029, 20047, 20051, 20063, 20071, 20089, 20101, 20107, 20113, 20117, 20123, 20129, 20143, 20147, 20149, 20161, 20173, 20177, 20183, 20201, 20219, 20231, 20233, 20249, 20261, 20269, 20287, 20297, 20323, 20327, 20333, 20341, 20347, 20353, 20357, 20359, 20369, 20389, 20393, 20399, 20407, 20411, 20431, 20441, 20443, 20477, 20479, 20483, 20507, 20509, 20521, 20533, 20543, 20549, 20551, 20563, 20593, 20599, 20611, 20627, 20639, 20641, 20663, 20681, 20693, 20707, 20717, 20719, 20731, 20743, 20747, 20749, 20753, 20759, 20771, 20773, 20789, 20807, 20809, 20849, 20857, 20873, 20879, 20887, 20897, 20899, 20903, 20921, 20929, 20939, 20947, 20959, 20963, 20981, 20983, 21001, 21011, 21013, 21017, 21019, 21023, 21031, 21059, 21061, 21067, 21089, 21101, 21107, 21121, 21139, 21143, 21149, 21157, 21163, 21169, 21179, 21187, 21191, 21193, 21211, 21221, 21227, 21247, 21269, 21277, 21283, 21313, 21317, 21319, 21323, 21341, 21347, 21377, 21379, 21383, 21391, 21397, 21401, 21407, 21419, 21433, 21467, 21481, 21487, 21491, 21493, 21499, 21503, 21517, 21521, 21523, 21529, 21557, 21559, 21563, 21569, 21577, 21587, 21589, 21599, 21601, 21611, 21613, 21617, 21647, 21649, 21661, 21673, 21683, 21701, 21713, 21727, 21737, 21739, 21751, 21757, 21767, 21773, 21787, 21799, 21803, 21817, 21821, 21839, 21841, 21851, 21859, 21863, 21871, 21881, 21893, 21911, 21929, 21937, 21943, 21961, 21977, 21991, 21997, 22003, 22013, 22027, 22031, 22037, 22039, 22051, 22063, 22067, 22073, 22079, 22091, 22093, 22109, 22111, 22123, 22129, 22133, 22147, 22153, 22157, 22159, 22171, 22189, 22193, 22229, 22247, 22259, 22271, 22273, 22277, 22279, 22283, 22291, 22303, 22307, 22343, 22349, 22367, 22369, 22381, 22391, 22397, 22409, 22433, 22441, 22447, 22453, 22469, 22481, 22483, 22501, 22511, 22531, 22541, 22543, 22549, 22567, 22571, 22573, 22613, 22619, 22621, 22637, 22639, 22643, 22651, 22669, 22679, 22691, 22697, 22699, 22709, 22717, 22721, 22727, 22739, 22741, 22751, 22769, 22777, 22783, 22787, 22807, 22811, 22817, 22853, 22859, 22861, 22871, 22877, 22901, 22907, 22921, 22937, 22943, 22961, 22963, 22973, 22993, 23003, 23011, 23017, 23021, 23027, 23029, 23039, 23041, 23053, 23057, 23059, 23063, 23071, 23081, 23087, 23099, 23117, 23131, 23143, 23159, 23167, 23173, 23189, 23197, 23201, 23203, 23209, 23227, 23251, 23269, 23279, 23291, 23293, 23297, 23311, 23321, 23327, 23333, 23339, 23357, 23369, 23371, 23399, 23417, 23431, 23447, 23459, 23473, 23497, 23509, 23531, 23537, 23539, 23549, 23557, 23561, 23563, 23567, 23581, 23593, 23599, 23603, 23609, 23623, 23627, 23629, 23633, 23663, 23669, 23671, 23677, 23687, 23689, 23719, 23741, 23743, 23747, 23753, 23761, 23767, 23773, 23789, 23801, 23813, 23819, 23827, 23831, 23833, 23857, 23869, 23873, 23879, 23887, 23893, 23899, 23909, 23911, 23917, 23929, 23957, 23971, 23977, 23981, 23993, 24001, 24007, 24019, 24023, 24029, 24043, 24049, 24061, 24071, 24077, 24083, 24091, 24097, 24103, 24107, 24109, 24113, 24121, 24133, 24137, 24151, 24169, 24179, 24181, 24197, 24203, 24223, 24229, 24239, 24247, 24251, 24281, 24317, 24329, 24337, 24359, 24371, 24373, 24379, 24391, 24407, 24413, 24419, 24421, 24439, 24443, 24469, 24473, 24481, 24499, 24509, 24517, 24527, 24533, 24547, 24551, 24571, 24593, 24611, 24623, 24631, 24659, 24671, 24677, 24683, 24691, 24697, 24709, 24733, 24749, 24763, 24767, 24781, 24793, 24799, 24809, 24821, 24841, 24847, 24851, 24859, 24877, 24889, 24907, 24917, 24919, 24923, 24943, 24953, 24967, 24971, 24977, 24979, 24989, 25013, 25031, 25033, 25037, 25057, 25073, 25087, 25097, 25111, 25117, 25121, 25127, 25147, 25153, 25163, 25169, 25171, 25183, 25189, 25219, 25229, 25237, 25243, 25247, 25253, 25261, 25301, 25303, 25307, 25309, 25321, 25339, 25343, 25349, 25357, 25367, 25373, 25391, 25409, 25411, 25423, 25439, 25447, 25453, 25457, 25463, 25469, 25471, 25523, 25537, 25541, 25561, 25577, 25579, 25583, 25589, 25601, 25603, 25609, 25621, 25633, 25639, 25643, 25657, 25667, 25673, 25679, 25693, 25703, 25717, 25733, 25741, 25747, 25759, 25763, 25771, 25793, 25799, 25801, 25819, 25841, 25847, 25849, 25867, 25873, 25889, 25903, 25913, 25919, 25931, 25933, 25939, 25943, 25951, 25969, 25981, 25997, 25999, 26003, 26017, 26021, 26029, 26041, 26053, 26083, 26099, 26107, 26111, 26113, 26119, 26141, 26153, 26161, 26171, 26177, 26183, 26189, 26203, 26209, 26227, 26237, 26249, 26251, 26261, 26263, 26267, 26293, 26297, 26309, 26317, 26321, 26339, 26347, 26357, 26371, 26387, 26393, 26399, 26407, 26417, 26423, 26431, 26437, 26449, 26459, 26479, 26489, 26497, 26501, 26513, 26539, 26557, 26561, 26573, 26591, 26597, 26627, 26633, 26641, 26647, 26669, 26681, 26683, 26687, 26693, 26699, 26701, 26711, 26713, 26717, 26723, 26729, 26731, 26737, 26759, 26777, 26783, 26801, 26813, 26821, 26833, 26839, 26849, 26861, 26863, 26879, 26881, 26891, 26893, 26903, 26921, 26927, 26947, 26951, 26953, 26959, 26981, 26987, 26993, 27011, 27017, 27031, 27043, 27059, 27061, 27067, 27073, 27077, 27091, 27103, 27107, 27109, 27127, 27143, 27179, 27191, 27197, 27211, 27239, 27241, 27253, 27259, 27271, 27277, 27281, 27283, 27299, 27329, 27337, 27361, 27367, 27397, 27407, 27409, 27427, 27431, 27437, 27449, 27457, 27479, 27481, 27487, 27509, 27527, 27529, 27539, 27541, 27551, 27581, 27583, 27611, 27617, 27631, 27647, 27653, 27673, 27689, 27691, 27697, 27701, 27733, 27737, 27739, 27743, 27749, 27751, 27763, 27767, 27773, 27779, 27791, 27793, 27799, 27803, 27809, 27817, 27823, 27827, 27847, 27851, 27883, 27893, 27901, 27917, 27919, 27941, 27943, 27947, 27953, 27961, 27967, 27983, 27997, 28001, 28019, 28027, 28031, 28051, 28057, 28069, 28081, 28087, 28097, 28099, 28109, 28111, 28123, 28151, 28163, 28181, 28183, 28201, 28211, 28219, 28229, 28277, 28279, 28283, 28289, 28297, 28307, 28309, 28319, 28349, 28351, 28387, 28393, 28403, 28409, 28411, 28429, 28433, 28439, 28447, 28463, 28477, 28493, 28499, 28513, 28517, 28537, 28541, 28547, 28549, 28559, 28571, 28573, 28579, 28591, 28597, 28603, 28607, 28619, 28621, 28627, 28631, 28643, 28649, 28657, 28661, 28663, 28669, 28687, 28697, 28703, 28711, 28723, 28729, 28751, 28753, 28759, 28771, 28789, 28793, 28807, 28813, 28817, 28837, 28843, 28859, 28867, 28871, 28879, 28901, 28909, 28921, 28927, 28933, 28949, 28961, 28979, 29009, 29017, 29021, 29023, 29027, 29033, 29059, 29063, 29077, 29101, 29123, 29129, 29131, 29137, 29147, 29153, 29167, 29173, 29179, 29191, 29201, 29207, 29209, 29221, 29231, 29243, 29251, 29269, 29287, 29297, 29303, 29311, 29327, 29333, 29339, 29347, 29363, 29383, 29387, 29389, 29399, 29401, 29411, 29423, 29429, 29437, 29443, 29453, 29473, 29483, 29501, 29527, 29531, 29537, 29567, 29569, 29573, 29581, 29587, 29599, 29611, 29629, 29633, 29641, 29663, 29669, 29671, 29683, 29717, 29723, 29741, 29753, 29759, 29761, 29789, 29803, 29819, 29833, 29837, 29851, 29863, 29867, 29873, 29879, 29881, 29917, 29921, 29927, 29947, 29959, 29983, 29989, 30011, 30013, 30029, 30047, 30059, 30071, 30089, 30091, 30097, 30103, 30109, 30113, 30119, 30133, 30137, 30139, 30161, 30169, 30181, 30187, 30197, 30203, 30211, 30223, 30241, 30253, 30259, 30269, 30271, 30293, 30307, 30313, 30319, 30323, 30341, 30347, 30367, 30389, 30391, 30403, 30427, 30431, 30449, 30467, 30469, 30491, 30493, 30497, 30509, 30517, 30529, 30539, 30553, 30557, 30559, 30577, 30593, 30631, 30637, 30643, 30649, 30661, 30671, 30677, 30689, 30697, 30703, 30707, 30713, 30727, 30757, 30763, 30773, 30781, 30803, 30809, 30817, 30829, 30839, 30841, 30851, 30853, 30859, 30869, 30871, 30881, 30893, 30911, 30931, 30937, 30941, 30949, 30971, 30977, 30983, 31013, 31019, 31033, 31039, 31051, 31063, 31069, 31079, 31081, 31091, 31121, 31123, 31139, 31147, 31151, 31153, 31159, 31177, 31181, 31183, 31189, 31193, 31219, 31223, 31231, 31237, 31247, 31249, 31253, 31259, 31267, 31271, 31277, 31307, 31319, 31321, 31327, 31333, 31337, 31357, 31379, 31387, 31391, 31393, 31397, 31469, 31477, 31481, 31489, 31511, 31513, 31517, 31531, 31541, 31543, 31547, 31567, 31573, 31583, 31601, 31607, 31627, 31643, 31649, 31657, 31663, 31667, 31687, 31699, 31721, 31723, 31727, 31729, 31741, 31751, 31769, 31771, 31793, 31799, 31817, 31847, 31849, 31859, 31873, 31883, 31891, 31907, 31957, 31963, 31973, 31981, 31991, 32003, 32009, 32027, 32029, 32051, 32057, 32059, 32063, 32069, 32077, 32083, 32089, 32099, 32117, 32119, 32141, 32143, 32159, 32173, 32183, 32189, 32191, 32203, 32213, 32233, 32237, 32251, 32257, 32261, 32297, 32299, 32303, 32309, 32321, 32323, 32327, 32341, 32353, 32359, 32363, 32369, 32371, 32377, 32381, 32401, 32411, 32413, 32423, 32429, 32441, 32443, 32467, 32479, 32491, 32497, 32503, 32507, 32531, 32533, 32537, 32561, 32563, 32569, 32573, 32579, 32587, 32603, 32609, 32611, 32621, 32633, 32647, 32653, 32687, 32693, 32707, 32713, 32717, 32719, 32749, 32771, 32779, 32783, 32789, 32797, 32801, 32803, 32831, 32833, 32839, 32843, 32869, 32887, 32909, 32911, 32917, 32933, 32939, 32941, 32957, 32969, 32971, 32983, 32987, 32993, 32999, 33013, 33023, 33029, 33037, 33049, 33053, 33071, 33073, 33083, 33091, 33107, 33113, 33119, 33149, 33151, 33161, 33179, 33181, 33191, 33199, 33203, 33211, 33223, 33247, 33287, 33289, 33301, 33311, 33317, 33329, 33331, 33343, 33347, 33349, 33353, 33359, 33377, 33391, 33403, 33409, 33413, 33427, 33457, 33461, 33469, 33479, 33487, 33493, 33503, 33521, 33529, 33533, 33547, 33563, 33569, 33577, 33581, 33587, 33589, 33599, 33601, 33613, 33617, 33619, 33623, 33629, 33637, 33641, 33647, 33679, 33703, 33713, 33721, 33739, 33749, 33751, 33757, 33767, 33769, 33773, 33791, 33797, 33809, 33811, 33827, 33829, 33851, 33857, 33863, 33871, 33889, 33893, 33911, 33923, 33931, 33937, 33941, 33961, 33967, 33997, 34019, 34031, 34033, 34039, 34057, 34061, 34123, 34127, 34129, 34141, 34147, 34157, 34159, 34171, 34183, 34211, 34213, 34217, 34231, 34253, 34259, 34261, 34267, 34273, 34283, 34297, 34301, 34303, 34313, 34319, 34327, 34337, 34351, 34361, 34367, 34369, 34381, 34403, 34421, 34429, 34439, 34457, 34469, 34471, 34483, 34487, 34499, 34501, 34511, 34513, 34519, 34537, 34543, 34549, 34583, 34589, 34591, 34603, 34607, 34613, 34631, 34649, 34651, 34667, 34673, 34679, 34687, 34693, 34703, 34721, 34729, 34739, 34747, 34757, 34759, 34763, 34781, 34807, 34819, 34841, 34843, 34847, 34849, 34871, 34877, 34883, 34897, 34913, 34919, 34939, 34949, 34961, 34963, 34981, 35023, 35027, 35051, 35053, 35059, 35069, 35081, 35083, 35089, 35099, 35107, 35111, 35117, 35129, 35141, 35149, 35153, 35159, 35171, 35201, 35221, 35227, 35251, 35257, 35267, 35279, 35281, 35291, 35311, 35317, 35323, 35327, 35339, 35353, 35363, 35381, 35393, 35401, 35407, 35419, 35423, 35437, 35447, 35449, 35461, 35491, 35507, 35509, 35521, 35527, 35531, 35533, 35537, 35543, 35569, 35573, 35591, 35593, 35597, 35603, 35617, 35671, 35677, 35729, 35731, 35747, 35753, 35759, 35771, 35797, 35801, 35803, 35809, 35831, 35837, 35839, 35851, 35863, 35869, 35879, 35897, 35899, 35911, 35923, 35933, 35951, 35963, 35969, 35977, 35983, 35993, 35999, 36007, 36011, 36013, 36017, 36037, 36061, 36067, 36073, 36083, 36097, 36107, 36109, 36131, 36137, 36151, 36161, 36187, 36191, 36209, 36217, 36229, 36241, 36251, 36263, 36269, 36277, 36293, 36299, 36307, 36313, 36319, 36341, 36343, 36353, 36373, 36383, 36389, 36433, 36451, 36457, 36467, 36469, 36473, 36479, 36493, 36497, 36523, 36527, 36529, 36541, 36551, 36559, 36563, 36571, 36583, 36587, 36599, 36607, 36629, 36637, 36643, 36653, 36671, 36677, 36683, 36691, 36697, 36709, 36713, 36721, 36739, 36749, 36761, 36767, 36779, 36781, 36787, 36791, 36793, 36809, 36821, 36833, 36847, 36857, 36871, 36877, 36887, 36899, 36901, 36913, 36919, 36923, 36929, 36931, 36943, 36947, 36973, 36979, 36997, 37003, 37013, 37019, 37021, 37039, 37049, 37057, 37061, 37087, 37097, 37117, 37123, 37139, 37159, 37171, 37181, 37189, 37199, 37201, 37217, 37223, 37243, 37253, 37273, 37277, 37307, 37309, 37313, 37321, 37337, 37339, 37357, 37361, 37363, 37369, 37379, 37397, 37409, 37423, 37441, 37447, 37463, 37483, 37489, 37493, 37501, 37507, 37511, 37517, 37529, 37537, 37547, 37549, 37561, 37567, 37571, 37573, 37579, 37589, 37591, 37607, 37619, 37633, 37643, 37649, 37657, 37663, 37691, 37693, 37699, 37717, 37747, 37781, 37783, 37799, 37811, 37813, 37831, 37847, 37853, 37861, 37871, 37879, 37889, 37897, 37907, 37951, 37957, 37963, 37967, 37987, 37991, 37993, 37997, 38011, 38039, 38047, 38053, 38069, 38083, 38113, 38119, 38149, 38153, 38167, 38177, 38183, 38189, 38197, 38201, 38219, 38231, 38237, 38239, 38261, 38273, 38281, 38287, 38299, 38303, 38317, 38321, 38327, 38329, 38333, 38351, 38371, 38377, 38393, 38431, 38447, 38449, 38453, 38459, 38461, 38501, 38543, 38557, 38561, 38567, 38569, 38593, 38603, 38609, 38611, 38629, 38639, 38651, 38653, 38669, 38671, 38677, 38693, 38699, 38707, 38711, 38713, 38723, 38729, 38737, 38747, 38749, 38767, 38783, 38791, 38803, 38821, 38833, 38839, 38851, 38861, 38867, 38873, 38891, 38903, 38917, 38921, 38923, 38933, 38953, 38959, 38971, 38977, 38993, 39019, 39023, 39041, 39043, 39047, 39079, 39089, 39097, 39103, 39107, 39113, 39119, 39133, 39139, 39157, 39161, 39163, 39181, 39191, 39199, 39209, 39217, 39227, 39229, 39233, 39239, 39241, 39251, 39293, 39301, 39313, 39317, 39323, 39341, 39343, 39359, 39367, 39371, 39373, 39383, 39397, 39409, 39419, 39439, 39443, 39451, 39461, 39499, 39503, 39509, 39511, 39521, 39541, 39551, 39563, 39569, 39581, 39607, 39619, 39623, 39631, 39659, 39667, 39671, 39679, 39703, 39709, 39719, 39727, 39733, 39749, 39761, 39769, 39779, 39791, 39799, 39821, 39827, 39829, 39839, 39841, 39847, 39857, 39863, 39869, 39877, 39883, 39887, 39901, 39929, 39937, 39953, 39971, 39979, 39983, 39989, 40009, 40013, 40031, 40037, 40039, 40063, 40087, 40093, 40099, 40111, 40123, 40127, 40129, 40151, 40153, 40163, 40169, 40177, 40189, 40193, 40213, 40231, 40237, 40241, 40253, 40277, 40283, 40289, 40343, 40351, 40357, 40361, 40387, 40423, 40427, 40429, 40433, 40459, 40471, 40483, 40487, 40493, 40499, 40507, 40519, 40529, 40531, 40543, 40559, 40577, 40583, 40591, 40597, 40609, 40627, 40637, 40639, 40693, 40697, 40699, 40709, 40739, 40751, 40759, 40763, 40771, 40787, 40801, 40813, 40819, 40823, 40829, 40841, 40847, 40849, 40853, 40867, 40879, 40883, 40897, 40903, 40927, 40933, 40939, 40949, 40961, 40973, 40993, 41011, 41017, 41023, 41039, 41047, 41051, 41057, 41077, 41081, 41113, 41117, 41131, 41141, 41143, 41149, 41161, 41177, 41179, 41183, 41189, 41201, 41203, 41213, 41221, 41227, 41231, 41233, 41243, 41257, 41263, 41269, 41281, 41299, 41333, 41341, 41351, 41357, 41381, 41387, 41389, 41399, 41411, 41413, 41443, 41453, 41467, 41479, 41491, 41507, 41513, 41519, 41521, 41539, 41543, 41549, 41579, 41593, 41597, 41603, 41609, 41611, 41617, 41621, 41627, 41641, 41647, 41651, 41659, 41669, 41681, 41687, 41719, 41729, 41737, 41759, 41761, 41771, 41777, 41801, 41809, 41813, 41843, 41849, 41851, 41863, 41879, 41887, 41893, 41897, 41903, 41911, 41927, 41941, 41947, 41953, 41957, 41959, 41969, 41981, 41983, 41999, 42013, 42017, 42019, 42023, 42043, 42061, 42071, 42073, 42083, 42089, 42101, 42131, 42139, 42157, 42169, 42179, 42181, 42187, 42193, 42197, 42209, 42221, 42223, 42227, 42239, 42257, 42281, 42283, 42293, 42299, 42307, 42323, 42331, 42337, 42349, 42359, 42373, 42379, 42391, 42397, 42403, 42407, 42409, 42433, 42437, 42443, 42451, 42457, 42461, 42463, 42467, 42473, 42487, 42491, 42499, 42509, 42533, 42557, 42569, 42571, 42577, 42589, 42611, 42641, 42643, 42649, 42667, 42677, 42683, 42689, 42697, 42701, 42703, 42709, 42719, 42727, 42737, 42743, 42751, 42767, 42773, 42787, 42793, 42797, 42821, 42829, 42839, 42841, 42853, 42859, 42863, 42899, 42901, 42923, 42929, 42937, 42943, 42953, 42961, 42967, 42979, 42989, 43003, 43013, 43019, 43037, 43049, 43051, 43063, 43067, 43093, 43103, 43117, 43133, 43151, 43159, 43177, 43189, 43201, 43207, 43223, 43237, 43261, 43271, 43283, 43291, 43313, 43319, 43321, 43331, 43391, 43397, 43399, 43403, 43411, 43427, 43441, 43451, 43457, 43481, 43487, 43499, 43517, 43541, 43543, 43573, 43577, 43579, 43591, 43597, 43607, 43609, 43613, 43627, 43633, 43649, 43651, 43661, 43669, 43691, 43711, 43717, 43721, 43753, 43759, 43777, 43781, 43783, 43787, 43789, 43793, 43801, 43853, 43867, 43889, 43891, 43913, 43933, 43943, 43951, 43961, 43963, 43969, 43973, 43987, 43991, 43997, 44017, 44021, 44027, 44029, 44041, 44053, 44059, 44071, 44087, 44089, 44101, 44111, 44119, 44123, 44129, 44131, 44159, 44171, 44179, 44189, 44201, 44203, 44207, 44221, 44249, 44257, 44263, 44267, 44269, 44273, 44279, 44281, 44293, 44351, 44357, 44371, 44381, 44383, 44389, 44417, 44449, 44453, 44483, 44491, 44497, 44501, 44507, 44519, 44531, 44533, 44537, 44543, 44549, 44563, 44579, 44587, 44617, 44621, 44623, 44633, 44641, 44647, 44651, 44657, 44683, 44687, 44699, 44701, 44711, 44729, 44741, 44753, 44771, 44773, 44777, 44789, 44797, 44809, 44819, 44839, 44843, 44851, 44867, 44879, 44887, 44893, 44909, 44917, 44927, 44939, 44953, 44959, 44963, 44971, 44983, 44987, 45007, 45013, 45053, 45061, 45077, 45083, 45119, 45121, 45127, 45131, 45137, 45139, 45161, 45179, 45181, 45191, 45197, 45233, 45247, 45259, 45263, 45281, 45289, 45293, 45307, 45317, 45319, 45329, 45337, 45341, 45343, 45361, 45377, 45389, 45403, 45413, 45427, 45433, 45439, 45481, 45491, 45497, 45503, 45523, 45533, 45541, 45553, 45557, 45569, 45587, 45589, 45599, 45613, 45631, 45641, 45659, 45667, 45673, 45677, 45691, 45697, 45707, 45737, 45751, 45757, 45763, 45767, 45779, 45817, 45821, 45823, 45827, 45833, 45841, 45853, 45863, 45869, 45887, 45893, 45943, 45949, 45953, 45959, 45971, 45979, 45989, 46021, 46027, 46049, 46051, 46061, 46073, 46091, 46093, 46099, 46103, 46133, 46141, 46147, 46153, 46171, 46181, 46183, 46187, 46199, 46219, 46229, 46237, 46261, 46271, 46273, 46279, 46301, 46307, 46309, 46327, 46337, 46349, 46351, 46381, 46399, 46411, 46439, 46441, 46447, 46451, 46457, 46471, 46477, 46489, 46499, 46507, 46511, 46523, 46549, 46559, 46567, 46573, 46589, 46591, 46601, 46619, 46633, 46639, 46643, 46649, 46663, 46679, 46681, 46687, 46691, 46703, 46723, 46727, 46747, 46751, 46757, 46769, 46771, 46807, 46811, 46817, 46819, 46829, 46831, 46853, 46861, 46867, 46877, 46889, 46901, 46919, 46933, 46957, 46993, 46997, 47017, 47041, 47051, 47057, 47059, 47087, 47093, 47111, 47119, 47123, 47129, 47137, 47143, 47147, 47149, 47161, 47189, 47207, 47221, 47237, 47251, 47269, 47279, 47287, 47293, 47297, 47303, 47309, 47317, 47339, 47351, 47353, 47363, 47381, 47387, 47389, 47407, 47417, 47419, 47431, 47441, 47459, 47491, 47497, 47501, 47507, 47513, 47521, 47527, 47533, 47543, 47563, 47569, 47581, 47591, 47599, 47609, 47623, 47629, 47639, 47653, 47657, 47659, 47681, 47699, 47701, 47711, 47713, 47717, 47737, 47741, 47743, 47777, 47779, 47791, 47797, 47807, 47809, 47819, 47837, 47843, 47857, 47869, 47881, 47903, 47911, 47917, 47933, 47939, 47947, 47951, 47963, 47969, 47977, 47981, 48017, 48023, 48029, 48049, 48073, 48079, 48091, 48109, 48119, 48121, 48131, 48157, 48163, 48179, 48187, 48193, 48197, 48221, 48239, 48247, 48259, 48271, 48281, 48299, 48311, 48313, 48337, 48341, 48353, 48371, 48383, 48397, 48407, 48409, 48413, 48437, 48449, 48463, 48473, 48479, 48481, 48487, 48491, 48497, 48523, 48527, 48533, 48539, 48541, 48563, 48571, 48589, 48593, 48611, 48619, 48623, 48647, 48649, 48661, 48673, 48677, 48679, 48731, 48733, 48751, 48757, 48761, 48767, 48779, 48781, 48787, 48799, 48809, 48817, 48821, 48823, 48847, 48857, 48859, 48869, 48871, 48883, 48889, 48907, 48947, 48953, 48973, 48989, 48991, 49003, 49009, 49019, 49031, 49033, 49037, 49043, 49057, 49069, 49081, 49103, 49109, 49117, 49121, 49123, 49139, 49157, 49169, 49171, 49177, 49193, 49199, 49201, 49207, 49211, 49223, 49253, 49261, 49277, 49279, 49297, 49307, 49331, 49333, 49339, 49363, 49367, 49369, 49391, 49393, 49409, 49411, 49417, 49429, 49433, 49451, 49459, 49463, 49477, 49481, 49499, 49523, 49529, 49531, 49537, 49547, 49549, 49559, 49597, 49603, 49613, 49627, 49633, 49639, 49663, 49667, 49669, 49681, 49697, 49711, 49727, 49739, 49741, 49747, 49757, 49783, 49787, 49789, 49801, 49807, 49811, 49823, 49831, 49843, 49853, 49871, 49877, 49891, 49919, 49921, 49927, 49937, 49939, 49943, 49957, 49991, 49993, 49999, 50021, 50023, 50033, 50047, 50051, 50053, 50069, 50077, 50087, 50093, 50101, 50111, 50119, 50123, 50129, 50131, 50147, 50153, 50159, 50177, 50207, 50221, 50227, 50231, 50261, 50263, 50273, 50287, 50291, 50311, 50321, 50329, 50333, 50341, 50359, 50363, 50377, 50383, 50387, 50411, 50417, 50423, 50441, 50459, 50461, 50497, 50503, 50513, 50527, 50539, 50543, 50549, 50551, 50581, 50587, 50591, 50593, 50599, 50627, 50647, 50651, 50671, 50683, 50707, 50723, 50741, 50753, 50767, 50773, 50777, 50789, 50821, 50833, 50839, 50849, 50857, 50867, 50873, 50891, 50893, 50909, 50923, 50929, 50951, 50957, 50969, 50971, 50989, 50993, 51001, 51031, 51043, 51047, 51059, 51061, 51071, 51109, 51131, 51133, 51137, 51151, 51157, 51169, 51193, 51197, 51199, 51203, 51217, 51229, 51239, 51241, 51257, 51263, 51283, 51287, 51307, 51329, 51341, 51343, 51347, 51349, 51361, 51383, 51407, 51413, 51419, 51421, 51427, 51431, 51437, 51439, 51449, 51461, 51473, 51479, 51481, 51487, 51503, 51511, 51517, 51521, 51539, 51551, 51563, 51577, 51581, 51593, 51599, 51607, 51613, 51631, 51637, 51647, 51659, 51673, 51679, 51683, 51691, 51713, 51719, 51721, 51749, 51767, 51769, 51787, 51797, 51803, 51817, 51827, 51829, 51839, 51853, 51859, 51869, 51871, 51893, 51899, 51907, 51913, 51929, 51941, 51949, 51971, 51973, 51977, 51991, 52009, 52021, 52027, 52051, 52057, 52067, 52069, 52081, 52103, 52121, 52127, 52147, 52153, 52163, 52177, 52181, 52183, 52189, 52201, 52223, 52237, 52249, 52253, 52259, 52267, 52289, 52291, 52301, 52313, 52321, 52361, 52363, 52369, 52379, 52387, 52391, 52433, 52453, 52457, 52489, 52501, 52511, 52517, 52529, 52541, 52543, 52553, 52561, 52567, 52571, 52579, 52583, 52609, 52627, 52631, 52639, 52667, 52673, 52691, 52697, 52709, 52711, 52721, 52727, 52733, 52747, 52757, 52769, 52783, 52807, 52813, 52817, 52837, 52859, 52861, 52879, 52883, 52889, 52901, 52903, 52919, 52937, 52951, 52957, 52963, 52967, 52973, 52981, 52999, 53003, 53017, 53047, 53051, 53069, 53077, 53087, 53089, 53093, 53101, 53113, 53117, 53129, 53147, 53149, 53161, 53171, 53173, 53189, 53197, 53201, 53231, 53233, 53239, 53267, 53269, 53279, 53281, 53299, 53309, 53323, 53327, 53353, 53359, 53377, 53381, 53401, 53407, 53411, 53419, 53437, 53441, 53453, 53479, 53503, 53507, 53527, 53549, 53551, 53569, 53591, 53593, 53597, 53609, 53611, 53617, 53623, 53629, 53633, 53639, 53653, 53657, 53681, 53693, 53699, 53717, 53719, 53731, 53759, 53773, 53777, 53783, 53791, 53813, 53819, 53831, 53849, 53857, 53861, 53881, 53887, 53891, 53897, 53899, 53917, 53923, 53927, 53939, 53951, 53959, 53987, 53993, 54001, 54011, 54013, 54037, 54049, 54059, 54083, 54091, 54101, 54121, 54133, 54139, 54151, 54163, 54167, 54181, 54193, 54217, 54251, 54269, 54277, 54287, 54293, 54311, 54319, 54323, 54331, 54347, 54361, 54367, 54371, 54377, 54401, 54403, 54409, 54413, 54419, 54421, 54437, 54443, 54449, 54469, 54493, 54497, 54499, 54503, 54517, 54521, 54539, 54541, 54547, 54559, 54563, 54577, 54581, 54583, 54601, 54617, 54623, 54629, 54631, 54647, 54667, 54673, 54679, 54709, 54713, 54721, 54727, 54751, 54767, 54773, 54779, 54787, 54799, 54829, 54833, 54851, 54869, 54877, 54881, 54907, 54917, 54919, 54941, 54949, 54959, 54973, 54979, 54983, 55001, 55009, 55021, 55049, 55051, 55057, 55061, 55073, 55079, 55103, 55109, 55117, 55127, 55147, 55163, 55171, 55201, 55207, 55213, 55217, 55219, 55229, 55243, 55249, 55259, 55291, 55313, 55331, 55333, 55337, 55339, 55343, 55351, 55373, 55381, 55399, 55411, 55439, 55441, 55457, 55469, 55487, 55501, 55511, 55529, 55541, 55547, 55579, 55589, 55603, 55609, 55619, 55621, 55631, 55633, 55639, 55661, 55663, 55667, 55673, 55681, 55691, 55697, 55711, 55717, 55721, 55733, 55763, 55787, 55793, 55799, 55807, 55813, 55817, 55819, 55823, 55829, 55837, 55843, 55849, 55871, 55889, 55897, 55901, 55903, 55921, 55927, 55931, 55933, 55949, 55967, 55987, 55997, 56003, 56009, 56039, 56041, 56053, 56081, 56087, 56093, 56099, 56101, 56113, 56123, 56131, 56149, 56167, 56171, 56179, 56197, 56207, 56209, 56237, 56239, 56249, 56263, 56267, 56269, 56299, 56311, 56333, 56359, 56369, 56377, 56383, 56393, 56401, 56417, 56431, 56437, 56443, 56453, 56467, 56473, 56477, 56479, 56489, 56501, 56503, 56509, 56519, 56527, 56531, 56533, 56543, 56569, 56591, 56597, 56599, 56611, 56629, 56633, 56659, 56663, 56671, 56681, 56687, 56701, 56711, 56713, 56731, 56737, 56747, 56767, 56773, 56779, 56783, 56807, 56809, 56813, 56821, 56827, 56843, 56857, 56873, 56891, 56893, 56897, 56909, 56911, 56921, 56923, 56929, 56941, 56951, 56957, 56963, 56983, 56989, 56993, 56999, 57037, 57041, 57047, 57059, 57073, 57077, 57089, 57097, 57107, 57119, 57131, 57139, 57143, 57149, 57163, 57173, 57179, 57191, 57193, 57203, 57221, 57223, 57241, 57251, 57259, 57269, 57271, 57283, 57287, 57301, 57329, 57331, 57347, 57349, 57367, 57373, 57383, 57389, 57397, 57413, 57427, 57457, 57467, 57487, 57493, 57503, 57527, 57529, 57557, 57559, 57571, 57587, 57593, 57601, 57637, 57641, 57649, 57653, 57667, 57679, 57689, 57697, 57709, 57713, 57719, 57727, 57731, 57737, 57751, 57773, 57781, 57787, 57791, 57793, 57803, 57809, 57829, 57839, 57847, 57853, 57859, 57881, 57899, 57901, 57917, 57923, 57943, 57947, 57973, 57977, 57991, 58013, 58027, 58031, 58043, 58049, 58057, 58061, 58067, 58073, 58099, 58109, 58111, 58129, 58147, 58151, 58153, 58169, 58171, 58189, 58193, 58199, 58207, 58211, 58217, 58229, 58231, 58237, 58243, 58271, 58309, 58313, 58321, 58337, 58363, 58367, 58369, 58379, 58391, 58393, 58403, 58411, 58417, 58427, 58439, 58441, 58451, 58453, 58477, 58481, 58511, 58537, 58543, 58549, 58567, 58573, 58579, 58601, 58603, 58613, 58631, 58657, 58661, 58679, 58687, 58693, 58699, 58711, 58727, 58733, 58741, 58757, 58763, 58771, 58787, 58789, 58831, 58889, 58897, 58901, 58907, 58909, 58913, 58921, 58937, 58943, 58963, 58967, 58979, 58991, 58997, 59009, 59011, 59021, 59023, 59029, 59051, 59053, 59063, 59069, 59077, 59083, 59093, 59107, 59113, 59119, 59123, 59141, 59149, 59159, 59167, 59183, 59197, 59207, 59209, 59219, 59221, 59233, 59239, 59243, 59263, 59273, 59281, 59333, 59341, 59351, 59357, 59359, 59369, 59377, 59387, 59393, 59399, 59407, 59417, 59419, 59441, 59443, 59447, 59453, 59467, 59471, 59473, 59497, 59509, 59513, 59539, 59557, 59561, 59567, 59581, 59611, 59617, 59621, 59627, 59629, 59651, 59659, 59663, 59669, 59671, 59693, 59699, 59707, 59723, 59729, 59743, 59747, 59753, 59771, 59779, 59791, 59797, 59809, 59833, 59863, 59879, 59887, 59921, 59929, 59951, 59957, 59971, 59981, 59999, 60013, 60017, 60029, 60037, 60041, 60077, 60083, 60089, 60091, 60101, 60103, 60107, 60127, 60133, 60139, 60149, 60161, 60167, 60169, 60209, 60217, 60223, 60251, 60257, 60259, 60271, 60289, 60293, 60317, 60331, 60337, 60343, 60353, 60373, 60383, 60397, 60413, 60427, 60443, 60449, 60457, 60493, 60497, 60509, 60521, 60527, 60539, 60589, 60601, 60607, 60611, 60617, 60623, 60631, 60637, 60647, 60649, 60659, 60661, 60679, 60689, 60703, 60719, 60727, 60733, 60737, 60757, 60761, 60763, 60773, 60779, 60793, 60811, 60821, 60859, 60869, 60887, 60889, 60899, 60901, 60913, 60917, 60919, 60923, 60937, 60943, 60953, 60961, 61001, 61007, 61027, 61031, 61043, 61051, 61057, 61091, 61099, 61121, 61129, 61141, 61151, 61153, 61169, 61211, 61223, 61231, 61253, 61261, 61283, 61291, 61297, 61331, 61333, 61339, 61343, 61357, 61363, 61379, 61381, 61403, 61409, 61417, 61441, 61463, 61469, 61471, 61483, 61487, 61493, 61507, 61511, 61519, 61543, 61547, 61553, 61559, 61561, 61583, 61603, 61609, 61613, 61627, 61631, 61637, 61643, 61651, 61657, 61667, 61673, 61681, 61687, 61703, 61717, 61723, 61729, 61751, 61757, 61781, 61813, 61819, 61837, 61843, 61861, 61871, 61879, 61909, 61927, 61933, 61949, 61961, 61967, 61979, 61981, 61987, 61991, 62003, 62011, 62017, 62039, 62047, 62053, 62057, 62071, 62081, 62099, 62119, 62129, 62131, 62137, 62141, 62143, 62171, 62189, 62191, 62201, 62207, 62213, 62219, 62233, 62273, 62297, 62299, 62303, 62311, 62323, 62327, 62347, 62351, 62383, 62401, 62417, 62423, 62459, 62467, 62473, 62477, 62483, 62497, 62501, 62507, 62533, 62539, 62549, 62563, 62581, 62591, 62597, 62603, 62617, 62627, 62633, 62639, 62653, 62659, 62683, 62687, 62701, 62723, 62731, 62743, 62753, 62761, 62773, 62791, 62801, 62819, 62827, 62851, 62861, 62869, 62873, 62897, 62903, 62921, 62927, 62929, 62939, 62969, 62971, 62981, 62983, 62987, 62989, 63029, 63031, 63059, 63067, 63073, 63079, 63097, 63103, 63113, 63127, 63131, 63149, 63179, 63197, 63199, 63211, 63241, 63247, 63277, 63281, 63299, 63311, 63313, 63317, 63331, 63337, 63347, 63353, 63361, 63367, 63377, 63389, 63391, 63397, 63409, 63419, 63421, 63439, 63443, 63463, 63467, 63473, 63487, 63493, 63499, 63521, 63527, 63533, 63541, 63559, 63577, 63587, 63589, 63599, 63601, 63607, 63611, 63617, 63629, 63647, 63649, 63659, 63667, 63671, 63689, 63691, 63697, 63703, 63709, 63719, 63727, 63737, 63743, 63761, 63773, 63781, 63793, 63799, 63803, 63809, 63823, 63839, 63841, 63853, 63857, 63863, 63901, 63907, 63913, 63929, 63949, 63977, 63997, 64007, 64013, 64019, 64033, 64037, 64063, 64067, 64081, 64091, 64109, 64123, 64151, 64153, 64157, 64171, 64187, 64189, 64217, 64223, 64231, 64237, 64271, 64279, 64283, 64301, 64303, 64319, 64327, 64333, 64373, 64381, 64399, 64403, 64433, 64439, 64451, 64453, 64483, 64489, 64499, 64513, 64553, 64567, 64577, 64579, 64591, 64601, 64609, 64613, 64621, 64627, 64633, 64661, 64663, 64667, 64679, 64693, 64709, 64717, 64747, 64763, 64781, 64783, 64793, 64811, 64817, 64849, 64853, 64871, 64877, 64879, 64891, 64901, 64919, 64921, 64927, 64937, 64951, 64969, 64997, 65003, 65011, 65027, 65029, 65033, 65053, 65063, 65071, 65089, 65099, 65101, 65111, 65119, 65123, 65129, 65141, 65147, 65167, 65171, 65173, 65179, 65183, 65203, 65213, 65239, 65257, 65267, 65269, 65287, 65293, 65309, 65323, 65327, 65353, 65357, 65371, 65381, 65393, 65407, 65413, 65419, 65423, 65437, 65447, 65449, 65479, 65497, 65519, 65521, 65537, 65539, 65543, 65551, 65557, 65563, 65579, 65581, 65587, 65599, 65609, 65617, 65629, 65633, 65647, 65651, 65657, 65677, 65687, 65699, 65701, 65707, 65713, 65717, 65719, 65729, 65731, 65761, 65777, 65789, 65809, 65827, 65831, 65837, 65839, 65843, 65851, 65867, 65881, 65899, 65921, 65927, 65929, 65951, 65957, 65963, 65981, 65983, 65993, 66029, 66037, 66041, 66047, 66067, 66071, 66083, 66089, 66103, 66107, 66109, 66137, 66161, 66169, 66173, 66179, 66191, 66221, 66239, 66271, 66293, 66301, 66337, 66343, 66347, 66359, 66361, 66373, 66377, 66383, 66403, 66413, 66431, 66449, 66457, 66463, 66467, 66491, 66499, 66509, 66523, 66529, 66533, 66541, 66553, 66569, 66571, 66587, 66593, 66601, 66617, 66629, 66643, 66653, 66683, 66697, 66701, 66713, 66721, 66733, 66739, 66749, 66751, 66763, 66791, 66797, 66809, 66821, 66841, 66851, 66853, 66863, 66877, 66883, 66889, 66919, 66923, 66931, 66943, 66947, 66949, 66959, 66973, 66977, 67003, 67021, 67033, 67043, 67049, 67057, 67061, 67073, 67079, 67103, 67121, 67129, 67139, 67141, 67153, 67157, 67169, 67181, 67187, 67189, 67211, 67213, 67217, 67219, 67231, 67247, 67261, 67271, 67273, 67289, 67307, 67339, 67343, 67349, 67369, 67391, 67399, 67409, 67411, 67421, 67427, 67429, 67433, 67447, 67453, 67477, 67481, 67489, 67493, 67499, 67511, 67523, 67531, 67537, 67547, 67559, 67567, 67577, 67579, 67589, 67601, 67607, 67619, 67631, 67651, 67679, 67699, 67709, 67723, 67733, 67741, 67751, 67757, 67759, 67763, 67777, 67783, 67789, 67801, 67807, 67819, 67829, 67843, 67853, 67867, 67883, 67891, 67901, 67927, 67931, 67933, 67939, 67943, 67957, 67961, 67967, 67979, 67987, 67993, 68023, 68041, 68053, 68059, 68071, 68087, 68099, 68111, 68113, 68141, 68147, 68161, 68171, 68207, 68209, 68213, 68219, 68227, 68239, 68261, 68279, 68281, 68311, 68329, 68351, 68371, 68389, 68399, 68437, 68443, 68447, 68449, 68473, 68477, 68483, 68489, 68491, 68501, 68507, 68521, 68531, 68539, 68543, 68567, 68581, 68597, 68611, 68633, 68639, 68659, 68669, 68683, 68687, 68699, 68711, 68713, 68729, 68737, 68743, 68749, 68767, 68771, 68777, 68791, 68813, 68819, 68821, 68863, 68879, 68881, 68891, 68897, 68899, 68903, 68909, 68917, 68927, 68947, 68963, 68993, 69001, 69011, 69019, 69029, 69031, 69061, 69067, 69073, 69109, 69119, 69127, 69143, 69149, 69151, 69163, 69191, 69193, 69197, 69203, 69221, 69233, 69239, 69247, 69257, 69259, 69263, 69313, 69317, 69337, 69341, 69371, 69379, 69383, 69389, 69401, 69403, 69427, 69431, 69439, 69457, 69463, 69467, 69473, 69481, 69491, 69493, 69497, 69499, 69539, 69557, 69593, 69623, 69653, 69661, 69677, 69691, 69697, 69709, 69737, 69739, 69761, 69763, 69767, 69779, 69809, 69821, 69827, 69829, 69833, 69847, 69857, 69859, 69877, 69899, 69911, 69929, 69931, 69941, 69959, 69991, 69997, 70001, 70003, 70009, 70019, 70039, 70051, 70061, 70067, 70079, 70099, 70111, 70117, 70121, 70123, 70139, 70141, 70157, 70163, 70177, 70181, 70183, 70199, 70201, 70207, 70223, 70229, 70237, 70241, 70249, 70271, 70289, 70297, 70309, 70313, 70321, 70327, 70351, 70373, 70379, 70381, 70393, 70423, 70429, 70439, 70451, 70457, 70459, 70481, 70487, 70489, 70501, 70507, 70529, 70537, 70549, 70571, 70573, 70583, 70589, 70607, 70619, 70621, 70627, 70639, 70657, 70663, 70667, 70687, 70709, 70717, 70729, 70753, 70769, 70783, 70793, 70823, 70841, 70843, 70849, 70853, 70867, 70877, 70879, 70891, 70901, 70913, 70919, 70921, 70937, 70949, 70951, 70957, 70969, 70979, 70981, 70991, 70997, 70999, 71011, 71023, 71039, 71059, 71069, 71081, 71089, 71119, 71129, 71143, 71147, 71153, 71161, 71167, 71171, 71191, 71209, 71233, 71237, 71249, 71257, 71261, 71263, 71287, 71293, 71317, 71327, 71329, 71333, 71339, 71341, 71347, 71353, 71359, 71363, 71387, 71389, 71399, 71411, 71413, 71419, 71429, 71437, 71443, 71453, 71471, 71473, 71479, 71483, 71503, 71527, 71537, 71549, 71551, 71563, 71569, 71593, 71597, 71633, 71647, 71663, 71671, 71693, 71699, 71707, 71711, 71713, 71719, 71741, 71761, 71777, 71789, 71807, 71809, 71821, 71837, 71843, 71849, 71861, 71867, 71879, 71881, 71887, 71899, 71909, 71917, 71933, 71941, 71947, 71963, 71971, 71983, 71987, 71993, 71999, 72019, 72031, 72043, 72047, 72053, 72073, 72077, 72089, 72091, 72101, 72103, 72109, 72139, 72161, 72167, 72169, 72173, 72211, 72221, 72223, 72227, 72229, 72251, 72253, 72269, 72271, 72277, 72287, 72307, 72313, 72337, 72341, 72353, 72367, 72379, 72383, 72421, 72431, 72461, 72467, 72469, 72481, 72493, 72497, 72503, 72533, 72547, 72551, 72559, 72577, 72613, 72617, 72623, 72643, 72647, 72649, 72661, 72671, 72673, 72679, 72689, 72701, 72707, 72719, 72727, 72733, 72739, 72763, 72767, 72797, 72817, 72823, 72859, 72869, 72871, 72883, 72889, 72893, 72901, 72907, 72911, 72923, 72931, 72937, 72949, 72953, 72959, 72973, 72977, 72997, 73009, 73013, 73019, 73037, 73039, 73043, 73061, 73063, 73079, 73091, 73121, 73127, 73133, 73141, 73181, 73189, 73237, 73243, 73259, 73277, 73291, 73303, 73309, 73327, 73331, 73351, 73361, 73363, 73369, 73379, 73387, 73417, 73421, 73433, 73453, 73459, 73471, 73477, 73483, 73517, 73523, 73529, 73547, 73553, 73561, 73571, 73583, 73589, 73597, 73607, 73609, 73613, 73637, 73643, 73651, 73673, 73679, 73681, 73693, 73699, 73709, 73721, 73727, 73751, 73757, 73771, 73783, 73819, 73823, 73847, 73849, 73859, 73867, 73877, 73883, 73897, 73907, 73939, 73943, 73951, 73961, 73973, 73999, 74017, 74021, 74027, 74047, 74051, 74071, 74077, 74093, 74099, 74101, 74131, 74143, 74149, 74159, 74161, 74167, 74177, 74189, 74197, 74201, 74203, 74209, 74219, 74231, 74257, 74279, 74287, 74293, 74297, 74311, 74317, 74323, 74353, 74357, 74363, 74377, 74381, 74383, 74411, 74413, 74419, 74441, 74449, 74453, 74471, 74489, 74507, 74509, 74521, 74527, 74531, 74551, 74561, 74567, 74573, 74587, 74597, 74609, 74611, 74623, 74653, 74687, 74699, 74707, 74713, 74717, 74719, 74729, 74731, 74747, 74759, 74761, 74771, 74779, 74797, 74821, 74827, 74831, 74843, 74857, 74861, 74869, 74873, 74887, 74891, 74897, 74903, 74923, 74929, 74933, 74941, 74959, 75011, 75013, 75017, 75029, 75037, 75041, 75079, 75083, 75109, 75133, 75149, 75161, 75167, 75169, 75181, 75193, 75209, 75211, 75217, 75223, 75227, 75239, 75253, 75269, 75277, 75289, 75307, 75323, 75329, 75337, 75347, 75353, 75367, 75377, 75389, 75391, 75401, 75403, 75407, 75431, 75437, 75479, 75503, 75511, 75521, 75527, 75533, 75539, 75541, 75553, 75557, 75571, 75577, 75583, 75611, 75617, 75619, 75629, 75641, 75653, 75659, 75679, 75683, 75689, 75703, 75707, 75709, 75721, 75731, 75743, 75767, 75773, 75781, 75787, 75793, 75797, 75821, 75833, 75853, 75869, 75883, 75913, 75931, 75937, 75941, 75967, 75979, 75983, 75989, 75991, 75997, 76001, 76003, 76031, 76039, 76079, 76081, 76091, 76099, 76103, 76123, 76129, 76147, 76157, 76159, 76163, 76207, 76213, 76231, 76243, 76249, 76253, 76259, 76261, 76283, 76289, 76303, 76333, 76343, 76367, 76369, 76379, 76387, 76403, 76421, 76423, 76441, 76463, 76471, 76481, 76487, 76493, 76507, 76511, 76519, 76537, 76541, 76543, 76561, 76579, 76597, 76603, 76607, 76631, 76649, 76651, 76667, 76673, 76679, 76697, 76717, 76733, 76753, 76757, 76771, 76777, 76781, 76801, 76819, 76829, 76831, 76837, 76847, 76871, 76873, 76883, 76907, 76913, 76919, 76943, 76949, 76961, 76963, 76991, 77003, 77017, 77023, 77029, 77041, 77047, 77069, 77081, 77093, 77101, 77137, 77141, 77153, 77167, 77171, 77191, 77201, 77213, 77237, 77239, 77243, 77249, 77261, 77263, 77267, 77269, 77279, 77291, 77317, 77323, 77339, 77347, 77351, 77359, 77369, 77377, 77383, 77417, 77419, 77431, 77447, 77471, 77477, 77479, 77489, 77491, 77509, 77513, 77521, 77527, 77543, 77549, 77551, 77557, 77563, 77569, 77573, 77587, 77591, 77611, 77617, 77621, 77641, 77647, 77659, 77681, 77687, 77689, 77699, 77711, 77713, 77719, 77723, 77731, 77743, 77747, 77761, 77773, 77783, 77797, 77801, 77813, 77839, 77849, 77863, 77867, 77893, 77899, 77929, 77933, 77951, 77969, 77977, 77983, 77999, 78007, 78017, 78031, 78041, 78049, 78059, 78079, 78101, 78121, 78137, 78139, 78157, 78163, 78167, 78173, 78179, 78191, 78193, 78203, 78229, 78233, 78241, 78259, 78277, 78283, 78301, 78307, 78311, 78317, 78341, 78347, 78367, 78401, 78427, 78437, 78439, 78467, 78479, 78487, 78497, 78509, 78511, 78517, 78539, 78541, 78553, 78569, 78571, 78577, 78583, 78593, 78607, 78623, 78643, 78649, 78653, 78691, 78697, 78707, 78713, 78721, 78737, 78779, 78781, 78787, 78791, 78797, 78803, 78809, 78823, 78839, 78853, 78857, 78877, 78887, 78889, 78893, 78901, 78919, 78929, 78941, 78977, 78979, 78989, 79031, 79039, 79043, 79063, 79087, 79103, 79111, 79133, 79139, 79147, 79151, 79153, 79159, 79181, 79187, 79193, 79201, 79229, 79231, 79241, 79259, 79273, 79279, 79283, 79301, 79309, 79319, 79333, 79337, 79349, 79357, 79367, 79379, 79393, 79397, 79399, 79411, 79423, 79427, 79433, 79451, 79481, 79493, 79531, 79537, 79549, 79559, 79561, 79579, 79589, 79601, 79609, 79613, 79621, 79627, 79631, 79633, 79657, 79669, 79687, 79691, 79693, 79697, 79699, 79757, 79769, 79777, 79801, 79811, 79813, 79817, 79823, 79829, 79841, 79843, 79847, 79861, 79867, 79873, 79889, 79901, 79903, 79907, 79939, 79943, 79967, 79973, 79979, 79987, 79997, 79999, 80021, 80039, 80051, 80071, 80077, 80107, 80111, 80141, 80147, 80149, 80153, 80167, 80173, 80177, 80191, 80207, 80209, 80221, 80231, 80233, 80239, 80251, 80263, 80273, 80279, 80287, 80309, 80317, 80329, 80341, 80347, 80363, 80369, 80387, 80407, 80429, 80447, 80449, 80471, 80473, 80489, 80491, 80513, 80527, 80537, 80557, 80567, 80599, 80603, 80611, 80621, 80627, 80629, 80651, 80657, 80669, 80671, 80677, 80681, 80683, 80687, 80701, 80713, 80737, 80747, 80749, 80761, 80777, 80779, 80783, 80789, 80803, 80809, 80819, 80831, 80833, 80849, 80863, 80897, 80909, 80911, 80917, 80923, 80929, 80933, 80953, 80963, 80989, 81001, 81013, 81017, 81019, 81023, 81031, 81041, 81043, 81047, 81049, 81071, 81077, 81083, 81097, 81101, 81119, 81131, 81157, 81163, 81173, 81181, 81197, 81199, 81203, 81223, 81233, 81239, 81281, 81283, 81293, 81299, 81307, 81331, 81343, 81349, 81353, 81359, 81371, 81373, 81401, 81409, 81421, 81439, 81457, 81463, 81509, 81517, 81527, 81533, 81547, 81551, 81553, 81559, 81563, 81569, 81611, 81619, 81629, 81637, 81647, 81649, 81667, 81671, 81677, 81689, 81701, 81703, 81707, 81727, 81737, 81749, 81761, 81769, 81773, 81799, 81817, 81839, 81847, 81853, 81869, 81883, 81899, 81901, 81919, 81929, 81931, 81937, 81943, 81953, 81967, 81971, 81973, 82003, 82007, 82009, 82013, 82021, 82031, 82037, 82039, 82051, 82067, 82073, 82129, 82139, 82141, 82153, 82163, 82171, 82183, 82189, 82193, 82207, 82217, 82219, 82223, 82231, 82237, 82241, 82261, 82267, 82279, 82301, 82307, 82339, 82349, 82351, 82361, 82373, 82387, 82393, 82421, 82457, 82463, 82469, 82471, 82483, 82487, 82493, 82499, 82507, 82529, 82531, 82549, 82559, 82561, 82567, 82571, 82591, 82601, 82609, 82613, 82619, 82633, 82651, 82657, 82699, 82721, 82723, 82727, 82729, 82757, 82759, 82763, 82781, 82787, 82793, 82799, 82811, 82813, 82837, 82847, 82883, 82889, 82891, 82903, 82913, 82939, 82963, 82981, 82997, 83003, 83009, 83023, 83047, 83059, 83063, 83071, 83077, 83089, 83093, 83101, 83117, 83137, 83177, 83203, 83207, 83219, 83221, 83227, 83231, 83233, 83243, 83257, 83267, 83269, 83273, 83299, 83311, 83339, 83341, 83357, 83383, 83389, 83399, 83401, 83407, 83417, 83423, 83431, 83437, 83443, 83449, 83459, 83471, 83477, 83497, 83537, 83557, 83561, 83563, 83579, 83591, 83597, 83609, 83617, 83621, 83639, 83641, 83653, 83663, 83689, 83701, 83717, 83719, 83737, 83761, 83773, 83777, 83791, 83813, 83833, 83843, 83857, 83869, 83873, 83891, 83903, 83911, 83921, 83933, 83939, 83969, 83983, 83987, 84011, 84017, 84047, 84053, 84059, 84061, 84067, 84089, 84121, 84127, 84131, 84137, 84143, 84163, 84179, 84181, 84191, 84199, 84211, 84221, 84223, 84229, 84239, 84247, 84263, 84299, 84307, 84313, 84317, 84319, 84347, 84349, 84377, 84389, 84391, 84401, 84407, 84421, 84431, 84437, 84443, 84449, 84457, 84463, 84467, 84481, 84499, 84503, 84509, 84521, 84523, 84533, 84551, 84559, 84589, 84629, 84631, 84649, 84653, 84659, 84673, 84691, 84697, 84701, 84713, 84719, 84731, 84737, 84751, 84761, 84787, 84793, 84809, 84811, 84827, 84857, 84859, 84869, 84871, 84913, 84919, 84947, 84961, 84967, 84977, 84979, 84991, 85009, 85021, 85027, 85037, 85049, 85061, 85081, 85087, 85091, 85093, 85103, 85109, 85121, 85133, 85147, 85159, 85193, 85199, 85201, 85213, 85223, 85229, 85237, 85243, 85247, 85259, 85297, 85303, 85313, 85331, 85333, 85361, 85363, 85369, 85381, 85411, 85427, 85429, 85439, 85447, 85451, 85453, 85469, 85487, 85513, 85517, 85523, 85531, 85549, 85571, 85577, 85597, 85601, 85607, 85619, 85621, 85627, 85639, 85643, 85661, 85667, 85669, 85691, 85703, 85711, 85717, 85733, 85751, 85781, 85793, 85817, 85819, 85829, 85831, 85837, 85843, 85847, 85853, 85889, 85903, 85909, 85931, 85933, 85991, 85999, 86011, 86017, 86027, 86029, 86069, 86077, 86083, 86111, 86113, 86117, 86131, 86137, 86143, 86161, 86171, 86179, 86183, 86197, 86201, 86209, 86239, 86243, 86249, 86257, 86263, 86269, 86287, 86291, 86293, 86297, 86311, 86323, 86341, 86351, 86353, 86357, 86369, 86371, 86381, 86389, 86399, 86413, 86423, 86441, 86453, 86461, 86467, 86477, 86491, 86501, 86509, 86531, 86533, 86539, 86561, 86573, 86579, 86587, 86599, 86627, 86629, 86677, 86689, 86693, 86711, 86719, 86729, 86743, 86753, 86767, 86771, 86783, 86813, 86837, 86843, 86851, 86857, 86861, 86869, 86923, 86927, 86929, 86939, 86951, 86959, 86969, 86981, 86993, 87011, 87013, 87037, 87041, 87049, 87071, 87083, 87103, 87107, 87119, 87121, 87133, 87149, 87151, 87179, 87181, 87187, 87211, 87221, 87223, 87251, 87253, 87257, 87277, 87281, 87293, 87299, 87313, 87317, 87323, 87337, 87359, 87383, 87403, 87407, 87421, 87427, 87433, 87443, 87473, 87481, 87491, 87509, 87511, 87517, 87523, 87539, 87541, 87547, 87553, 87557, 87559, 87583, 87587, 87589, 87613, 87623, 87629, 87631, 87641, 87643, 87649, 87671, 87679, 87683, 87691, 87697, 87701, 87719, 87721, 87739, 87743, 87751, 87767, 87793, 87797, 87803, 87811, 87833, 87853, 87869, 87877, 87881, 87887, 87911, 87917, 87931, 87943, 87959, 87961, 87973, 87977, 87991, 88001, 88003, 88007, 88019, 88037, 88069, 88079, 88093, 88117, 88129, 88169, 88177, 88211, 88223, 88237, 88241, 88259, 88261, 88289, 88301, 88321, 88327, 88337, 88339, 88379, 88397, 88411, 88423, 88427, 88463, 88469, 88471, 88493, 88499, 88513, 88523, 88547, 88589, 88591, 88607, 88609, 88643, 88651, 88657, 88661, 88663, 88667, 88681, 88721, 88729, 88741, 88747, 88771, 88789, 88793, 88799, 88801, 88807, 88811, 88813, 88817, 88819, 88843, 88853, 88861, 88867, 88873, 88883, 88897, 88903, 88919, 88937, 88951, 88969, 88993, 88997, 89003, 89009, 89017, 89021, 89041, 89051, 89057, 89069, 89071, 89083, 89087, 89101, 89107, 89113, 89119, 89123, 89137, 89153, 89189, 89203, 89209, 89213, 89227, 89231, 89237, 89261, 89269, 89273, 89293, 89303, 89317, 89329, 89363, 89371, 89381, 89387, 89393, 89399, 89413, 89417, 89431, 89443, 89449, 89459, 89477, 89491, 89501, 89513, 89519, 89521, 89527, 89533, 89561, 89563, 89567, 89591, 89597, 89599, 89603, 89611, 89627, 89633, 89653, 89657, 89659, 89669, 89671, 89681, 89689, 89753, 89759, 89767, 89779, 89783, 89797, 89809, 89819, 89821, 89833, 89839, 89849, 89867, 89891, 89897, 89899, 89909, 89917, 89923, 89939, 89959, 89963, 89977, 89983, 89989, 90001, 90007, 90011, 90017, 90019, 90023, 90031, 90053, 90059, 90067, 90071, 90073, 90089, 90107, 90121, 90127, 90149, 90163, 90173, 90187, 90191, 90197, 90199, 90203, 90217, 90227, 90239, 90247, 90263, 90271, 90281, 90289, 90313, 90353, 90359, 90371, 90373, 90379, 90397, 90401, 90403, 90407, 90437, 90439, 90469, 90473, 90481, 90499, 90511, 90523, 90527, 90529, 90533, 90547, 90583, 90599, 90617, 90619, 90631, 90641, 90647, 90659, 90677, 90679, 90697, 90703, 90709, 90731, 90749, 90787, 90793, 90803, 90821, 90823, 90833, 90841, 90847, 90863, 90887, 90901, 90907, 90911, 90917, 90931, 90947, 90971, 90977, 90989, 90997, 91009, 91019, 91033, 91079, 91081, 91097, 91099, 91121, 91127, 91129, 91139, 91141, 91151, 91153, 91159, 91163, 91183, 91193, 91199, 91229, 91237, 91243, 91249, 91253, 91283, 91291, 91297, 91303, 91309, 91331, 91367, 91369, 91373, 91381, 91387, 91393, 91397, 91411, 91423, 91433, 91453, 91457, 91459, 91463, 91493, 91499, 91513, 91529, 91541, 91571, 91573, 91577, 91583, 91591, 91621, 91631, 91639, 91673, 91691, 91703, 91711, 91733, 91753, 91757, 91771, 91781, 91801, 91807, 91811, 91813, 91823, 91837, 91841, 91867, 91873, 91909, 91921, 91939, 91943, 91951, 91957, 91961, 91967, 91969, 91997, 92003, 92009, 92033, 92041, 92051, 92077, 92083, 92107, 92111, 92119, 92143, 92153, 92173, 92177, 92179, 92189, 92203, 92219, 92221, 92227, 92233, 92237, 92243, 92251, 92269, 92297, 92311, 92317, 92333, 92347, 92353, 92357, 92363, 92369, 92377, 92381, 92383, 92387, 92399, 92401, 92413, 92419, 92431, 92459, 92461, 92467, 92479, 92489, 92503, 92507, 92551, 92557, 92567, 92569, 92581, 92593, 92623, 92627, 92639, 92641, 92647, 92657, 92669, 92671, 92681, 92683, 92693, 92699, 92707, 92717, 92723, 92737, 92753, 92761, 92767, 92779, 92789, 92791, 92801, 92809, 92821, 92831, 92849, 92857, 92861, 92863, 92867, 92893, 92899, 92921, 92927, 92941, 92951, 92957, 92959, 92987, 92993, 93001, 93047, 93053, 93059, 93077, 93083, 93089, 93097, 93103, 93113, 93131, 93133, 93139, 93151, 93169, 93179, 93187, 93199, 93229, 93239, 93241, 93251, 93253, 93257, 93263, 93281, 93283, 93287, 93307, 93319, 93323, 93329, 93337, 93371, 93377, 93383, 93407, 93419, 93427, 93463, 93479, 93481, 93487, 93491, 93493, 93497, 93503, 93523, 93529, 93553, 93557, 93559, 93563, 93581, 93601, 93607, 93629, 93637, 93683, 93701, 93703, 93719, 93739, 93761, 93763, 93787, 93809, 93811, 93827, 93851, 93871, 93887, 93889, 93893, 93901, 93911, 93913, 93923, 93937, 93941, 93949, 93967, 93971, 93979, 93983, 93997, 94007, 94009, 94033, 94049, 94057, 94063, 94079, 94099, 94109, 94111, 94117, 94121, 94151, 94153, 94169, 94201, 94207, 94219, 94229, 94253, 94261, 94273, 94291, 94307, 94309, 94321, 94327, 94331, 94343, 94349, 94351, 94379, 94397, 94399, 94421, 94427, 94433, 94439, 94441, 94447, 94463, 94477, 94483, 94513, 94529, 94531, 94541, 94543, 94547, 94559, 94561, 94573, 94583, 94597, 94603, 94613, 94621, 94649, 94651, 94687, 94693, 94709, 94723, 94727, 94747, 94771, 94777, 94781, 94789, 94793, 94811, 94819, 94823, 94837, 94841, 94847, 94849, 94873, 94889, 94903, 94907, 94933, 94949, 94951, 94961, 94993, 94999, 95003, 95009, 95021, 95027, 95063, 95071, 95083, 95087, 95089, 95093, 95101, 95107, 95111, 95131, 95143, 95153, 95177, 95189, 95191, 95203, 95213, 95219, 95231, 95233, 95239, 95257, 95261, 95267, 95273, 95279, 95287, 95311, 95317, 95327, 95339, 95369, 95383, 95393, 95401, 95413, 95419, 95429, 95441, 95443, 95461, 95467, 95471, 95479, 95483, 95507, 95527, 95531, 95539, 95549, 95561, 95569, 95581, 95597, 95603, 95617, 95621, 95629, 95633, 95651, 95701, 95707, 95713, 95717, 95723, 95731, 95737, 95747, 95773, 95783, 95789, 95791, 95801, 95803, 95813, 95819, 95857, 95869, 95873, 95881, 95891, 95911, 95917, 95923, 95929, 95947, 95957, 95959, 95971, 95987, 95989, 96001, 96013, 96017, 96043, 96053, 96059, 96079, 96097, 96137, 96149, 96157, 96167, 96179, 96181, 96199, 96211, 96221, 96223, 96233, 96259, 96263, 96269, 96281, 96289, 96293, 96323, 96329, 96331, 96337, 96353, 96377, 96401, 96419, 96431, 96443, 96451, 96457, 96461, 96469, 96479, 96487, 96493, 96497, 96517, 96527, 96553, 96557, 96581, 96587, 96589, 96601, 96643, 96661, 96667, 96671, 96697, 96703, 96731, 96737, 96739, 96749, 96757, 96763, 96769, 96779, 96787, 96797, 96799, 96821, 96823, 96827, 96847, 96851, 96857, 96893, 96907, 96911, 96931, 96953, 96959, 96973, 96979, 96989, 96997, 97001, 97003, 97007, 97021, 97039, 97073, 97081, 97103, 97117, 97127, 97151, 97157, 97159, 97169, 97171, 97177, 97187, 97213, 97231, 97241, 97259, 97283, 97301, 97303, 97327, 97367, 97369, 97373, 97379, 97381, 97387, 97397, 97423, 97429, 97441, 97453, 97459, 97463, 97499, 97501, 97511, 97523, 97547, 97549, 97553, 97561, 97571, 97577, 97579, 97583, 97607, 97609, 97613, 97649, 97651, 97673, 97687, 97711, 97729, 97771, 97777, 97787, 97789, 97813, 97829, 97841, 97843, 97847, 97849, 97859, 97861, 97871, 97879, 97883, 97919, 97927, 97931, 97943, 97961, 97967, 97973, 97987, 98009, 98011, 98017, 98041, 98047, 98057, 98081, 98101, 98123, 98129, 98143, 98179, 98207, 98213, 98221, 98227, 98251, 98257, 98269, 98297, 98299, 98317, 98321, 98323, 98327, 98347, 98369, 98377, 98387, 98389, 98407, 98411, 98419, 98429, 98443, 98453, 98459, 98467, 98473, 98479, 98491, 98507, 98519, 98533, 98543, 98561, 98563, 98573, 98597, 98621, 98627, 98639, 98641, 98663, 98669, 98689, 98711, 98713, 98717, 98729, 98731, 98737, 98773, 98779, 98801, 98807, 98809, 98837, 98849, 98867, 98869, 98873, 98887, 98893, 98897, 98899, 98909, 98911, 98927, 98929, 98939, 98947, 98953, 98963, 98981, 98993, 98999, 99013, 99017, 99023, 99041, 99053, 99079, 99083, 99089, 99103, 99109, 99119, 99131, 99133, 99137, 99139, 99149, 99173, 99181, 99191, 99223, 99233, 99241, 99251, 99257, 99259, 99277, 99289, 99317, 99347, 99349, 99367, 99371, 99377, 99391, 99397, 99401, 99409, 99431, 99439, 99469, 99487, 99497, 99523, 99527, 99529, 99551, 99559, 99563, 99571, 99577, 99581, 99607, 99611, 99623, 99643, 99661, 99667, 99679, 99689, 99707, 99709, 99713, 99719, 99721, 99733, 99761, 99767, 99787, 99793, 99809, 99817, 99823, 99829, 99833, 99839, 99859, 99871, 99877, 99881, 99901, 99907, 99923, 99929, 99961, 99971, 99989, 99991, 100003, 100019, 100043, 100049, 100057, 100069, 100103, 100109, 100129, 100151, 100153, 100169, 100183, 100189, 100193, 100207, 100213, 100237, 100267, 100271, 100279, 100291, 100297, 100313, 100333, 100343, 100357, 100361, 100363, 100379, 100391, 100393, 100403, 100411, 100417, 100447, 100459, 100469, 100483, 100493, 100501, 100511, 100517, 100519, 100523, 100537, 100547, 100549, 100559, 100591, 100609, 100613, 100621, 100649, 100669, 100673, 100693, 100699, 100703, 100733, 100741, 100747, 100769, 100787, 100799, 100801, 100811, 100823, 100829, 100847, 100853, 100907, 100913, 100927, 100931, 100937, 100943, 100957, 100981, 100987, 100999, 101009, 101021, 101027, 101051, 101063, 101081, 101089, 101107, 101111, 101113, 101117, 101119, 101141, 101149, 101159, 101161, 101173, 101183, 101197, 101203, 101207, 101209, 101221, 101267, 101273, 101279, 101281, 101287, 101293, 101323, 101333, 101341, 101347, 101359, 101363, 101377, 101383, 101399, 101411, 101419, 101429, 101449, 101467, 101477, 101483, 101489, 101501, 101503, 101513, 101527, 101531, 101533, 101537, 101561, 101573, 101581, 101599, 101603, 101611, 101627, 101641, 101653, 101663, 101681, 101693, 101701, 101719, 101723, 101737, 101741, 101747, 101749, 101771, 101789, 101797, 101807, 101833, 101837, 101839, 101863, 101869, 101873, 101879, 101891, 101917, 101921, 101929, 101939, 101957, 101963, 101977, 101987, 101999, 102001, 102013, 102019, 102023, 102031, 102043, 102059, 102061, 102071, 102077, 102079, 102101, 102103, 102107, 102121, 102139, 102149, 102161, 102181, 102191, 102197, 102199, 102203, 102217, 102229, 102233, 102241, 102251, 102253, 102259, 102293, 102299, 102301, 102317, 102329, 102337, 102359, 102367, 102397, 102407, 102409, 102433, 102437, 102451, 102461, 102481, 102497, 102499, 102503, 102523, 102533, 102539, 102547, 102551, 102559, 102563, 102587, 102593, 102607, 102611, 102643, 102647, 102653, 102667, 102673, 102677, 102679, 102701, 102761, 102763, 102769, 102793, 102797, 102811, 102829, 102841, 102859, 102871, 102877, 102881, 102911, 102913, 102929, 102931, 102953, 102967, 102983, 103001, 103007, 103043, 103049, 103067, 103069, 103079, 103087, 103091, 103093, 103099, 103123, 103141, 103171, 103177, 103183, 103217, 103231, 103237, 103289, 103291, 103307, 103319, 103333, 103349, 103357, 103387, 103391, 103393, 103399, 103409, 103421, 103423, 103451, 103457, 103471, 103483, 103511, 103529, 103549, 103553, 103561, 103567, 103573, 103577, 103583, 103591, 103613, 103619, 103643, 103651, 103657, 103669, 103681, 103687, 103699, 103703, 103723, 103769, 103787, 103801, 103811, 103813, 103837, 103841, 103843, 103867, 103889, 103903, 103913, 103919, 103951, 103963, 103967, 103969, 103979, 103981, 103991, 103993, 103997, 104003, 104009, 104021, 104033, 104047, 104053, 104059, 104087, 104089, 104107, 104113, 104119, 104123, 104147, 104149, 104161, 104173, 104179, 104183, 104207, 104231, 104233, 104239, 104243, 104281, 104287, 104297, 104309, 104311, 104323, 104327, 104347, 104369, 104381, 104383, 104393, 104399, 104417, 104459, 104471, 104473, 104479, 104491, 104513, 104527, 104537, 104543, 104549, 104551, 104561, 104579, 104593, 104597, 104623, 104639, 104651, 104659, 104677, 104681, 104683, 104693, 104701, 104707, 104711, 104717, 104723, 104729, }; #endif stk/src/Makefile0000664000175000017500000000125212617165721012534 0ustar bectbectall: \ __stk_dist_pairwise__.mex \ __get_column_number__.mex \ __stk_dist_matrixy__.mex \ __stk_filldist_discr_mex__.mex \ __stk_gpquadform_matrixy__.mex \ __stk_isdominated_mex__.mex \ __stk_mindist_mex__.mex \ __stk_dist_matrixx__.mex \ __stk_dist_pairwise__.mex \ __stk_gpquadform_matrixx__.mex \ __stk_gpquadform_pairwise__.mex \ __stk_paretofind_mex__.mex \ __stk_sampling_vdc_rr2__.mex \ __stk_distrib_bivnorm0_cdf__.mex __stk_sampling_vdc_rr2__.mex: primes.h __stk_paretofind_mex__.mex: pareto.h __stk_isdominated_mex__.mex: pareto.h MKOCTFILE ?= mkoctfile __%__.mex: %.c stk_mex.h $(MKOCTFILE) --mex --output $@ $< .PHONY: clean clean: rm -f *.o *.mex stk/src/stk_filldist_discr_mex.c0000664000175000017500000001142112617165717015774 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2012 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" #define X_IN prhs[0] /* input argument #1 */ #define Y_IN prhs[1] /* input argument #2 */ #define FILLDIST_OUT plhs[0] /* output argument #1 */ #define ARGMAX_OUT plhs[1] /* output argument #2 */ static double compute_filldist ( double* x, size_t nx, double* y, size_t ny, size_t dim, size_t* argmax ) { size_t i, j, k1, k2, j_max; double diff, sqdist_max, sqdist_j, sqdist_ij; j_max = 0; sqdist_max = 0.0; for (j = 0; j < ny; j++) { sqdist_j = 0; /* prevents a "may be uninitialized" warning */ /* Compute the sqdist from y(j, :) to the set x */ for (i = 0; i < nx; i++) { /* Compute the sqdist from y(j, :) to x(i, :) */ sqdist_ij = 0.0; for (k1 = i, k2 = j; k1 < dim * nx; k1 += nx, k2 += ny) { diff = x[k1] - y[k2]; sqdist_ij += diff * diff; } /* Update sqdist_j */ if ((i == 0) || (sqdist_ij < sqdist_j)) sqdist_j = sqdist_ij; } /* Update sqdist_max */ if (sqdist_j > sqdist_max) { j_max = j; sqdist_max = sqdist_j; } } *argmax = j_max; return sqrt(sqdist_max); } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { size_t mx, my, dim, argmax; double filldist, *px, *py; if (nlhs > 2) mexErrMsgTxt("Too many output arguments."); if (nrhs != 2) mexErrMsgTxt("Incorrect number of input arguments (should be 2)."); if (mxIsComplex(X_IN) || mxIsComplex(Y_IN)) mexErrMsgTxt("The input arguments cannot be complex."); if ((!mxIsDouble(X_IN)) || (!mxIsDouble(Y_IN))) mexErrMsgTxt("The input argument must be of class 'double'."); /* Read the size of the input arguments */ mx = mxGetM(X_IN); my = mxGetM(Y_IN); dim = mxGetN(X_IN); if ((mx == 0) || (my == 0) || (dim == 0)) mexErrMsgTxt("The input arguments should not be empty."); if (mxGetN(Y_IN) != dim) mexErrMsgTxt("The input arguments must have the same number of columns."); /* Do the actual computations in a subroutine */ px = mxGetPr(X_IN); py = mxGetPr(Y_IN); filldist = compute_filldist(px, mx, py, my, dim, &argmax); /* Return the results as Matlab objects */ FILLDIST_OUT = mxCreateDoubleScalar(filldist); if (nlhs == 2) ARGMAX_OUT = mxCreateDoubleScalar(((double)argmax) + 1); } stk/src/stk_dist_pairwise.c0000664000175000017500000001010112617165717014765 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2012 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" static void distance3(double* x, double* y, double* h, size_t n, size_t dim) { size_t i, k; double diff, lambda; for (i = 0; i < n; i++) { /* compute distance between x[i,:] and y[j,:] */ lambda = 0.0; for (k = i; k < dim * n; k += n) { diff = x[k] - y[k]; lambda += diff * diff; } /* store the result in h */ h[i] = sqrt(lambda); } } mxArray* compute_distance_xy_pairwise(const mxArray* x, const mxArray* y) { size_t d, n; mxArray* h; if((!stk_is_realmatrix(x)) || (!stk_is_realmatrix(y))) mexErrMsgTxt("Input arguments should be real-valued double-precision array."); /* Check that the input arguments have the same number of columns */ if (mxGetN(y) != (d = mxGetN(x))) mexErrMsgTxt("Both input arguments should have the same number of columns."); /* Check that the input arguments have the same number of rows */ if (mxGetM(y) != (n = mxGetM(x))) mexErrMsgTxt("Both input arguments should have the same number of rows."); /* Create a matrix for the return argument */ h = mxCreateDoubleMatrix(n, 1, mxREAL); /* Do the actual computations in a subroutine */ distance3(mxGetPr(x), mxGetPr(y), mxGetPr(h), n, d); return h; } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { if (nlhs > 1) /* Check number of output arguments */ mexErrMsgTxt("Too many output arguments."); if (nrhs != 2) /* Check number of input arguments */ mexErrMsgTxt("Incorrect number of input arguments."); plhs[0] = compute_distance_xy_pairwise(prhs[0], prhs[1]); } stk/src/stk_mindist_mex.c0000664000175000017500000001022712617165720014442 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2012 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" #define X_IN prhs[0] /* input argument */ #define H_OUT plhs[0] /* output argument */ static double compute_mindist(double* x, size_t nx, size_t dim) { size_t i, j, k1, k2; double diff, dist_squared, mindist_squared; mindist_squared = -1; for (i = 0; i < nx; i++) { for (j = i+1; j < nx; j++) { /* compute distance between x[i,:] and x[j,:] */ dist_squared = 0.0; for (k1 = i, k2 = j; k1 < dim * nx; k1 += nx, k2 += nx) { diff = x[k1] - x[k2]; dist_squared += diff * diff; } /* update mindist_squared */ if ((dist_squared < mindist_squared) || (mindist_squared < 0)) mindist_squared = dist_squared; } } return sqrt(mindist_squared); } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { size_t dim, mx; if (nlhs > 1) mexErrMsgTxt("Too many output arguments."); if (nrhs != 1) mexErrMsgTxt("Incorrect number of input arguments (should be 1)."); if (mxIsComplex(X_IN)) mexErrMsgTxt("The input argument cannot be complex."); if (!mxIsDouble(X_IN)) mexErrMsgTxt("The input argument must be of class 'double'."); /* Read the size of the input argument */ mx = mxGetM(X_IN); dim = mxGetN(X_IN); if (mx < 2) { /* return an empty matrix if the input has less than two lines */ H_OUT = mxCreateDoubleMatrix(0, 0, mxREAL); } else { if (dim == 0) { /* return zero distance if the matrix has no columns */ H_OUT = mxCreateDoubleScalar(0.0); } else { /* otherwise, do the actual computations in a subroutine */ H_OUT = mxCreateDoubleScalar(compute_mindist(mxGetPr(X_IN), mx, dim)); } } } stk/src/stk_gpquadform_matrixx.c0000664000175000017500000001066412617165717016056 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2013 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" static void gpquadform_matrixx ( double* x, double* rx2, double* h, size_t n, size_t dim ) { size_t i, j, k1, k2; double diff, lambda; for (i = 0; i < (n - 1); i++) { /* put a zero on the diagonal */ h[i * (n + 1)] = 0.0; for (j = (i + 1); j < n; j++) { /* compute distance between x[i,:] and x[j,:] */ lambda = 0.0; for (k1 = i, k2 = j; k1 < dim * n; k1 += n, k2 += n) { diff = x[k1] - x[k2]; lambda += (diff * diff) / (rx2[k1] + rx2[k2]); } /* store the result in h */ h[i + n * j] = lambda; h[j + n * i] = lambda; } } } mxArray* compute_gpquadform_matrixx ( const mxArray* x, const mxArray* rx ) { size_t k, d, mx; double u, *p, *rx2; mxArray *h; if((!stk_is_realmatrix(x)) || (!stk_is_realmatrix(rx))) mexErrMsgTxt("Input arguments should be real-valued double-precision array."); d = mxGetN(x); mx = mxGetM(x); /* Check that the all input arguments have the same number of columns */ if ((mxGetM(rx) != mx) || (mxGetN(rx) != d)) mexErrMsgTxt("x and rx should have the same size."); /* Compute rx^2 */ rx2 = mxCalloc(mx * d, sizeof(double)); p = mxGetPr(rx); for(k = 0; k < mx * d; k++) { u = p[k]; if(u <= 0) mexErrMsgTxt("rx should have (strictly) positive entries."); rx2[k] = u * u; } /* Create a matrix for the return argument */ h = mxCreateDoubleMatrix(mx, mx, mxREAL); /* Do the actual computations in a subroutine */ gpquadform_matrixx(mxGetPr(x), rx2, mxGetPr(h), mx, d); /* Free allocated memory */ mxFree(rx2); return h; } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { if (nlhs > 1) /* Check number of output arguments */ mexErrMsgTxt("Too many output arguments."); if (nrhs != 2) /* Check number of input arguments */ mexErrMsgTxt("Incorrect number of input arguments."); plhs[0] = compute_gpquadform_matrixx(prhs[0], prhs[1]); } stk/src/stk_sampling_vdc_rr2.c0000664000175000017500000003363412617165721015365 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2013 Alexandra Krauth, Elham Rahali & SUPELEC * * * * Authors: Julien Bect * * Alexandra Krauth * * Elham Rahali * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include #include #include #include "stk_mex.h" #include "primes.h" /***************************************************************************** * * * Subfunctions * * * ****************************************************************************/ int vanDerCorput_RR2(unsigned int b, unsigned int n, double *h); int compute_nb_digits(unsigned int n, unsigned int b); double radical_inverse(int *digits, unsigned int nb_digits, unsigned int b); int next_Mersenne_number(unsigned int b); int construct_permutRR(unsigned int b, int* permut); int construct_permutRR_Mersenne(unsigned int b, int* permut); /***************************************************************************** * * * MEX entry point (mexFunction) * * * * STK_SAMPLING_VDC_RR2 computes the first N terms of the J^th * * RR2-scrambled van der Corput sequence * * * * CALL: X = stk_sampling_vdc_rr2(N, J) * * * * Reference: Ladislav Kocis and William J. Whiten (1997) * * Computational investigations of lowdiscrepancy sequences. * * ACM Transactions on Mathematical Software, 23(2):266-294. * * * ****************************************************************************/ #define N_IN prhs[0] #define J_IN prhs[1] #define X_OUT plhs[0] void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int n_, j_, r; unsigned int n, j; double *h; mxArray* xdata; n_ = 0; j_ = 0; /*--- Read input arguments -----------------------------------------------*/ if(nrhs != 2) mexErrMsgIdAndTxt("STK:stk_sampling_vdc_rr2:nrhs", "Two inputs required."); if ((mxReadScalar_int(N_IN, &n_) != 0) || (n_ <= 0)) mexErrMsgIdAndTxt("STK:stk_sampling_vdc_rr2:IncorrectArgument", "First argument (n) must be a strictly positive " "scalar integer."); n = (unsigned int) n_; if ((mxReadScalar_int(J_IN, &j_) != 0) || (j_ <= 0)) mexErrMsgIdAndTxt("STK:stk_sampling_vdc_rr2:IncorrectArgument", "Second argument (j) must be a scrictly positive " "scalar integer."); j = (unsigned int) j_; if (j > PRIMES_TABLE_SIZE) mexErrMsgIdAndTxt("STK:stk_sampling_vdc_rr2:IncorrectArgument", "Second argument (d) must be smaller than %d.", PRIMES_TABLE_SIZE); /*--- Do the actual computations in a subroutine -------------------------*/ xdata = mxCreateDoubleMatrix(n, 1, mxREAL); h = mxGetPr(xdata); if ((r = vanDerCorput_RR2(primes_table[j - 1], n, h)) != STK_OK) mexErrMsgIdAndTxt("STK:stk_sampling_vdc_rr2:Sanity", "vanDerCorput_RR2() failed with error code %d.", r); /*--- Create output dataframe --------------------------------------------*/ if ((r = mexCallMATLAB(1, &X_OUT, 1, &xdata, "stk_dataframe")) != 0) mexErrMsgIdAndTxt("STK:stk_sampling_vdc_rr2:Sanity", "mexCallMATLAB() failed with error code %d.", r); } /***************************************************************************** * * * void vanDerCorput_RR2(unsigned int b, unsigned int N, double *result) * * * * Compute N terms of the RR2-scrambled van der Corput sequence in base b. * * * ****************************************************************************/ int vanDerCorput_RR2 (unsigned int b, unsigned int N, double *result) { int i, j, c, nb_digits_max, nb_digits, quotient; int *permut, *digits, *s_digits; /*--- Check input arguments ----------------------------------------------*/ if (N == 0) return STK_OK; /* we successfully did... nothing... */ if (b == 0) /* 0 is not a prime */ return STK_ERROR_DOMAIN; /*--- Allocate temporary arrays ------------------------------------------*/ /* Create arrays to store base-b representations (note: N is the biggest integer that we'll have to represent) */ if ((nb_digits_max = compute_nb_digits(N, b)) == -1) return STK_ERROR_SANITY; if ((digits = (int*) mxCalloc(nb_digits_max, sizeof(int))) == NULL) return STK_ERROR_OOM; if ((s_digits = (int*) mxCalloc(nb_digits_max, sizeof(int))) == NULL) return STK_ERROR_OOM; /* Create the permutation array */ if ((permut = (int*) mxCalloc(b, sizeof(int))) == NULL) return STK_ERROR_OOM; construct_permutRR(b, permut); /*--- Compute N terms in the base-b of the sequence ----------------------*/ nb_digits = 1; /* number of digits required to represent 1 in base b */ c = b; /* number of iterations before we increment nb_digits */ /* note: the first term is always zero, that's why we start at i = 1 */ for (i = 1; i < N; i++) { if ((--c) == 0) /* we need to increase the number of digits */ { nb_digits++; c = i * (b - 1); } /* Compute the representation of i in base b (no need to fill with zeros at the end) */ quotient = i; j = 0; while (quotient > 0) { digits[j] = quotient % b; quotient = quotient / b; j++; } /* Scramble the digits */ for(j = 0; j < nb_digits; j++) s_digits[j] = permut[digits[j]]; /* Compute the i^th term using the radical inverse function */ result[i] = radical_inverse(s_digits, nb_digits, b); } /*--- Free temporary arrays ----------------------------------------------*/ mxFree(digits); mxFree(s_digits); mxFree(permut); return STK_OK; } /***************************************************************************** * * * void construct_permutRR(unsigned int b, int* pi_b) * * * * Compute N terms of the RR2-scrambled van der Corput sequence in base b. * * * ****************************************************************************/ int construct_permutRR (unsigned int b, int* pi_b) { int i, j, b_max, *pi_b_max; /* Find the smallest number of the form 2^k - 1 (Mersenne number) that is greater than or equal to b. This number is not necessarily prime. */ b_max = next_Mersenne_number(b); /* Create an auxiliary permutation of {0, 1, ..., b_max - 1} */ if ((pi_b_max = mxCalloc(b_max, sizeof(int))) == NULL) return STK_ERROR_OOM; construct_permutRR_Mersenne(b_max, pi_b_max); /* Trim pi_b_max to get pi_b (note: the first element is always 0) */ j = 1; for (i = 1; i < b; i++) { while (pi_b_max[j] > (b - 1)) j++; pi_b[i] = pi_b_max[j++]; } mxFree(pi_b_max); return STK_OK; } /***************************************************************************** * * * int construct_permutRR_Mersenne(unsigned int b, int *permut) * * * * Construct the "reverse radix" permutation in the case where b is a * * Mersenne number. * * * * Note: careful, we do not actually check that b is a Mersenne number * * * ****************************************************************************/ int construct_permutRR_Mersenne (unsigned int b, int *permut) { int i, j, direct, reversed, digits; if ((digits = compute_nb_digits(b - 1, 2)) == -1) return STK_ERROR_SANITY; permut[0] = 0; for (i = 1; i < b; i++) { direct = i; reversed = 0; for(j = 0; j < digits; j++) { reversed <<= 1; reversed += (direct & 01); direct >>= 1; } permut[i] = reversed; } return STK_OK; } /***************************************************************************** * * * int compute_nb_digits(unsigned int n, unsigned int b) * * * * Compute the number of digits required to represent n in base b. * * * ****************************************************************************/ int compute_nb_digits (unsigned int n, unsigned int b) { int nb_digits, quotient; if ((b <= 0) || (n <= 0)) return -1; nb_digits = 0; quotient = n; while (quotient > 0) { nb_digits++; quotient = quotient / b; } return nb_digits; } /***************************************************************************** * * * double radical_inverse * * (int *digits, unsigned int nb_digits, unsigned int b) * * * * Apply the base-b radical inverse transform to a number given through its * * base-b representation * * * ****************************************************************************/ double radical_inverse (int *digits, unsigned int nb_digits, unsigned int b) { int i, b_pow_inv; double sum; b_pow_inv = 1; sum = 0; for (i = 0; i < nb_digits; i++) { b_pow_inv *= b; sum += ((double) digits[i]) / ((double)b_pow_inv); } return sum; } /***************************************************************************** * * * int next_Mersenne_number(unsigned int b) * * * * Compute the first integer bigger than b that is of the form * * * * 2^k - 1, with k an integer * * * ****************************************************************************/ int next_Mersenne_number (unsigned int b) { int m = 0; while (m < b) { m <<= 1; m += 1; } return m; } stk/src/get_column_number.c0000664000175000017500000001620612617165715014754 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2013 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "string.h" #include "stk_mex.h" #define ICOL_INFO -5 /* will be a -4 in the end */ #define ICOL_ROWNAMES -4 /* will be a -3 in the end */ #define ICOL_COLNAMES -3 /* will be a -2 in the end */ #define ICOL_ENTIRE_DATAFRAME -2 /* will be a -1 in the end */ int get_column_number(const mxArray* mxColNames, char* s) { size_t ncol, cmax, c; char** colnames; mxArray* tmp; int icol, found; if (strcmp (s, "info") == 0) return ICOL_INFO; if (strcmp (s, "rownames") == 0) return ICOL_ROWNAMES; if (strcmp (s, "colnames") == 0) return ICOL_COLNAMES; ncol = mxGetNumberOfElements(mxColNames); if (ncol == 0) { if (strcmp(s, "a") == 0 || strcmp(s, "data") == 0) /* LEGACY: .a */ return ICOL_ENTIRE_DATAFRAME; mexErrMsgTxt("The dataframe has no column names."); } icol = -1; /* Read colum names and compare with s. We stop when the first match is found, assuming that we are dealing with a well-formed dataframe without duplicated column names. */ colnames = (char**) mxCalloc(ncol, sizeof(char*)); for (c = 0; c < ncol; c++) { tmp = mxGetCell(mxColNames, c); if (tmp == NULL) mexErrMsgTxt("Error while reading column names (mxGetCell)."); colnames[c] = mxArrayToString(tmp); if (colnames[c] == NULL) mexErrMsgTxt("Error while reading column names (mxArrayToString)."); if (strcmp(colnames[c], s) == 0) { icol = (int) c; break; } } /* Maximum c such that colnames[c] must be freed */ found = (icol != -1); cmax = ((found) ? (c) : (ncol - 1)); /* Deal with special cases, in particular LEGACY cases, if no exact match has been found */ if (!found) { if (strcmp(s, "data") == 0) { icol = ICOL_ENTIRE_DATAFRAME; } else if (strcmp(s, "a") == 0) { for (c = 0; c < ncol; c++) if (strcmp(colnames[c], "mean") == 0) { icol = (int) c; break; } if (icol == -1) { icol = ICOL_ENTIRE_DATAFRAME; mexWarnMsgIdAndTxt("STK:subsref_dot:Legacy", "There is no variable named 'a'.\n" " => Assuming that you're an old STK user" " trying to get the entire dataframe."); } else { mexWarnMsgIdAndTxt("STK:subsref_dot:Legacy", "There is no variable named 'a'.\n" " => Assuming that you're an old STK user" " trying to get the kriging mean."); } } else if (strcmp(s, "v") == 0) { for (c = 0; c < ncol; c++) if (strcmp(colnames[c], "var") == 0) { icol = (int) c; break; } if (icol != -1) mexWarnMsgIdAndTxt("STK:subsref_dot:Legacy", "There is no variable named 'v'.\n" " => Assuming that you're an old STK user" " trying to get the kriging variance."); } } /* ERROR if no corresponding column can be found */ if (icol == -1) mexErrMsgIdAndTxt("STK:subsref_dot:UnknownVariable", "There is no variable named %s.", s); /* Free memory used for column names. */ for (c = 0; c <= cmax; c++) mxFree(colnames[c]); mxFree(colnames); return icol; } #define COLNAMES_IN prhs[0] #define PROPNAME_IN prhs[1] #define ICOL_OUT plhs[0] void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { char *s; int icol; /*--- Check number of input/output arguments --------------------------------*/ if (nrhs != 2) mexErrMsgTxt("Incorrect number of input arguments (should be 2)."); if (nlhs > 1) mexErrMsgTxt("Incorrect number of output arguments (should be 1)."); /*--- Read property name ----------------------------------------------------*/ if (!mxIsChar(PROPNAME_IN)) mexErrMsgTxt("PropertyName argument should be of class 'char'."); s = mxArrayToString(PROPNAME_IN); if(s == NULL) mexErrMsgTxt("mxArrayToString failed to process PropertyName argument."); /*--- Which column are we trying to set ? -----------------------------------*/ icol = get_column_number(COLNAMES_IN, s); ICOL_OUT = mxCreateDoubleScalar (icol + 1); mxFree(s); } stk/src/stk_gpquadform_pairwise.c0000664000175000017500000001114112617165720016166 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2013 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" static void gpquadform_pairwise ( double* x, double* y, double* rx, double* ry, double* h, size_t m, size_t dim ) { size_t i, kx, ky; double diff, lambda, rxi, ryi; for (i = 0; i < m; i++) { /* compute distance between x[i,:] and y[i,:] */ lambda = 0.0; for (kx = i, ky = i; kx < dim * m; kx += m, ky += m) { diff = x[kx] - y[ky]; rxi = rx[kx]; ryi = ry[ky]; lambda += (diff * diff) / (rxi * rxi + ryi * ryi); } /* store the result in h */ h[i] = lambda; } } mxArray* compute_qxy_matrixy ( const mxArray* x, const mxArray* y, const mxArray* rx, const mxArray* ry ) { size_t d, m; mxArray *h; if((!stk_is_realmatrix(x)) || (!stk_is_realmatrix(y)) || (!stk_is_realmatrix(rx)) || (!stk_is_realmatrix(ry))) mexErrMsgTxt("Input arguments should be real-valued double-precision array."); /* Check that the all input arguments have the same number of columns */ d = mxGetN(x); if ((mxGetN(y) != d) || (mxGetN(rx) != d) || (mxGetN(ry) != d)) mexErrMsgTxt("All input arguments should have the same number of columns."); /* Read the number of rows of x and y */ if (mxGetM(y) != (m = mxGetM(x))) mexErrMsgTxt("x and y should have the same number of rows."); /* Check that rx and ry have the appropriate number of rows */ if (mxGetM(rx) != m) mexErrMsgTxt("x and rx should have the same number of rows."); if (mxGetM(ry) != m) mexErrMsgTxt("y and ry should have the same number of rows."); /* Create a matrix for the return argument */ h = mxCreateDoubleMatrix(m, 1, mxREAL); /* Do the actual computations in a subroutine */ gpquadform_pairwise(mxGetPr(x), mxGetPr(y), mxGetPr(rx), mxGetPr(ry), mxGetPr(h), m, d); return h; } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { if (nlhs > 1) /* Check number of output arguments */ mexErrMsgTxt("Too many output arguments."); if (nrhs != 4) /* Check number of input arguments */ mexErrMsgTxt("Incorrect number of input arguments."); plhs[0] = compute_qxy_matrixy(prhs[0], prhs[1], prhs[2], prhs[3]); } stk/src/stk_dist_matrixx.c0000664000175000017500000000770712617165717014660 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2011, 2012 SUPELEC * * * * Authors: Julien Bect * * Emmanuel Vazquez * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" static void distance1(double* x, double* h, size_t nx, size_t dim) { size_t i, j, k1, k2; double diff, lambda; for (i = 0; i < nx; i++) { /* put a zero on the diagonal */ h[i*(nx+1)] = 0.0; for (j = i+1; j < nx; j++) { /* compute distance between x[i,:] and x[j,:] */ lambda = 0.0; for (k1 = i, k2 = j; k1 < dim * nx; k1 += nx, k2 += nx) { diff = x[k1] - x[k2]; lambda += diff * diff; } /* store the result in h, twice for symmetry */ h[i+nx*j] = sqrt(lambda); h[j+nx*i] = h[i+nx*j]; } } } mxArray* compute_distance_xx(const mxArray* x) { size_t d, n; mxArray* h; if(!stk_is_realmatrix(x)) mexErrMsgTxt("The input should be a real-valued double-precision array."); /* Read the size of the input argument */ n = mxGetM(x); d = mxGetN(x); /* Create a matrix for the return argument */ h = mxCreateDoubleMatrix(n, n, mxREAL); /* Do the actual computations in a subroutine */ distance1(mxGetPr(x), mxGetPr(h), n, d); return h; } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { if (nlhs > 1) /* Check number of output arguments */ mexErrMsgTxt("Too many output arguments."); if (nrhs != 1) /* Check number of input arguments */ mexErrMsgTxt("Incorrect number of input arguments."); plhs[0] = compute_distance_xx(prhs[0]); } stk/src/pareto.h0000664000175000017500000002133212617165720012537 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2014 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #ifndef ___LEXICAL_SORT_H___ #define ___LEXICAL_SORT_H___ /* assumes that types SCALAR and LOGICAL are defined */ struct T { int pos; int stride; int dim; const SCALAR *data; }; /*--------------------------------------------------------------*/ void lexical_sort (SCALAR *x, int *idx, int n, int d); int pareto_find (SCALAR *x, int *idx1, int* idx2, int n, int d); void is_dominated (const SCALAR *xa, const SCALAR *xb, LOGICAL *isdom, int *drank, int n, int k, int d); int __lexical_cmp__ (const void *_x, const void *_y); int __is_dominated__ (const struct T *x, const struct T *y); void __init_tab__ (const SCALAR *x, struct T *tab, int n, int d); /*--------------------------------------------------------------*/ int __lexical_cmp__ (const void *_x, const void *_y) { int j, n, d; const SCALAR *px, *py; const struct T *x, *y; /* Cast to const struct T* */ x = (const struct T*) _x; y = (const struct T*) _y; /* Pointers to the actual data */ px = x->data; py = y->data; /* We ASSUME that x and y have the same dim and stride */ d = x->dim; n = x->stride; for (j = 0; j < d; j ++, px += n, py += n) { if ((*px) < (*py)) return -1; /* x < y */ else if ((*px) > (*py)) return +1; /* y > x */ } return 0; /* x == y */ } /*--------------------------------------------------------------*/ /* Is x dominated by y ? */ /* note: SMALLER is better */ int __is_dominated__ (const struct T *x, const struct T *y) { int j, nx, ny, d, any_xgty; const SCALAR *px, *py; /* Pointers to the actual data */ px = x->data; py = y->data; d = x->dim; nx = x->stride; ny = y->stride; any_xgty = 0; /* flag: 1 if we have seen at least one component in y that is strictly better (smaller) */ for (j = 0; j < d; j ++, px += nx, py += ny) { if ((*px) < (*py)) return 0; /* y does not dominate x */ else if ((*px) > (*py)) any_xgty = 1; } return any_xgty; } /*--------------------------------------------------------------*/ /* TODO: templated versions, to handle integer types, single, etc. */ void lexical_sort (SCALAR *x, int *idx, int n, int d) { struct T *tab; int i; /* Prepare tab for sorting */ tab = (struct T *) malloc (n * sizeof (struct T)); __init_tab__ (x, tab, n, d); /* Sort using qsort() from the standard library */ qsort (tab, n, sizeof (struct T), __lexical_cmp__); /* Fill output list */ for (i = 0; i < n; i++) idx[i] = tab[i].pos; free (tab); } /*--------------------------------------------------------------*/ /* TODO: templated versions, to handle integer types, single, etc. */ int pareto_find (SCALAR *x, int *ndpos, int *drank, int n, int d) { /* ndpos: liste de taille n * * ndpos[i] = position in x of the i^th non-dominated point * (i^th in the lexical order) 0 <= i < k * * ndpos[i] = -1 for all i > k * * drank: another list of length n * * drank[i] = rank (in the lexical order, between 0 and k) of * the first dominating point if x[i, :] is dominated * * drank[i] = -1 if x[i, :] is not dominated * * Both lists are assumed to have been allocated by the caller. * * Note: all indices are 0-based in this function. */ struct T *tab; int i, ii, k, pos; /* Prepare tab for sorting */ tab = (struct T *) malloc (n * sizeof (struct T)); __init_tab__ (x, tab, n, d); /* Sort using qsort() from the standard library */ qsort (tab, n, sizeof (struct T), __lexical_cmp__); /* Fill ndpos and drank with -1 */ for (i = 0; i < n; i++) { ndpos[i] = -1; drank[i] = -1; } /* Remove dominated points */ /* i : rank of current point. Start at the SECOND element */ for (i = 1; i < n; i++) for (ii = 0; ii < i; ii++) if ((tab[ii].pos >= 0) && (__is_dominated__ (tab + i, tab + ii))) { drank[tab[i].pos] = ii; tab[i].pos = - 1; break; } /* Note: at this stage, drank contains the rank of the first * dominating point in the FULL (sorted) list of points */ /* Fill ndpos */ k = 0; for (i = 0; i < n; i++) { pos = tab[i].pos; if (pos >= 0) { /* indicates a non-dominated point */ ndpos[k] = pos; tab[i].pos = k; k ++; } } /* Adjust drank to the final list of non-dominated points */ for (i = 0; i < n; i++) if (drank[i] != -1 ) drank[i] = tab[drank[i]].pos; free (tab); return k; } /*--------------------------------------------------------------*/ void is_dominated (const SCALAR *xa, const SCALAR *xb, LOGICAL *isdom, int *drank, int n, int k, int d) { int i, j, b; struct T T1, T2; SCALAR xa1; T1.pos = 0; /* unused */ T1.stride = n; T1.dim = d; T2.pos = 0; /* unused */ T2.stride = k; T2.dim = d; for (i = 0; i < n; i++) { b = 0; /* not dominated, until proved otherwise */ T1.data = xa + i; /* pointer to the current row */ xa1 = xa[i]; /* first element of the current row */ for (j = 0; j < k; j++) { /* xb is assumed to be LEXICALLY SORTED => as soon as the first element becomes bigger than xa1, we know that the current row is not dominated */ if (xb[j] > xa1) break; T2.data = xb + j; if (__is_dominated__ (&T1, &T2)) { b = 1; break; } } if (b) { drank[i] = j; isdom[i] = (LOGICAL) 1; } else { drank[i] = -1; isdom[i] = (LOGICAL) 0; } } } /*--------------------------------------------------------------*/ void __init_tab__ (const SCALAR *x, struct T *tab, int n, int d) { int i; /* Fill in array to be sorted */ for (i = 0; i < n; i++) { tab[i].pos = i; tab[i].data = x + i; tab[i].dim = d; tab[i].stride = n; } } #endif stk/src/stk_dist_matrixy.c0000664000175000017500000001020712617165717014646 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2015 CentraleSupelec * * Copyright (C) 2011, 2012 SUPELEC * * * * Authors: Julien Bect * * Emmanuel Vazquez * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #include "stk_mex.h" static void distance2(double* x, double* y, double* h, size_t nx, size_t ny, size_t dim) { size_t i, j, kx, ky; double diff, lambda; for (i = 0; i < nx; i++) { for (j = 0; j < ny; j++) { /* compute distance between x[i,:] and y[j,:] */ lambda = 0.0; for (kx = i, ky = j; kx < dim * nx; kx += nx, ky += ny) { diff = x[kx] - y[ky]; lambda += diff * diff; } /* store the result in h */ h[i+nx*j] = sqrt(lambda); } } } mxArray* compute_distance_xy(const mxArray* x, const mxArray* y) { size_t d, mx, my; mxArray* h; if((!stk_is_realmatrix(x)) || (!stk_is_realmatrix(y))) mexErrMsgTxt("Input arguments should be real-valued double-precision array."); /* Check that the input arguments have the same number of columns */ if (mxGetN(y) != (d = mxGetN(x))) mexErrMsgTxt("Both input arguments should have the same number of columns."); /* Read the size (number of lines) of each input argument */ mx = mxGetM(x); my = mxGetM(y); /* Create a matrix for the return argument */ h = mxCreateDoubleMatrix(mx, my, mxREAL); /* Do the actual computations in a subroutine */ distance2(mxGetPr(x), mxGetPr(y), mxGetPr(h), mx, my, d); return h; } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { if (nlhs > 1) /* Check number of output arguments */ mexErrMsgTxt("Too many output arguments."); if (nrhs != 2) /* Check number of input arguments */ mexErrMsgTxt("Incorrect number of input arguments."); plhs[0] = compute_distance_xy(prhs[0], prhs[1]); } stk/src/stk_mex.h0000664000175000017500000000731212617165720012721 0ustar bectbect/***************************************************************************** * * * Small (Matlab/Octave) Toolbox for Kriging * * * * Copyright Notice * * * * Copyright (C) 2012, 2013 SUPELEC * * * * Author: Julien Bect * * * * Copying Permission Statement * * * * This file is part of * * * * STK: a Small (Matlab/Octave) Toolbox for Kriging * * (http://sourceforge.net/projects/kriging) * * * * STK is free software: you can redistribute it and/or modify it under * * the terms of the GNU General Public License as published by the Free * * Software Foundation, either version 3 of the License, or (at your * * option) any later version. * * * * STK 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 STK. If not, see . * * * ****************************************************************************/ #ifndef ___STK_MEX_H___ #define ___STK_MEX_H___ #include #include "mex.h" int stk_is_realmatrix(const mxArray* x) { if (mxIsComplex(x) || !mxIsDouble(x)) return 0; if (mxGetNumberOfDimensions(x) != 2) return 0; return 1; } int mxIsDoubleVector (const mxArray* x) { size_t m, n; if (! stk_is_realmatrix (x)) return 0; m = mxGetM (x); n = mxGetN (x); return ((m == 1) && (n > 0)) || ((n == 1) && (m > 0)); } void mxReplaceField (mxArray* S, mwIndex index, const char* fieldname, const mxArray* value) { mxArray *tmp, *value_copy; tmp = mxGetField(S, index, fieldname); if (tmp != NULL) mxDestroyArray(tmp); value_copy = mxDuplicateArray(value); if (value_copy == NULL) mexErrMsgTxt("mxDuplicateArray: not enough free heap " "space to create the mxArray"); mxSetField(S, index, fieldname, value_copy); } #define STK_OK 0 #define STK_ERROR -1 #define STK_ERROR_DOMAIN 1 #define STK_ERROR_OOM 2 #define STK_ERROR_SANITY 3 int mxReadScalar_int(const mxArray* x, int* n) { double t; if (mxGetNumberOfElements(x) != 1) return STK_ERROR; if (mxIsComplex(x) || !mxIsDouble(x)) return STK_ERROR; t = mxGetScalar(x); *n = (int) t; return ((((double) *n) == t) ? STK_OK : STK_ERROR); } #endif stk/NEWS0000664000175000017500000005777012617165714011026 0ustar bectbectChanges in version 2.3.4 ======================== * Bug fixes o @stk_hrect/ismember.m: Fix a bug that prevented ismember from working on more than one point at a time, and another bug in the case where B is not an stk_hrect object (it was incorrectly assumed to be an stk_dataframe in this case). o @stk_hrect/subsref.m: Make sure that the returned value is still an stk_hrect object when the number of rows (which is two) is unchanged. * Minor changes o Add a 'clean' target to the Octave package Makefile. o Decrease unit test verbosity. Changes in version 2.3.3 ======================== * Bug fixes o stk_dist, stk_filldist, stk_gpquadform, stk_mindist: Fix segmentation faults occuring with very large matrices (related to signed integer-based index computation in the underlying MEX-files). o stk_example_doe03.m: Use the appropriate flag for maximization. o mole/matlab/file_in_path.m: Fix two bugs (Matlab only) * Minor changes o stk_example_doe03.m: Display pointwise credible intervals in the upper panel. Changes in version 2.3.2 ======================== * Bug fixes o stk_param_estim.m: Fix a bug related to parameter objects. More precisely, use (:) indexing systematically to access the vector of numerical parameters corresponding to a given parameter object. o @stk_kreq_qr/get.m: Fix a call to dot () to make it work when there is only one observation. o Add missing field "Depends" to the DESCRIPTION file in the Octave package. * Minor changes o stk_param_getdefaultbounds.m: Return empty lower and upper bounds for parameter classes that do not implement the stk_param_getdefaultbounds (instead of calling error). o Add optional field "Autoload" to the DESCRIPTION file in the Octave package. Changes in version 2.3.1 ======================== * Bug fixes o stk_optim_hasfmincon.m: Detect fmincon by trying to use it, instead of relying on the result of the exist function (ticket #30 closed). o stk_param_estim.m: Make sure that the bounds that we use for the lnv parameter contain the starting point lnv0 when it is provided. o @stk_dataframe/set.m: Fix stk_error calls (missing mnemonic). o stk_distrib_bivnorm_cdf.m: Fix a bug in the case of mixtures of singular and non-singular cases. o @stk_dataframe/subsasgn.m: Preserve column names when deleting rows, even if the resulting array is empty. * Minor changes o stk_init.m: Clear persistent variables. As a consequence, stk_init can now be used to restart STK completely. o stk_commonsize.m: Accept empty dimensions, under the condition that all input arguments have the same empty dimensions (in which case the result is empty). o stk_commonsize.m: is now faster when some arguments already have the proper size (unnecessary calls to repmat are avoided). o stk_distrib_normal_cdf.m, stk_distrib_bivnorm_cdf.m: are now slightly faster (unnecessary calls to stk_commonsize are avoided). Changes in version 2.3.0 ======================== * Model structures o lognoisevariance is now considered a mandatory field. For backward compatibility, a missing or empty lognoisevariance field is interpreted as -inf. A nan value in the lognoisevariance field is now interpreted as meaning that the variance of the noise must be estimated. o model.param is set to nan by stk_model. This special value indicates that the parameters must be estimated from the data before any prediction can be done. o Improved documentation for stk_model. * Parameter estimation o stk_param_init defaults to using the input value of model.lognoisevariance if it is not NaN, and estimating the variance if it is NaN. The meaning of the fifth argument, now called DO_ESTIM_LNV, has thus slightly changed: it is used to force or prevent the estimation of the variance of the noise, regardless of the value of model.lognoisevariance. o stk_param_init also supports the heteroscedastic noisy case, but only when the variance of the noise is assumed to be known. o stk_param_init_lnv is a new function that provides a rough estimate of the variance of the noise (in the spirit of stk_param_init). o stk_param_estim estimates the variance of the noise if either a) param0lnv is provided and is not empty (as in STK <= 2.2.0), or b) model.lognoisevariance is NaN (new behaviour). If param0lnv is not provided, a starting point is obtained using the new stk_param_init_lnv function. In all cases (whether lnv is estimated or not) a meaningful value is returned for lnv (equal to model.nognoisevariance when lnv is not estimated). o stk_param_estim can provide a value for param0 when it is missing from the list of input arguments. o stk_param_relik: Compute G = W' * K * W in such a way that the result is always (?) symmetric. * Prediction o stk_predict computes lambda_mu and RS only when necessary, depending on the number of output arguments. * Covariance functions o stk_noisecov now has a 'pairwise' argument, like the others. * Sampling o stk_sampling_randunif accepts empty dim argument when box is provided * Simulation of Gaussian process sample paths o stk_generate_samplepaths.m: Do not add observation noise to the generated sample paths. This is consistent with stk_predict, which returns posterior variances for the unknown function, not for future noisy observations. o stk_conditioning.m: Simulate sample paths conditioned on noisy observations when the additional NOISE_SIM argument is provided. o stk_generate_samplepaths.m: Fix conditioning on noisy observations, which was not implemented properly until now. o stk_generate_samplepaths.m: The output is an stk_dataframe object if either MODEL.response_name exists and is a non-empty string, or one of the input arguments (XI, ZI, XT) is an stk_dataframe object. o stk_conditioning.m: The output is an stk_dataframe object if either LAMBDA or ZSIM is an stk_dataframe object. * Objects representing sets o stk_hrect: new class to describe hyper-rectangle objects. o stk_boundingbox.m: constructs the bounding box for a set of points. * Examples o stk_example_kb04 demonstrates how it is possible to estimate the variance of the noise without providing a initial guess for it. o stk_example_kb09.m demonstrates how to simulate conditional sample paths in the case of noisy observations, both in the homoscedastic and in the heteroscedastic cases. * Miscellaneous o stk_distrib_bivnorm_cdf computes bivariate normal probabilities. o stk_disp_progress.m: New function that displays a textual progress indicator. o stk_feval handles cell-arrays of functions (ticket #19 closed), multivariate outputs (ticket #20 closed), and uses vectorized calls by default (unless a progress indicator is displayed). o sort, mtimes, uplus and uminus are now overloaded for stk_dataframe objects o min, max are now able to return a second output argument (index of mininizer or maximizer) for stk_dataframe arguments. o Now the output of stk_dataframe is always an stk_dataframe object. Previously, this wasn't true if the first input argument was, e.g., an stk_factorialdesign object. o stk_distrib_normal_ei, stk_distrib_student_ei: bugfix (the optional input argument "minimize" was not taken into account). o stk_distrib_normal_cdf.m: Fix the zero-variance case. Changes in version 2.2.1 ======================== * Octave 4.0 compliance o Fix unit tests * Octave package o Do not ship stk_test and stk_runtests with the Octave package Changes in version 2.2.0 ======================== * Octave package o The STK is now available both as an "all-purpose" Matlab/Octave toolbox (as usual) and as a full-fledged Octave package that can be installed using `pkg install`. * Core o stk_model now also accepts function handles for covariance_type. o stk_ortho_func is deprecated and will be completeky replaced, in the 3.x series, by linear model objects. In the meantime, stk_ortho_func has been kept as a gateway to stk_lm_* functions and now supports the case of cubic polynomial models. o stk_cholcov: new function that adaptively adds a little bit of noise on the diagonal of a covariance matrix to help chol succeed, when the first factorization returned by chol is not complete (a warning is emitted when doing so). Used in stk_param_init, @stk_kreq_qr/get, stk_param_relik... o @stk_kreq_qr: heuristic improvement of numerical conditioning (implemented in the new private function compute_P_scaling). * Covariance functions o Accept invRho = 0 in anisotropic covariance functions. o stk_sf_matern: Handle special cases (3/2, 5/2, Inf) explicitely, and handle large values of the smoothness parameter nu better. o Handle the case of Gaussian isotropic and anisotropic covariance functions in stk_param_init and stk_param_getdefaultbounds. * Linear models o Introduce linear models objects. Currently, the following linear model object classes are available: stk_lm_null, stk_lm_constant, stk_lm_affine, stk_lm_quadratic, stk_lm_cubic and stk_lm_matrix. o Linear model objects are still considered an experimental feature. They can be accessed by setting model.order to nan, in which case model.lm is expected to contain a linear model object. o stk_example_misc03: New example script that demonstrates the use of linear model objects. * Sample path simulation (stk_generate_samplepaths) o The simulation of conditioned sample paths has been made easier (see ticket #3 on SF). This is demonstrated by stk_example_kb08. o Now uses model.response_name (if available) to create column names for the output array, and xt.rownames (if available) to create row names. o stk_generate_samplepaths can deal with replicated rows in xt. * Parameter estimation o stk_param_estim - Warn about constant-response data. - Return an additional 'info' structure, which currently contains the criterion that has been used, the criterion value at the optimum, and the bounds. - Add a new (optional) input argument that will make it possible, in the future, to select which estimation criterion to use. o stk_param_relik - Check symmetry of G = W' * K * W and apply a naive fix if it is not (emit a warning when doing so). - Improved implementation, which seems to reduce the number of warnings related to bad conditioning, and also improve the performance for large n (about 1000, say). o New optimization options (can bet set thorugh stk_options_set) - Add global options to control upper/lower bounds for param estim. - (Matlab) Add a 'optim_display_level' option to control the verbosity fmincon/fminsearch. Its default value is 'off'. o stk_param_gls: new function that computes the GLS estimator. * Array objects (stk_dataframe, stk_factorialdesign) o stk_length: New function that returns the "length" of an array, currently defined as its number of rows. o Improved display for both stk_dataframe and stk_factorial objects o Fix and improve accessors (subsasgn, subsref, set, get, fieldnames) o Minimalist support for linear indexing on stk_dataframe objects o New overloaded methods: @stk_dataframe/abs, @stk_dataframe/reshape o @stk_dataframe/plot: Full rewrite to improve compatibility with the base plot function. The case where x is an stk_dataframe objects with two or more columns is now handled in a way that is consistent with the base plot function (i.e., if x has two columns, then we get two 1D plots). o @stk_dataframe/horzcat, @stk_dataframe/vertcat: Now the result is always an stk_dataframe object, and has row names iff either one of the two arguments doesn't have row names, or the row names of both arguments agree. o @stk_dataframe/bsxfun: Modify the behaviour of bsxfun for stk_dataframe objects. The result is always an stk_dataframe object, and has column names iff either one of the two arguments doesn't have columns names or the columns names of both arguments agree. Graphics o stk_plot2d is deprecated and will be removed in the 3.x series. Use contour, mesh, surf... directly instead (they are now overloaded for stk_factorialdesign objects). o stk_plot1d: Improved flexibility in the way input arguments are handled. o stk_figure does not set the axis title any more. Pareto domination o stk_isdominated: New function that returns true for dominated rows. o stk_paretofind: New function that finds non-dominated points. o stk_example_misc04: New example script illustrating random Pareto fronts. * Faster and less verbose startup o Stop bothering users at startup with information that they can find in the README file anyway. o Don't display selected optimizers at startup. o In Matlab, don't bother checking if the PCT is installed. * Documentation o New HTML documentation, available in the "all-purpose" Matlab/Octave release (doc/html directory) and online on Source-Forge at . o Lots of fixes and improvements in help texts. o Add a CITATION file, which explains how to cite STK in publications. o stk_testfun_braninhoo: Fix domain bounds in the documentation. * Miscellaneous o Options set/get - stk_options_set: Add a reset feature. - stk_options_set: Prevent persistent from being cleared (bugfix) o Remove page_screen_output (not needed anymore). o Restore the stk_ prefix for distrib_* functions (distrib_normal_cdf is renamed to stk_distrib_normal_cdf, distrib_student_ei to stk_distrib_student_ei, etc.) o Lots of internal changes, minor changes, etc. not worth mentioning here. Changes in version 2.1.1 ======================== * This is a minor bugfix release. o Fix a bug in stk_param_init. o Add size checks to several functions. o Warn Octave users about the problem with MEX-files in privates folders: Octave must be restarted when stk_init is run for the first time. Changes in version 2.1.0 ======================== * Several ways to get help, report bugs or ask for new features on Sourceforge are now proposed to the user (both in README or stk_init.m) * Examples o Existing examples have been improved: descriptions rewritten; graphical options controlled globally thanks to dedicated plotting functions (stk_figure; stk_subplot, stk_axes, stk_title...); + lots of minor changes o New examples - kb06: ordinary kriging VS linear trend - kb07: simulations of Matern sample paths with different various nu - doe03: one-dimensional Bayesian optimization (expected improvement) * Covariance functions o New function: stk_gausscov_iso.m (isotropic Gaussian covariance model) o New function: stk_gausscov_aniso.m (anisotropic Gaussian covariance model) * Special functions o The precision of stk_sf_matern has been improved around 0 for high nu o New function: stk_sf_gausscorr (Gaussian correlation function in 1D) * Design of experiments o New function: stk_phipcrit (phi_p criterion for space-filling designs) o New function: stk_maxabscorr (maximal pairwise absolute correlation) * Probability distributions o A new 'probability distributions' module has been initiated (read misc/distrib/README to understand the reasons why) o Currently provides: pdf, cdf and expected improvement (EI) for the Gaussian and Student t distributions * Matlab/Octave compatibility throughout all supported releases has been strengthened, thanks to the creation of a Matlab/Octave Langage Extension (MOLE) module o octave_quantile removed; instead, a replacement for quantile() is provided by the MOLE when needed. o new function graphicstoolkit(), providing a kind of replacement for graphics_toolkit(), that also work in Matlab and old Octave releases o ... * Miscellaneous o stk_plot1dsim has been removed (use stk_plot1d instead) o plotting functions now work directly on the current axes o An optional 'box' argument has been added to stk_sampling_halton_rr2 o stk_feval now uses input row names for its output * Bugfixes o @stk_kreq_qr/stk_update is now (inefficient but) working o isequal() is now working for stk_dataframe and stk_kreq_qr objects in Octave 3.2.x (explicit overloading was required for these old releases) o and many other tiny little things Changes in version 2.0.3 ======================== * This is a minor bugfix release. o Fix a bug core/stk_predict.m (related to blockwise computations) Changes in version 2.0.2 ======================== * This is a minor bugfix release. o Fix a bug in @stk_dataframe/subsref.m (handle colnames properly when ()-indexing is used to extract a subset of rows). o Fix a bug in @stk_dataframe/stk_dataframe.m (make sure that .data contains numerical data) and add a copy constructor. Changes in version 2.0.1 ======================== * This is a minor bugfix release. o Fix a bug in stk_predict (don't compute the optional outputs lambda and mu when they are not requested by the caller). o Fix a bug in stk_sampling_olhs (fail neatly when called with n = 2). Changes in version 2.0.0 ======================== * Required Octave version number has been raised to 3.2.2. * Important changes to the public API o New R-like data structures: @stk_dataframe, @stk_factorial_design. o The structures previously used everywhere in STK (with a ".a" field) are still supported but should be considered as deprecated (and will probably be completely removed in the next major release). o As a result, stk_predict () does not return a ".a/.v" structure any more. Instead, it returns an stk_dataframe object with two variables called "mean" and "var". o The function that computes (the opposite of the log of) the restricted likelihood is now called stk_param_relik instead of stk_remlqrg. * Many improvements in the internal structure of STK, for the sake of clarity (for those who happen to read the code) and efficiency: o @stk_kreq_qr: new class for encapsulating basic computations related to a Gaussian process (kriging) model. o The old Kx_cache/Px_cache mechanism, for working efficiently on finite spaces, has been replaced by a new covariance fonction: stk_discretecov. o A new framework to encapsulate various approaches to parallel computations. Currently only supporting 'none' or 'parfor' (Mathworks' PCT toolbox parfor loops) engines, more to come later. * Experimental support for parameter objects. o model.param is now allowed to be an object from a user-defined class. This feature is experimental, and not really used currently in the toolbox. o A new function stk_param_getdefaultbounds () has appeared in ./param, that was previously hidden in stk_predict (). It can be overridden in the case where model.param is an object from a user-defined class. * New sampling algorithms and related functions o Fill-distance computation: exact (using Pronzato & Müller, Statistics & Computing, 2011) or approximate (using a space-filling reference set). o Van Der Corput and Halton RR2-scrambled sequences (quasi-MC) o NOLHS designs (Cioppa & Lucs, Technometrics, 2007) * Miscellaneous o misc/options: a new system for managing options o octave_quantile(): replacement for the missing quantile() function in base Matlab (Mathworks' Statistics toolbox is not a requirement of STK). o Add MEX-files for computing "Gibbs-Paciorek quadratic forms" to support future work on non-stationary covariance functions. o AUTHORS: a list of maintainers and contributors can now be found at the root of the source tree. o stk_compile_all: now recompiles MEX-files automatically if the source code has changed. o Various new utility functions, tiny or not-so-tiny improvements, bugfixes here and there... Changes in version 1.2 ====================== * stk_predict o Now offers the possibility to compute the posterior covariance matrix (it is returned as a fourth optional argument). o Has been modified to work with non-stationary covariance functions. * Added a new "pairwise" option to all covariance functions and also to stk_dist (formerly stk_distance_matrix). This options allows to compute only the diagonal of the full distance/covariance matrix). * Space-filling designs o New function (stk_filldist) to compute the (discretized) fill distance. o New function (stk_sampling_olhs) to generate Orthogonal Latin Hypercube (OLH) samples using the algorithm of Ye (1998). * New (experimental) function to choose automatically the starting point for a parameter estimation optimization procedure (stk_param_init). * New functions to work with boxes: stk_rescale, stk_normalize. * More flexible representation of data o Improved the flexibility most functions (stk_predict, stk_param_estim, ...), which are now accepting both matrices and "data structures" (with an 'a' field) as input arguments. o New function: stk_datastruct. * Regular grids o New function stk_plot2d() that serves has a wrapper around {surf|contour|mesh|pcolor}-type functions, to plot data defined over a two-dimensional regular grid. o stk_sampling_regulargrid now also returns 'ndgrid-style' coordinate matrices stored in new .coord field. * Examples o Reorganized the example folder and renamed all example scripts. o New example (stk_example_misc03) to demonstrate the effect of adding a prior on the covariance parameters. o Improved graphical outputs in stk_example_kb03. o New test function: stk_testfun_braninhoo (Branin-Hoo). * Miscellaneous o Renamed stk_distancematrix to stk_dist. o Various new utility functions: stk_runexamples, stk_disp_framedtext, stk_disp_examplewelcome, stk_plot_shadedci, stk_octave_config. o Improved Octave-specific configuration. o Lots of bugfixes and improvements. Changes in version 1.1 ====================== * New special functions for the Matern 3/2 and 5/2 correlation functions (stk_sf_matern32, stk_sf_matern52). New covariance functions (stk_materncov32_iso, stk_materncov32_aniso, ...). * New MEX-file to compute the separation distance (stk_mindist). * New function to generate random Latin Hypercube Samples (stk_sampling_randomlhs). Renamed stk_sampling_cartesiangrid to stk_sampling_regulargrid, and changed the meaning of the first argument for consistency with other stk_sampling_* functions. * Improved stk_model function. Now provides default parameters for several families of covariance functions. * Renamed fields in "model" structures (covariance_cache to Kx_cache and P0 to Px_cache). A new field 'dim' has been added to the 'model' structure. * Changed the order of the arguments of the functions that use the structure 'model'. Now, 'model' is always the first argument. * Changed stk_param_estim to make it possible to estimate noise variance. * Fixed issues in stk_param_estim.m related to the definition of the search domain and the selection of (constrained/unconstrained) optimizer. * Renamed stk_conditionning to stk_conditioning. * New functions for a more flexible and efficient management of STK's configuration in stk_init (path, compilation of MEX-file, checking for optional packages, selection of the default optimizer, ...). * New functions for unit testing, based on Octave's testing system (stk_test, stk_runtests). Tests have been added to most functions in the toolbox. * Improved documentation & new examples. * Improved argument checking and error messages. * Improved compatibility with older versions of Octave and Matlab. * Lots of minor changes and bug fixes. * Complete reorganization of the code (better directory structure). stk/INDEX0000664000175000017500000003202212617165722011077 0ustar bectbectstk >> STK, a Small Toolbox for Kriging ## Several reasons why we don't want to let certain functions ## appear in the INDEX (i.e., in the public API of STK) ## ## 1) Deprecation: these functions will be removed in future ## versions of STK, no need to adertise them. ## ## 2) Internal: these functions are mostly intended for internal ## use in STK. Although it might be occasionnaly useful for ## advanced users to call them directly, they are not considered ## as part of the public API and therefore not as stable as ## public API functions. A necessary (but not sufficient) condition ## for a function to be called "internal" is that it should not ## be used in any of the stk_example_* scripts. Use at your own ## risk. ## ## 3) Trivial overload: these functions provide the same functionality ## as a corresponding "generic" function, with such a similar ## behaviour that no documentation needs to be provided. For ## instance, @stk_dataframe/abs is just a shortcut to avoid ## writing abs (double (x)) or abs (x.data) when x is an ## stk_dataframe object. No need to advertise such functions in ## the INDEX. ## ## 4) Experimental features: not ready yet for use by everyone. ## Kriging: Core STK functions ## Why not group all these functions in the same folder ? ## Currently, some of them are in ./core/ and some others in ./utils/ stk_model stk_make_matcov stk_predict stk_conditioning stk_generate_samplepaths #stk_ortho_func [deprecated] #stk_cholcov [internal] Kriging: Parameter estimation stk_param_estim #stk_param_getdefaultbounds [internal] stk_param_gls stk_param_init stk_param_init_lnv stk_param_relik ## The stk_kre_qr class -> not ready to be exposed #@stk_kreq_qr/get [internal] #@stk_kreq_qr/isequal [internal] #@stk_kreq_qr/linsolve [internal] #@stk_kreq_qr/stk_kreq_qr [internal] #@stk_kreq_qr/stk_set_righthandside [internal] #@stk_kreq_qr/stk_squared_seminorm [internal] #@stk_kreq_qr/stk_update [internal] #@stk_kreq_qr/subsref [internal] Kriging: Covariance functions stk_gausscov_aniso stk_gausscov_iso stk_materncov32_aniso stk_materncov32_iso stk_materncov52_aniso stk_materncov52_iso stk_materncov_aniso stk_materncov_iso stk_noisecov stk_discretecov ## The prefix 'sf' for 'special functions' is not appropriate, since the ## expression 'special function' refers to specific rather specific in the ## traditional math vocabulary... Because of that, these functions are ## likely to be renamed in future versions of STK. Until then, let us ## consider them as "internal" (they are never used directly in any of the ## example scripts) #stk_sf_gausscorr [internal] #stk_sf_matern [internal] #stk_sf_matern32 [internal] #stk_sf_matern52 [internal] ## The use of stk_lm_* objects is currently considered as an experimental ## feature. It is not advertised in any of the example scripts. Moreover, ## it requires to set model.order to NaN, a "cheat code" feature which ## is very weakly documented (only in stk_example_misc03). stk_lm_* ## should become the standard way of of defining the "linear part" of a ## model in the next major release of STK. #@stk_lm_affine/stk_lm_affine [experimental] #@stk_lm_affine/feval [experimental] #@stk_lm_constant/stk_lm_constant [experimental] #@stk_lm_constant/feval [experimental] #@stk_lm_cubic/stk_lm_cubic [experimental] #@stk_lm_cubic/feval [experimental] #@stk_lm_matrix/stk_lm_matrix [experimental] #@stk_lm_matrix/feval [experimental] #@stk_lm_null/stk_lm_null [experimental] #@stk_lm_null/feval [experimental] #@stk_lm_quadratic/stk_lm_quadratic [experimental] #@stk_lm_quadratic/feval [experimental] Design of experiments (non-sequential): sampling stk_sampling_halton_rr2 stk_sampling_maximinlhs stk_sampling_olhs stk_sampling_randomlhs stk_sampling_randunif stk_sampling_regulargrid stk_sampling_vdc_rr2 Design of experiments (non-sequential): criterions ## note: some are in misc/design, others in misc/dist... ## Shouldn't they all be in sampling/criterions ? stk_filldist #stk_filldist_discretized [internal] #stk_filldist_exact [internal] stk_maxabscorr stk_mindist stk_phipcrit Design of experiments (sequential): expected improvement stk_distrib_normal_ei stk_distrib_student_ei Examples: kriging basics stk_example_kb01 stk_example_kb02 stk_example_kb03 stk_example_kb04 stk_example_kb05 stk_example_kb06 stk_example_kb07 stk_example_kb08 stk_example_kb09 Examples: design of experiments stk_example_doe01 stk_example_doe02 stk_example_doe03 Examples: miscellaneous stk_example_misc01 stk_example_misc02 stk_example_misc03 stk_example_misc04 #stk_testfun_braninhoo #stk_testfun_goldsteinprice ## Cf. misc/distrib/README #stk_distrib_normal_cdf [internal] #stk_distrib_normal_pdf [internal] #stk_distrib_student_cdf [internal] #stk_distrib_student_pdf [internal] #stk_distrib_bivnorm_cdf [internal] Miscellaneous: arrays stk_boundingbox stk_feval stk_isdominated stk_length stk_normalize stk_paretofind stk_rescale @stk_dataframe/stk_dataframe @stk_factorialdesign/stk_factorialdesign @stk_factorialdesign/ndgrid @stk_hrect/stk_hrect #stk_commonsize [internal] #stk_sprintf [internal] #stk_sprintf_colnames [internal] #stk_sprintf_info [internal] #stk_sprintf_rownames [internal] #stk_sprintf_sizetype [internal] #@cell/stk_sprintf_sizetype [internal] ## Those are for legacy support of .a data structures ## (will be completely removed in the 3.x series) #@struct/double #@struct/stk_boundingbox #@struct/stk_length #@stk_dataframe/stk_boundingbox [overload STK] #@stk_dataframe/stk_conditioning [overload STK] #@stk_dataframe/stk_generate_samplepaths [overload STK] #@stk_dataframe/stk_length [overload STK] #@stk_dataframe/stk_normalize [overload STK] #@stk_dataframe/stk_rescale [overload STK] #@stk_dataframe/apply [internal] #@stk_dataframe/stk_sprintf [internal] #@stk_dataframe/stk_sprintf_colnames [internal] #@stk_dataframe/stk_sprintf_info [internal] #@stk_dataframe/stk_sprintf_rownames [internal] #@stk_dataframe/stk_sprintf_sizetype [internal] #@stk_dataframe/abs [overload base] #@stk_dataframe/and [overload base] #@stk_dataframe/bsxfun [overload base] #@stk_dataframe/cat [overload base] #@stk_dataframe/ctranspose [overload base] #@stk_dataframe/diff [overload base] #@stk_dataframe/disp [overload base] #@stk_dataframe/display [overload base] #@stk_dataframe/double [overload base] #@stk_dataframe/end [overload base] #@stk_dataframe/eq [overload base] #@stk_dataframe/fieldnames [overload base] #@stk_dataframe/ge [overload base] #@stk_dataframe/get [overload base] #@stk_dataframe/gt [overload base] #@stk_dataframe/horzcat [overload base] #@stk_dataframe/isempty [overload base] #@stk_dataframe/isequal [overload base] #@stk_dataframe/ismember [overload base] #@stk_dataframe/ldivide [overload base] #@stk_dataframe/le [overload base] #@stk_dataframe/length [overload base] #@stk_dataframe/lt [overload base] #@stk_dataframe/ne [overload base] #@stk_dataframe/or [overload base] #@stk_dataframe/plot [overload base] #@stk_dataframe/subsasgn [overload base] #@stk_dataframe/subsref [overload base] #@stk_dataframe/max [overload base] #@stk_dataframe/mean [overload base] #@stk_dataframe/median [overload base] #@stk_dataframe/min [overload base] #@stk_dataframe/minus [overload base] #@stk_dataframe/mode [overload base] #@stk_dataframe/mtimes [overload base] #@stk_dataframe/plus [overload base] #@stk_dataframe/power [overload base] #@stk_dataframe/prod [overload base] #@stk_dataframe/rdivide [overload base] #@stk_dataframe/realpow [overload base] #@stk_dataframe/reshape [overload base] #@stk_dataframe/set [overload base] #@stk_dataframe/size [overload base] #@stk_dataframe/sort [overload base] #@stk_dataframe/quantile [overload base] #@stk_dataframe/std [overload base] #@stk_dataframe/sum [overload base] #@stk_dataframe/times [overload base] #@stk_dataframe/transpose [overload base] #@stk_dataframe/uminus [overload base] #@stk_dataframe/uplus [overload base] #@stk_dataframe/var [overload base] #@stk_dataframe/vertcat [overload base] #@stk_dataframe/xlim [overload base] #@stk_dataframe/xor [overload base] #@stk_dataframe/ylim [overload base] #@stk_factorialdesign/contour [overload base] #@stk_factorialdesign/fieldnames [overload base] #@stk_factorialdesign/get [overload base] #@stk_factorialdesign/mesh [overload base] #@stk_factorialdesign/meshc [overload base] #@stk_factorialdesign/meshz [overload base] #@stk_factorialdesign/pcolor [overload base] #@stk_factorialdesign/set [overload base] #@stk_factorialdesign/subsasgn [overload base] #@stk_factorialdesign/surf [overload base] #@stk_factorialdesign/uminus [overload base] #@stk_factorialdesign/stk_boundingbox [overload STK] #@stk_factorialdesign/stk_normalize [overload STK] #@stk_factorialdesign/stk_rescale [overload STK] #@stk_factorialdesign/stk_sprintf [internal] #@stk_factorialdesign/stk_sprintf_levels [internal] #@stk_hrect/axis [overload base] #@stk_hrect/disp [overload base] #@stk_hrect/display [overload base] #@stk_hrect/get [overload base] #@stk_hrect/horzcat [overload base] #@stk_hrect/ismember [overload base] #@stk_hrect/subsasgn [overload base] #@stk_hrect/subsref [overload base] #@stk_hrect/vertcat [overload base] #@stk_hrect/stk_boundingbox [overload STK] #@stk_hrect/stk_normalize [overload STK] #@stk_hrect/stk_rescale [overload STK] Miscellaneous: options, plots... stk_dist stk_init stk_options_get stk_options_set stk_plot1d #stk_plot2d [deprecated] #stk_plot_shadedci [internal] stk_select_optimizer stk_version #stk_gpquadform [experimental] ## Replacement for some base functions related to figures. Mostly for use ## in STK's examples, to keep consistent graphical options accross all ## examples. No need to let these appear in the INDEX. #stk_axes [internal] #stk_figure [internal] #stk_get_axis_arg [internal] #stk_labels [internal] #stk_subplot [internal] #stk_title [internal] #stk_xlabel [internal] #stk_ylabel [internal] #stk_zlabel [internal] ## error/warning #stk_error [internal, not for public use] ##stk_warning does not exist yet, but it should (?) ## misc/text #stk_disp_examplewelcome #stk_disp_progress #stk_sprintf_colvect #stk_sprintf_colvect_fixedpoint #stk_sprintf_colvect_scientific #stk_sprintf_framed ## testing STK #stk_assert_box [internal] #stk_isequal_tolabs #stk_isequal_tolrel #stk_is_lhs #stk_test_dfbinaryop ## (embryonic) parallelization engine #@stk_parallel_engine_none/stk_parallel_engine_none [experimental] #@stk_parallel_engine_none/stk_parallel_feval [experimental] #@stk_parallel_engine_none/stk_parallel_stop [experimental] #@stk_parallel_engine_parfor/stk_parallel_engine_parfor [experimental] #@stk_parallel_engine_parfor/stk_parallel_feval [experimental] #@stk_parallel_engine_parfor/stk_parallel_stop [experimental] #stk_parallel_cutblocks [experimental] #stk_parallel_engine_get [experimental] #stk_parallel_engine_set [experimental] #stk_parallel_feval [experimental] #stk_parallel_start [experimental] #stk_parallel_stop [experimental] stk/CITATION0000664000175000017500000000132712617165714011447 0ustar bectbect-------------------------------------------------------------------- To cite this release of STK in publications use: Julien Bect, Emmanuel Vazquez and others (2015). STK: a Small (Matlab/Octave) Toolbox for Kriging. Release 2.3. URL http://kriging.sourceforge.net A BibTeX entry for LaTeX users is: @misc{, author = {Bect, Julien and Vazquez, Emmanuel and others}, title = {{STK}: a {S}mall ({M}atlab/{O}ctave) {T}oolbox for {K}riging. {R}elease 2.3}, year = {2014}, url = {http://kriging.sourceforge.net} } We have invested a lot of time and effort in the development of STK. Please cite it if you use it. -------------------------------------------------------------------- stk/ChangeLog0000664000175000017500000041024512617165714012067 0ustar bectbect2015-11-06 Julien Bect Makefile: Fix 'clean' target (tab instead of spaces) * admin/octpkg/Makefile: Fix 'clean' target (tabs instead of spaces) 2015-10-30 Julien Bect Decrease unit test verbosity * arrays/@stk_dataframe/double.m: decrease unit test verbosity. * arrays/@stk_dataframe/sort.m: idem * arrays/@stk_dataframe/subsasgn.m: idem * arrays/@stk_factorialdesign/fieldnames.m: idem * arrays/@stk_factorialdesign/stk_factorialdesign.m: idem * arrays/@stk_hrect/horzcat.m: idem * misc/text/stk_sprintf_colvect_scientific.m: idem * paramestim/stk_param_gls.m: idem Add a 'clean' target to the Octave package Makefile * admin/octpkg/Makefile: Add a 'clean target'. 2015-10-22 Julien Bect @stk_hrect/subsref.m: Return an stk_hrect object if possible * arrays/@stk_hrect/subsref.m: Make sure that the returned value is still an stk_hrect object when the number of rows (which is two) is unchanged. @stk_hrect/ismember.m: Fix two bugs * arrays/@stk_hrect/ismember.m: Fix a bug that prevented ismember from working on more than one point at a time, and another bug in the case where B is not an stk_hrect object (it was incorrectly assumed to be an stk_dataframe in this case). 2015-10-11 Julien Bect mole/matlab/file_in_path.m: Fix two bugs * misc/mole/matlab/file_in_path.m: Fix two bugs. 2015-10-10 Julien Bect stk_example_doe03.m: Use the appropriate flag for maximization * examples/02_design_of_experiments/stk_example_doe03.m: Use the appropriate flag for maximization. Also, use stk_plot1d for the upper panel plot to display pointwise credible intervals. 2015-09-25 Julien Bect Don't use UTF-8 in m-files * misc/design/stk_phipcrit.m: Müller -> Muller * misc/dist/stk_filldist.m: Idem * misc/dist/stk_filldist_exact.m: Idem 2015-09-15 Julien Bect README: Fix a typo * README: Fix a typo 2015-07-20 Julien Bect Use size_t for computations on positive indices * misc/dist/private/stk_dist_matrixx.c: Use size_t for computations on positive indices, otherwise we can get very unpleasant surprises (aka segfaults) as a consequence of negative indices... * misc/dist/private/stk_dist_matrixy.c: idem * misc/dist/private/stk_dist_pairwise.c: idem * misc/dist/private/stk_filldist_discr_mex.c: idem * misc/dist/private/stk_gpquadform_matrixx.c: idem * misc/dist/private/stk_gpquadform_matrixy.c: idem * misc/dist/private/stk_gpquadform_pairwise.c: idem * misc/dist/private/stk_mindist_mex.c: idem 2015-06-30 Julien Bect build_octpkg.m: Fix the generated DESCRIPTION file * admin/build_tools/build_octpkg.m: Add "Depends: octave (>= 3.2.2)" and "Autoload: no" to the generated DESCRIPTION file. 2015-06-25 Emmanuel Vazquez @stk_kreq_qr/get.m: Fix a call to dot () * core/@stk_kreq_qr/get.m: Fix a call to dot () to make it work when there is only one observation. 2015-06-25 Rémi Stroh stk_param_estim.m: Fix a bug related to parameter objects. * paramestim/stk_param_estim.m (provide_param0_value): Fix a bug related to parameter objects. More precisely, use (:) indexing systematically to access the vector of numerical parameters corresponding to a given parameter object. @stk_factorialdesign/stk_normalize.m: Add missing line continuation mark * arrays/@stk_factorialdesign/stk_normalize.m: Add missing line continuation mark. 2015-06-24 Julien Bect stk_param_init.m: Removed unused variable. * paramestim/stk_param_init.m: Removed unused variable. stk_param_getdefaultbounds.m: Return [] for parameter classes * paramestim/stk_param_getdefaultbounds.m: Return empty lower and upper bounds for parameter classes that do not implement the stk_param_getdefaultbounds. 2015-06-16 Julien Bect check_index_file.m: Fix error handling. * admin/build_tools/check_index_file.m: Fix error handling. Use PKG_ADD/PKG_DEL directives in the Octave package. * stk_init.m: Add PKG_ADD/PKG_DEL directives. Also, add an optional input argument 'do_quit'; when it is true, stk_init removes STK from the path. * admin/build_tools/build_octpkg.m: No more PKG_ADD/PKG_DEL files. They are replaced by corresponding directives in stk_init.m, which is no longer renamed to PKG_ADD. Also, there are now two STK_OCTAVE_PACKAGE variables to set (one in stk_init.m, the other one in stk_config_rmpath.m). * admin/build_tools/check_index_file.m: No need to warry about PKG_ADD.m ad PKG_DEL.m anymore. * admin/octpkg/post_install.m: Idem. * admin/octpkg/INDEX: Add stk_init to the INDEX. * config/stk_config_path.m: Do not look for PKG_ADD to detect Octave package mode, since there no longer is a PKG_ADD file. Instead, rely on a hard-coded STK_OCTAVE_PACKAGE variable, which is modified at build time by build_octpkg (similarly to the one in stk_init). * config/stk_config_rmpath.m: Modify comment. * config/stk_config_addpath.m: Modify comment. * admin/octpkg/PKG_DEL.m: Removed. Instead, a PKD_DEL directive has been inserted in stk_init. 2015-06-15 Julien Bect Avoid unnecessary calls to stk_commonsize. * misc/distrib/stk_distrib_bivnorm_cdf.m: Avoid unnecessary calls to stk_commonsize. * misc/distrib/stk_distrib_normal_cdf.m: Idem. 2015-06-12 Julien Bect stk_commonsize.m: Avoid unnecessary calls to repmat. * arrays/generic/stk_commonsize.m: Avoid unnecessary calls to repmat. 2015-06-11 Julien Bect stk_commonsize.m: Accept empty dimensions * arrays/generic/stk_commonsize.m: Accept empty dimensions, under the condition that all input arguments have the same empty dimensions (in which case the result is empty). 2015-06-10 Julien Bect @stk_dataframe/subsasgn.m: Preserve column names when deleting rows * arrays/@stk_dataframe/subsasgn.m: Preserve column names when deleting rows, even if the resulting array is empty. 2015-05-29 Julien Bect stk_distrib_bivnorm_cdf.m: Bugfix * misc/distrib/stk_distrib_bivnorm_cdf.m: Fix a bug in the case of mixtures of singular and non-singular cases. Add unit test. 2015-05-24 Julien Bect Clear persistent variables in stk_init * config/stk_config_clearpersistents.m: New function that unlocks all possibly mlock-ed STK files and clears all STK functions that contain persistent variables. * stk_init.m: Call stk_config_clearpersistents. * admin/RELEASE.md: Update release instructions. 2015-05-20 Julien Bect @stk_dataframe/set.m: Fix stk_error calls (missing mnemonic) * arrays/@stk_dataframe/set.m: Fix stk_error calls (missing mnemonic) stk_param_estim.m: Make sure that lnv0 falls within the bounds * paramestim/stk_param_estim.m (get_default_bounds_lnv): Make sure that lnv0 falls within the bounds returned by get_default_bounds_lnv. 2015-05-19 Julien Bect stk_optim_hasfmincon.m: Improve fmincon detection * misc/optim/stk_optim_hasfmincon.m: Try to use fmincon to check that it is there, instead of relying on the result of the exist function (closes ticket #30). 2015-05-17 Julien Bect admin/octpkg/Makefile: Use $(MKOCTFILE) if defined * admin/octpkg/Makefile: Use $(MKOCTFILE) if defined stk_runtests.m: Make sure that all Octave warnings are disabled * misc/test/stk_runtests.m: Make sure that all Octave warnings are disabled Fix %!shared blocks in unit tests. * arrays/@stk_hrect/stk_normalize.m: Fix unit test. * arrays/generic/stk_feval.m: Fix unit test. 2015-04-22 Julien Bect Improve indexing (subasgn/subsref) for stk_dataframe objects. * arrays/@stk_dataframe/subsasgn.m: Preserve row names and column names when it is possible (closes ticket #21). * arrays/@stk_dataframe/subsref.m: Allow for several levels of indexing in the case of ()-indexing. stk_dataframe.m: Add help text * arrays/@stk_dataframe/stk_dataframe.m: Add help text (closes ticket #26). 2015-04-21 Julien Bect stk_hrect.m: Add help text * arrays/@stk_hrect/stk_hrect.m: Add help text (closes ticket #27). 2015-04-20 Julien Bect stk_boundingbox.m: Add doc and overload for several classes (ticket #28) * arrays/generic/stk_boundingbox.m: Add doc. Handle plain arrays only. * arrays/@stk_dataframe/stk_boundingbox.m: Overload. * arrays/@stk_factorialdesign/stk_boundingbox.m: Overload. * arrays/@stk_hrect/stk_boundingbox.m: Overload. * arrays/@struct/stk_boundingbox.m: Overload. 2015-04-05 Julien Bect stk_feval.m: Update documentation. * stk_feval.m: Update documentation. 2015-03-11 Julien Bect stk_feval.m: Implement vectorized calls and use them by default. * arrays/generic/stk_feval.m: Implement vectorized calls and use them by default. * paramestim/stk_param_relik.m: Fix unit test. Fix progress indicator in stk_feval. * arrays/generic/stk_feval.m: Restore the progress indicator. * misc/text/stk_disp_progress.m: Fix progress message. 2015-03-04 Julien Bect stk_distrib_normal_cdf.m: Fix the zero-variance case * misc/distrib/stk_distrib_normal_cdf.m: Fix the zero-variance case. Add unit tests. Fix bugs in stk_distrib_*_ei functions. * misc/distrib/stk_distrib_normal_ei.m: Fix bug (input argument "minimize" was not properly taken into account). * misc/distrib/stk_distrib_student_ei.m: Fix bug (input argument "minimize" was not properly taken into account). 2015-02-21 Julien Bect Optimize for speed * misc/distrib/stk_distrib_normal_cdf.m: Optimize for speed * covfcs/stk_gausscov_aniso.m: Optimize for speed * covfcs/stk_materncov32_aniso.m: Optimize for speed * covfcs/stk_materncov52_aniso.m: Optimize for speed * covfcs/stk_materncov_aniso.m: Optimize for speed 2015-02-18 Julien Bect stk_feval.m: Do not return an stk_dataframe object systematically * arrays/generic/stk_feval.m: Return an stk_dataframe object only if the input x itself is an stk_dataframe object. Optimize for speed (and fix a tiny bug) * arrays/@stk_dataframe/stk_dataframe.m: Optimize for speed * arrays/@stk_dataframe/set.m: Optimize for speed (and fix a tiny bug) * arrays/@stk_dataframe/horzcat.m: Optimize for speed * arrays/@stk_dataframe/vertcat.m: Optimize for speed * arrays/@stk_dataframe/subsref.m: Optimize for speed * arrays/generic/stk_feval.m: Optimize for speed 2015-02-17 Julien Bect Initialize model.param with NaNs. * core/stk_model.m: Initialize model.param with NaNs. * core/stk_predict.m: Fix unit tests. * covfcs/stk_discretecov.m: Fix unit tests. * covfcs/stk_gausscov_aniso.m: Fix unit tests. * covfcs/stk_gausscov_iso.m: Fix unit tests. * covfcs/stk_materncov32_aniso.m: Fix unit tests. * covfcs/stk_materncov32_iso.m: Fix unit tests. * covfcs/stk_materncov52_aniso.m: Fix unit tests. * covfcs/stk_materncov52_iso.m: Fix unit tests. * covfcs/stk_materncov_aniso.m: Fix unit tests. * covfcs/stk_materncov_iso.m: Fix unit tests. * utils/stk_conditioning.m: Fix unit tests. * utils/stk_generate_samplepaths.m: Fix unit tests. 2015-02-11 Julien Bect stk_feval.m: Accept any object that implement feval * arrays/generic/stk_feval.m: Accept any object that implement feval (not just strings and function handles). 2015-02-10 Julien Bect stk_feval.m: Fix backward compatibility issues * arrays/generic/stk_feval.m: Fix backward compatibility issue. Old-style STK structures, where the data is contained in a field named 'a', were not dealt with properly. Add unit test. * core/stk_predict.m: Convert xi to double (same reason). * paramestim/stk_param_estim.m: Convert zi to double (same reason). * arrays/@struct/stk_length.m: New function. 2015-02-09 Julien Bect stk_hrect.m: Provide default constructor * arrays/@stk_hrect/stk_hrect.m: Provide default constructor 2015-02-04 Julien Bect Overload uplus, uminus for stk_dataframe objects. * arrays/@stk_dataframe/uminus.m: Overload uminus. * arrays/@stk_dataframe/uplus.m: Overload uplus. * arrays/@stk_factorialdesign/uminus.m: Overload uminus. stk_feval.m: Accept multivariate outputs (closes #20) * arrays/generic/stk_feval.m: Accept functions with multivariate outputs (i.e., outputs with several columns). Improve the construction of the output dataframe (column names). Add unit tests. stk_feval.m: Fix a bug related to column names * arrays/generic/stk_feval.m: Fix a bug related to column names. 2015-02-03 Julien Bect @stk_dataframe/apply, min, max: Return more than one output argument * arrays/@stk_dataframe/apply.m: Return more than one output argument * arrays/@stk_dataframe/max.m: Return more than one output argument * arrays/@stk_dataframe/min.m: Return more than one output argument stk_param_relik.m: Improve the computation of G = W' * K * W * paramestim/stk_param_relik.m: Compute G = W' * K * W in such a way that the result is always (?) symmetric. 2015-01-28 Julien Bect stk_predict.m: Compute lambda_mu and RS only when necessary * core/stk_predict.m: Compute lambda_mu and RS only when necessary, depending on the number of output arguments. Add unit tests. stk_param_init.m: Handle the heteroscedastic case * paramestim/stk_param_init.m: Handle the heteroscedastic case with known variance properly. Error in the heteroscedastic case with unknown variance. Add unit tests. 2015-01-27 Julien Bect stk_param_init.m: Fix a bug. * paramestim/stk_param_init.m (paraminit_): Fix a bug. 2015-01-25 Julien Bect stk_dataframe.m: Make sure that the output is an stk_dataframe * arrays/@stk_dataframe/stk_dataframe.m: Make sure that the output is an stk_dataframe object. Add unit tests. 2015-01-24 Julien Bect Overload a few base functions for stk_dataframe objects * arrays/@stk_dataframe/sort.m: Overload base function * arrays/@stk_dataframe/mtimes.m: Overload base function 2015-01-23 Julien Bect stk_conditioning.m: Overload for stk_dataframe objects * arrays/@stk_dataframe/stk_conditioning.m: Overload stk_conditioning for stk_dataframe inputs. The output is an stk_dataframe object if either LAMBDA or ZSIM is an stk_dataframe object. * utils/stk_conditioning.m: Do not convert the output into an stk_dataframe object. stk_generate_samplepaths.m: Overload for stk_dataframe objects * arrays/@stk_dataframe/stk_generate_samplepaths.m: Overload stk_generate_samplepaths for stk_dataframe inputs. The output is always an stk_dataframe object. * utils/stk_generate_samplepaths.m: Simplify the code using the assumption that none of the inputs is an stk_dataframe object. The output is an stk_dataframe object if and only if model.response_name exists and is a non-empty string. 2015-01-21 Julien Bect stk_feval.m: Various improvements. * arrays/generic/stk_feval.m: Update documentation. Try to make the code clearer. Use stk_disp_progress. stk_disp_progress.m: Display a progress indicator. * misc/text/stk_disp_progress.m: New function that displays a textual progress indicator. 2015-01-21 Emmanuel Vazquez stk_feval.m: Generalize to the case of a cell array of functions * arrays/generic/stk_feval.m: Generalize to the case of a cell array of functions (ticket #19 closed). 2015-01-08 Julien Bect Improve conditional simulation examples. * examples/01_kriging_basics/stk_example_kb05.m: Add documentation. * examples/01_kriging_basics/stk_example_kb09.m: New example. stk_generate_samplepaths.m: Fix conditioning on noisy observations * utils/stk_generate_samplepaths.m: Fix conditioning on noisy observations, which was not implemented properly until now. stk_conditioning.m: Implement conditioning on noisy observations * utils/stk_conditioning.m: Simulate sample paths conditioned on noisy observations when the additional NOISE_SIM argument is provided. 2015-01-07 Julien Bect stk_generate_samplepaths.m: Do not simulate observation noise. * utils/stk_generate_samplepaths.m: Do not add observation noise to the generated sample paths. This is consistent with stk_predict, which returns posterior variances for the unknown function, not for future noisy observations. 2014-12-31 Julien Bect Accept empty dim in sampling functions. * sampling/stk_sampling_halton_rr2.m: Accept empty dim argument when box is provided, in which case dim is guessed from the dimension of box if provided, and defaults to one otherwise. * sampling/stk_sampling_maximinlhs.m: Idem. * sampling/stk_sampling_olhs.m: Idem. * sampling/stk_sampling_randomlhs.m: Idem. * sampling/stk_sampling_randunif.m: Idem. * sampling/stk_sampling_regulargrid.m: Idem. Use @stk_hrect objects wherever it is useful (work in progress). * examples/01_kriging_basics/stk_example_kb03.m: Use @stk_hrect. * examples/02_design_of_experiments/stk_example_doe03.m: Use @stk_hrect. * misc/test/stk_is_lhs.m: Use @stk_hrect. * paramestim/stk_param_init.m: Use @stk_hrect. * sampling/stk_sampling_halton_rr2.m: Use @stk_hrect. * sampling/stk_sampling_maximinlhs.m: Use @stk_hrect. * sampling/stk_sampling_olhs.m: Use @stk_hrect. * sampling/stk_sampling_randomlhs.m: Use @stk_hrect. * sampling/stk_sampling_randunif.m: Use @stk_hrect. * sampling/stk_sampling_regulargrid.m: Use @stk_hrect. A few additional methods for the @stk_dataframe class. * arrays/@stk_dataframe/diff.m: Overload base function. * arrays/@stk_dataframe/ismember.m: Overload base function. * arrays/@stk_dataframe/xlim.m: Overload base function. * arrays/@stk_dataframe/ylim.m: Overload base function. Overhaul stk_normalize and stk_rescale functions. * arrays/@stk_dataframe/stk_normalize.m: Overhaul. * arrays/@stk_dataframe/stk_rescale.m: Overhaul. * arrays/@stk_factorialdesign/stk_normalize.m: Overhaul. * arrays/@stk_factorialdesign/stk_rescale.m: Overhaul. * arrays/generic/stk_normalize.m: Overhaul. * arrays/generic/stk_rescale.m: Overhaul. stk_boundingbox.m: New function to create bounding boxes. * arrays/generic/stk_boundingbox.m: New function to create bounding boxes as @stk_hrect object. * admin/octpkg/INDEX: Add new functions to the index. New @stk_hrect class to represent hyper-rectangles. * arrays/@stk_hrect/stk_hrect.m: Constructor for the new @stk_hrect class. * arrays/@stk_hrect/axis.m: Overload base function. * arrays/@stk_hrect/disp.m: Overload base function. * arrays/@stk_hrect/display.m: Overload base function. * arrays/@stk_hrect/get.m: Overload base function. * arrays/@stk_hrect/horzcat.m: Overload base function. * arrays/@stk_hrect/ismember.m: Overload base function. * arrays/@stk_hrect/stk_normalize.m: Overload STK function. * arrays/@stk_hrect/stk_rescale.m: Overload STK function * arrays/@stk_hrect/subsasgn.m: Overload base function. * arrays/@stk_hrect/subsref.m: Overload base function. * arrays/@stk_hrect/vertcat.m: Overload base function. * admin/octpkg/INDEX: Add new functions to the index. Improve plot helper functions. * misc/plot/stk_get_axis_arg.m: New function to help handling the options axes argument that most plotting functions have. * misc/plot/stk_xlabel.m: Use stk_get_axis_arg. * misc/plot/stk_ylabel.m: Use stk_get_axis_arg. * misc/plot/stk_zlabel.m: New function, similar to stk_xlabel and stk_ylabel. * misc/options/stk_options_set.m: Add options for stk_zlabel. 2014-12-09 Julien Bect stk_distrib_bivnorm_cdf: Compute bivariate normal probabilities. * misc/distrib/stk_distrib_bivnorm_cdf.m: Compute bivariate normal probabilities (with any means, standard deviations and corrrelation coefficients). Supports broadcasting. Accurate computation of [p, q] even when p or q is close to one. * misc/distrib/private/stk_distrib_bivnorm0_cdf.c: C MEX-file for the computation of standard bivariate probabilities (zero means, unit variances). * admin/octpkg/INDEX: Hide stk_distrib_bivnorm_cdf.m, currently considered as an internal function. * admin/octpkg/Makefile: Add __stk_distrib_bivnorm0_cdf__ to the list of targets. * config/stk_config_makeinfo.m: Add stk_distrib_bivnorm0_cdf. 2014-12-03 Julien Bect stk_sampling_randunif.m: Fix input argument checking. * sampling/stk_sampling_randunif.m: Fix input argument checking. stk_sampling_randunif.m: Accept empty dim when box is provided. * sampling/stk_sampling_randunif.m: Accept empty dim argument when box is provided, in which case dim is guessed from the dimension of box. 2014-11-20 Julien Bect stk_param_estim.m: Provide a value for param0 if needed. * paramestim/stk_param_estim.m: Provide a value for param0 if needed. stk_param_estim.m: Empty is the same as not provided. * paramestim/stk_param_estim.m: Empty is the same as not provided. stk_param_estim.m: Simplify variable names. * paramestim/stk_param_estim.m: Simplify variable names, param0lnv -> lnv0, paramlnvopt -> lnvopt. stk_param_estim.m: Always return something meaningful for lnv. * paramestim/stk_param_estim.m: Always return something meaningful for lnv: when the variance of the noise is not estimated, return model.lognoisevariance. Update the function documentation following this and earlier changes. 2014-11-08 Julien Bect stk_param_estim.m: Estimate lnv if lognoisevariance is nan. * paramestim/stk_param_init_lnv.m: New function that provides a rough estimate of the variance of the noise for a given model. * admin/octpkg/INDEX: Include stk_param_init_lnv.m. * paramestim/stk_param_estim.m: Estimate the variance of the noise if the lognoisevariance field is nan, using as a starting point the value returned by stk_param_init_lnv. * examples/01_kriging_basics/stk_example_kb04.m: Demonstrate how it is possible to estimate the variance of the noise without providing a initial guess for it. 2014-11-06 Julien Bect Handle empty lognoisevariance field as if missing. * core/stk_make_matcov.m: Handle empty lognoisevariance field as if missing. * core/stk_model.m: Idem. * doc/dev/model.texi: Idem. * paramestim/stk_param_estim.m: Idem. * paramestim/stk_param_init.m: Idem. * paramestim/stk_param_relik.m: Idem. 2014-11-03 Julien Bect Add a 'pairwise' argument to stk_noisecov. * covfcs/stk_noisecov.m: Add a 'pairwise' argument. * core/stk_make_matcov.m: Use the new 'pairwise' argument. 2014-11-02 Julien Bect stk_param_init.m: Change the behaviour regarding lnv. * paramestim/stk_param_init.m: defaults to using the input value of model.lognoisevariance if it is not nan, and estimating the variance if it is nan. The meaning of the fifth argument, now called DO_ESTIM_LNV, has also slightly changed: it is used to force or prevent the estimation of the variance of the noise, regardless of the value of model.lognoisevariance. * examples/03_miscellaneous/stk_example_misc03.m: Display the two models that have been used in this example. * doc/dev/model.texi: update accordingly. 2014-10-26 Julien Bect Make lognoisevariance a mandatory field in model structures. * core/stk_model.m: Make lognoisevariance a mandatory field in model structures, with default value -inf. For backward compatibility, stk_discrete_cov models can still be created with model structures that lack a lognoisevariance field. * core/stk_make_matcov.m: For backward compatibility, a lognoisevariance field with value -inf is added if absent. * paramestim/stk_param_estim.m: idem. * paramestim/stk_param_init.m: idem. * paramestim/stk_param_relik.m: idem + remove NOISYOBS variable. * covfcs/stk_discretecov.m: Modify unit test accordingly. * doc/dev/model.texi: Record design notes and ideas about model structures (not meant to be released as a user-level doc). 2014-10-09 Julien Bect Add the Goldstein-Price test function. * examples/test_functions/stk_testfun_goldsteinprice.m: Goldstein-Price test function. 2014-09-29 Julien Bect Polish stk_sprintf_colvect_* functions. * misc/text/stk_sprintf_colvect_fixedpoint.m: Use round instead of floor. Polish formatting. * misc/text/stk_sprintf_colvect_scientific.m: Polish formatting. 2014-09-28 Julien Bect @stk_dataframe/plot.m: Fix two problems. * arrays/@stk_dataframe/plot.m: Fix two problems. stk_config_rmpath.m: Use strrep instead of regexprep. * config/stk_config_rmpath.m: Use strrep instead of regexprep for compatiblity with Octave 3.2.x (see comments inside the file). 2014-09-27 Julien Bect PKG_DEL.m: Use addpath instead of cd. * admin/octpkg/PKG_DEL.m: Use addpath instead of cd. stk_param_getdefaultbounds.m: Avoid -Inf in default bounds. * paramestim/stk_param_getdefaultbounds.m: Avoid -Inf in default bounds. 2014-09-25 Julien Bect Fix a problem related to Octave 3.2.x when STK is used as a package. * config/stk_config_path.m: Add private folder to the path in Octave 3.2.x even when STK is used as a package. Fix a problem with @stk_factorialdesign/fieldnames.m. * arrays/@stk_factorialdesign/fieldnames.m: Concatenate cell arrays of strings, but not a string with a cell array of strings since the latter syntax is not supported in Octave 3.2.x. Add @stk_factorialdesign/private to the path when using Octave 3.2.x. * config/stk_config_path.m: Add @stk_factorialdesign/private to the path when using Octave 3.2.x. 2014-09-22 Julien Bect Robustify a private function. * arrays/@stk_factorialdesign/private/plot_surfmeshcontour.m: Make the function work with old versions of octave where, for some plotting functions (e.g., pcolor in Octave 3.6.4) the full syntax with axes handle and parameter/value pairs is not supported. Make stk_config_rmpath work on Windows systems. * config/stk_config_rmpath.m: Make stk_config_rmpath work on Windows systems (pathsep must be used instead of ':' since ':' is not the path separator for Windows...). 2014-09-20 Julien Bect Provide a replacement for missing isrow. * misc/mole/isrow/isrow.m: Replacement for isrow. * config/stk_config_mole.m: Add our isrow function to the path if necessary (e.g., Matlab R2007a). Fix a tiny bug in stk_param_estim. * paramestim/stk_param_estim.m: Use strcmpi instead of strcmp to compare err.identifier to 'matlab:optimset:invalidparamname' on line 167. I wonder if this line has ever worked properly... (only affects old releases of Matlab, e.g.,R2007a). Don't use ~ to ignore arguments. * admin/build_tools/build_octpkg.m: Don't use ~ to ignore arguments. * utils/stk_generate_samplepaths.m: Don't use ~ to ignore arguments. 2014-09-15 Julien Bect stk_param_relik.m: Optimize the case of simple kriging. * paramestim/stk_param_relik.m: Optimize the case of simple kriging. 2014-09-09 Paul Feliot doc: Update help text for several functions. * covfcs/stk_materncov32_aniso.m: Update help text. * covfcs/stk_materncov32_iso.m: Update help text. * covfcs/stk_materncov52_aniso.m: Update help text. * covfcs/stk_materncov52_iso.m: Update help text. * covfcs/stk_materncov_aniso.m: Update help text. * covfcs/stk_materncov_iso.m: Update help text. * paramestim/stk_param_init.m: Update help text. 2014-09-02 Julien Bect Rename LICENSE to COPYING. * LICENSE: Renamed to COPYING. * COPYING: Formerly known as LICENSE. * README: Update reference to LICENSE. * admin/build_tools/build_forgedoc.m: No more need to rename. * admin/build_tools/build_octpkg.m: No more need to rename. * admin/find_nonstandard_characters.sh: Update reference to LICENSE. * admin/fix_eol.sh: Update reference to LICENSE. Rename WHATSNEW to NEWS. * NEWS: Formerly known as WHATSNEW. This version is for release 2.1.1 (we still have to update it to 2.2.0). From now on, we will always keep a version of this file in the default branch. * admin/build_tools/build_forgedoc.m: No need to rename WHATSNEW to NEWS anymore. * admin/build_tools/build_octpkg.m: Same thing. 2014-08-20 Julien Bect Add CITATION file. * CITATION: Explain how to cite STK in publications. 2014-08-18 Julien Bect Document stk_length. * arrays/generic/stk_length.m: Add doc. * arrays/@stk_dataframe/stk_length.m: Fix doc. * admin/octave-pkg/INDEX: Un-hide stk_length. 2014-08-17 Julien Bect Deprecate stk_plot2d. * misc/plot/stk_plot2d.m: Deprecated. * arrays/@stk_factorialdesign/contour.m: Overload base function. * arrays/@stk_factorialdesign/mesh.m: Overload base function. * arrays/@stk_factorialdesign/meshc.m: Overload base function. * arrays/@stk_factorialdesign/meshz.m: Overload base function. * arrays/@stk_factorialdesign/pcolor.m: Overload base function. * arrays/@stk_factorialdesign/surf.m: Overload base function. * arrays/@stk_factorialdesign/private/plot_surfmeshcontour.m: Provide a common implementation for overloading surf/contour/... * examples/01_kriging_basics/stk_example_kb03.m: Use contour and pcolor. * examples/03_miscellaneous/stk_example_misc04.m: Use pcolor. * admin/octave-pkg/INDEX: Update with the new functions. Hide stk_plot2d. @stk_dataframe/plot.m: Hold on after the first plot. * arrays/@stk_dataframe/plot.m: Hold on after the first plot, if there are several (fixes a bug introduced yesterday). 2014-08-16 Julien Bect @stk_dataframe/plot.m: Full rewrite again. * arrays/@stk_dataframe/plot.m: Full rewrite again, to improve even more compatibility with the base plot function. The case where x is an stk_dataframe objects with two or more columns is now handled in a way that is consistent with the base plot function (i.e., if x has two columns, then we get two 1D plots). 2014-08-15 Julien Bect stk_plot1d.m: Add missing documentation. * misc/plot/stk_plot1d.m: Add doc. @stk_dataframe/plot.m: Full rewrite. * arrays/@stk_dataframe/plot.m: Full rewrite to improve compatibility with the base plot function. Deprecate the case where x is an stk_dataframe objects with two or more columns. 2014-08-14 Julien Bect Add missing documentations. * arrays/@stk_factorialdesign/ndgrid.m: Add doc. * covfcs/stk_discretecov.m: Add doc. 2014-08-13 Julien Bect Use "z" instead of "x" in all stk_distrib_* functions. * misc/distrib/stk_distrib_normal_cdf.m: Use "z" instead of "x". * misc/distrib/stk_distrib_normal_ei.m: Idem. * misc/distrib/stk_distrib_normal_pdf.m: Idem. * misc/distrib/stk_distrib_student_cdf.m: Idem. * misc/distrib/stk_distrib_student_ei.m: Idem. * misc/distrib/stk_distrib_student_pdf.m: Idem. Provide a documentation for EI functions. * misc/distrib/stk_distrib_normal_ei.m: Add doc. * misc/distrib/stk_distrib_student_ei.m: Add doc. 2014-08-12 Julien Bect Improve Octave packaging. * admin/make_octave_package.m: Delete rename_mex.sed after use. Rename test script. * admin/MAKE_OCTAVE_PACKAGE.md: New doc file (in markdown). * admin/octave-pkg/test_package.m: Renamed to * admin/octave-pkg/pkg_install_stk_and_generate_doc.m: Renamed from. 2014-08-10 Julien Bect stk_example_misc04.m: Fix property name. * examples/03_miscellaneous/stk_example_misc04.m: Fix property name (YTickLabels --> YTickLabel). stk_example_misc04.m: Fix for Octave compatiblity. * examples/03_miscellaneous/stk_example_misc04.m: Fix for Octave compatiblity (stairs does not accept stk_datafrm objects in Octave). 2014-08-08 Julien Bect Fix and improve stk_factorialdesign's accessors. * arrays/@stk_factorialdesign/subsasgn.m: New function. Override stk_dataframe's subsasgn to prevent illegal modifications of stk_factorialdesign objects through ()-type indexing. Any such modification results in an implicit cast to stk_dataframe. * arrays/@stk_factorialdesign/get.m: Provide read-only access to the underlying stk_dataframe object. * arrays/@stk_factorialdesign/set.m: The result is implicitely cast into an stk_dataframe object upon any modification that would otherwise corrupt the internal structure of the stk_factorialdesign object. * arrays/@stk_factorialdesign/fieldnames.m: Add .stk_dataframe. 2014-08-07 Julien Bect Simplify the display of stk_factorialdesign objects. * arrays/@stk_factorialdesign/stk_sprintf.m: Simplify the display of stk_factorialdesign objects by hiding the ".stk_dataframe" level (i.e., .info is used as an aliad for .stk_dataframe.info). * arrays/@stk_dataframe/stk_sprintf.m: Modified (tiny change). Define list of field names for stk_factorialdesign objects. * arrays/@stk_factorialdesign/fieldnames.m: Define list of field names for stk_factorialdesign objects. Fix list of field names for stk_dataframe objects. * arrays/@stk_dataframe/private/reserved_field_names.m: Fix list of field names for stk_dataframe objects. * arrays/@stk_dataframe/fieldnames.m: Update unit test. 2014-07-31 Julien Bect Modify the behaviour of vertcat/horzcat for stk_dataframe objects. * arrays/@stk_dataframe/horzcat.m: Modified. The result is always an stk_dataframe object, and has row names iff either one of the two arguments doesn't have row names, or the row names of both arguments agree. * arrays/@stk_dataframe/vertcat.m: Similar changes. Modify the behaviour of bsxfun for stk_dataframe objects. * arrays/@stk_dataframe/bsxfun.m: Modified. The result is always an stk_dataframe object, and has column names iff either one of the two arguments doesn't have columns names or the columns names of both arguments agree. * arrays/@stk_factorialdesign/stk_factorialdesign.m: Modified unit test. * arrays/@stk_dataframe/abs.m: Overload abs for stk_dataframe object. This allows to write abs (x) instead of abs (double (x)) or abs (x.data). 2014-07-24 Julien Bect Accept invRho = 0 in anisotropic covariance functions. * covfcs/stk_gausscov_aniso.m: Accept invRho = 0. * covfcs/stk_materncov32_aniso.m: Idem. * covfcs/stk_materncov52_aniso.m: Idem. * covfcs/stk_materncov_aniso.m: Idem. stk_sprintf_colvect_scientific.m: Fix a bug. * misc/text/stk_sprintf_colvect_scientific.m: Fix a bu related to rounding numbers such as 9.99e02 (which were displayed as 10e+02 instead of 1e+03). * arrays/@stk_dataframe/stk_sprintf.m: Set default width to 8. * misc/text/stk_sprintf_colvect.m: Idem. * misc/text/stk_sprintf_colvect_fixedpoint.m: Idem. 2014-07-23 Julien Bect stk_param_estim.m: Warn about constant-response data. * paramestim/stk_param_estim.m: Warn about constant-response data. 2014-07-22 Julien Bect stk_param_init.m: Warn about constant-response data. * paramestim/stk_param_init.m: Warn about constant-response data. stk_param_relik.m: Check symmetry of G = W' * K * W. * paramestim/stk_param_relik.m: Check if G = W' * K * W and apply a naive fix if it is not (+ emit a warning). * config/stk_config_setup.m: Do not display the new warning. * core/stk_cholcov.m: Only issue one warning if using epsi. Improve the implementation of stk_dataframe objects display. * arrays/@stk_dataframe/disp.m: Modified. * arrays/@stk_dataframe/display.m: Modified. * arrays/@stk_factorialdesign/stk_sprintf_levels.m: Modified. * arrays/@stk_dataframe/stk_sprintf.m: New function. * arrays/@stk_factorialdesign/stk_sprintf.m: New function. * arrays/generic/stk_sprintf.m: New function. * arrays/@stk_dataframe/stk_sprintf_data.m: Removed. * arrays/@stk_factorialdesign/disp.m: Removed. * arrays/generic/stk_sprintf_data.m: Removed. Implement stk_sprintf_sizetype for cell arrays. * arrays/@cell/stk_sprintf_sizetype.m: Implement stk_sprintf_sizetype for cell arrays. * arrays/@stk_dataframe/stk_sprintf_sizetype.m: Minor formatting change in the output string (remove spaces). * arrays/generic/stk_sprintf_sizetype.m: Idem. 2014-07-21 Julien Bect stk_config_buildmex.m: Run silently when doing nothing. * config/stk_config_buildmex.m: Run silently when doing nothing. Remove page_screen_output (not needed anymore). * misc/mole/matlab/page_screen_output.m: Deleted (not needed anymore). Stop bothering users at startup. * stk_init.m: Stop bothering users at startup with information that they can find in the README file anyway. Don't display selected optimizers at startup. * misc/optim/stk_select_optimizer.m: Don't display selected optimizers when called without input arguments (typically, during startup). 2014-07-20 Julien Bect stk_config_setup.m: Call stk_parallel_engine_set. * config/stk_config_setup.m: Call stk_parallel_engine_set. Get rid of stk_parallel_haspct. * misc/parallel/stk_parallel_haspct.m: Deleted. * admin/octave-pkg/INDEX: Modified. * misc/parallel/stk_parallel_start.m: Modified. stk_config_setup.m: Don't bother checking if the PCT is installed. * config/stk_config_setup.m: in Matlab, don't bother checking if the PCT is installed. 2014-07-19 Julien Bect New example script illustrating random Pareto fronts. * examples/03_miscellaneous/stk_example_misc04.m: New script. 2014-07-18 Julien Bect Add an option to control the verbosity fmincon/fminsearch. * misc/options/stk_options_set.m: Add new option 'optim_display_level' with default value 'off'. * paramestim/stk_param_estim.m: Use the new option. * paramestim/stk_param_init.m: Don't display debugging info. 2014-07-14 Julien Bect stk_plot1d.m: Improved flexibility in argument handling. * misc/plot/stk_plot1d.m: Improved flexibility in the way input arguments are handled. 2014-07-03 Julien Bect Global options to control upper/lower bounds for param estim. * misc/options/stk_options_set.m: Add new options. * paramestim/stk_param_getdefaultbounds.m: Read global options. stk_param_estim.m: Return an additional 'info' structure. * paramestim/stk_param_estim.m: Return an additional 'info' structure, which currently contains the criterion that has been used, the criterion value at the optimum, and the bounds. 2014-07-02 Julien Bect stk_generate_samplepaths.m: Use model.response_name if available. * utils/stk_generate_samplepaths.m: Use model.response_name if available. 2014-07-01 Julien Bect stk_isdominated.m: New function, returns true for dominated rows. * arrays/generic/stk_isdominated.m: New function * arrays/generic/private/stk_isdominated_mex.c: New MEX-function * misc/include/pareto.h: Add new function is_dominated * config/stk_config_makeinfo.m: Compile the new MEX-function * admin/octave-pkg/Makefile: Compile the new MEX-function * arrays/generic/private/stk_paretofind_mex.c: Modified * arrays/generic/stk_paretofind.m: Modified stk_figure.m: Do not set the axis title. * misc/plot/stk_figure.m: Do not set the axis title. stk_plot2d.m: Create labels only if column names are available. * misc/plot/stk_plot2d.m: Create labels only if column names are available. * examples/01_kriging_basics/stk_example_kb03.m: Provide explicit column names for the 2d array used in this script. 2014-06-27 Julien Bect stk_cholcov.m: Prevent infinite while loops. * core/stk_cholcov.m: Prevent infinite while loops, that could occur in the case of matrices that either contained nans or Infs, or were really far from from positive definite. 2014-06-25 Ashwin Ravisankar stk_param_estim.m: Add an optional 'criterion' argument. * paramestim/stk_param_estim.m: added new input argument criterion that will make it possible, in the future, to select which estimation criterion to use. stk_param_relik.m: Add a unit test to check the gradient. * paramestim/stk_param_relik.m: Add a unit test. 2014-06-19 Ashwin Ravisankar stk_param_gls.m: A new function to compute the GLS estimator. * paramestim/stk_param_gls.m: new function * paramestim/stk_param_init.m: modified 2014-06-16 Julien Bect make_octave_package.m: Parse 'Description' field from README. * admin/make_octave_package.m: Modified to parse 'Description' field directly from README (avoids text duplication). * admin/octave-pkg/description.txt: Deleted. 2014-06-15 Julien Bect stk_paretofind.m: New function to find non-dominated points. * arrays/generic/stk_paretofind.m: new function * arrays/generic/private/stk_paretofind_mex.c: new mex-function * misc/include/pareto.h: new C header * config/stk_config_makeinfo.m: modified * config/stk_config_path.m: modified * admin/octave-pkg/Makefile: modified 2014-06-14 Julien Bect README: Include a short description. * README: Include a short description (from description.txt) * admin/octave-pkg/description.txt: Line-wrapping. stk_options_set.m: Add a reset feature. * misc/options/stk_options_set.m: Add a reset feature using a special case when nargin == 1. * misc/options/stk_options_get.m: Just fix spacing. stk_options_set.m: Prevent persistent from being cleared. * misc/options/stk_options_set.m: Add a call to mlock to prevent the persistent variable from being cleared. 2014-05-15 Julien Bect stk_model.m: Fix a fresh bug (my mistake). * core/stk_model.m: Restore proper default behaviour when nargin == 0. Merge /etc into /admin * etc/CODING_GUIDELINES: moved from * admin/CODING_GUIDELINES: moved to * etc/RELEASE_CHECKLIST: moved from * admin/RELEASE_CHECKLIST: moved to + modified * etc/octave-pkg/INDEX: moved from * admin/octave-pkg/INDEX: moved to * etc/octave-pkg/Makefile: moved from * admin/octave-pkg/Makefile: moved to * etc/octave-pkg/PKG_DEL.m: moved from * admin/octave-pkg/PKG_DEL.m: moved to * etc/octave-pkg/pkg_install_stk_and_generate_doc.m: moved from * admin/octave-pkg/pkg_install_stk_and_generate_doc.m: moved to * etc/octave-pkg/post_install.m: moved from * admin/octave-pkg/post_install.m: moved to * admin/description.txt: moved from * admin/octave-pkg/description.txt: moved to * admin/make_octave_package.m: modified * admin/make_release_targz.sh: modified * admin/stk_make_htmldoc.m: modified 2014-05-13 Julien Bect stk_model.m: Accept function handles for covariance_type. * core/stk_model.m: Accept function handles for covariance_type. 2014-05-13 Emmanuel Vazquez Add a stk_length function * arrays/generic/stk_length.m: returns the length of an array * arrays/@stk_dataframe/stk_length.m: idem 2014-05-12 Julien Bect stk_generate_samplepaths.m: Deal with duplicates in xt. * utils/stk_generate_samplepaths.m: Deal with duplicates in xt. 2014-05-08 Julien Bect Move stk_model to core. * core/stk_model.m: formerly known as utils/stk_model.m * utils/stk_model.m: deleted Move utils/arrays one level up. * arrays: formerly known as utils/arrays * utils/arrays: deleted * config/stk_config_makeinfo.m: modified * config/stk_config_path.m: modified 2014-05-07 Julien Bect @stk_dataframe/subsasgn: Solve a problem with Octave 3.2.x * utils/arrays/@stk_dataframe/subsasgn.m: solve a problem with Octave 3.2.x (0x0 stk_dataframe objects). Avoid changing the current dir to make a function available. * misc/test/stk_runtests.m: Avoid changing the current dir to make stk_config_path available. Use addpath/rmpath instead. 2014-05-06 Julien Bect stk_config_path: Fix a private folder problem in Octave 3.2.x * config/stk_config_path.m: Fix a private folder problem in Octave 3.2.x (a new private folder has been recently created). Use horzcat instead of [,]. * lm/@stk_lm_affine/feval.m: modified * lm/@stk_lm_cubic/feval.m: modified * lm/@stk_lm_quadratic/feval.m: modified Change the way the MOLE is installed. * config/stk_config_mole.m: New function, that takes the place of misc/mole/init.m and misc/mole/install_mole_function.m. * misc/mole/init.m: removed * misc/mole/install_mole_function.m: removed * config/stk_config_addpath.m: Modified, to call stk_config_mole, thus avoiding the use of "run" which seems to be causing problems in Octave 3.2.x. * etc/octave-pkg/post_install.m: idem * stk_init.m: idem 2014-04-15 Julien Bect Add an INDEX file to the Octave package. * etc/octave-pkg/INDEX: INDEX file for the Octave package * etc/octave-pkg/pkg_install_stk_and_generate_doc.m: new script to test quickly that the tarball can be installed and to inspect how the corresponding Octave-forge documentation will look. * admin/make_octave_package: copy INDEX to the package. Don't include stk_optim_hasfmincon in the Octave package. * admin/make_octave_package.m: modified Some functions are not part of the public API. * core/ortho_func.m: modified (doc) * core/stk_cholcov.m: modified (doc) * core/@stk_kreq_qr/get.m: modified (doc) * core/@stk_kreq_qr/isequal.m: modified (doc) * core/@stk_kreq_qr/linsolve.m: modified (doc) * core/@stk_kreq_qr/stk_kreq_qr.m: modified (doc) * core/@stk_kreq_qr/stk_set_righthandside.m: modified (doc) * core/@stk_kreq_qr/stk_squared_seminorm.m: modified (doc) * core/@stk_kreq_qr/stk_update.m: modified (doc) * core/@stk_kreq_qr/subsref.m: modified (doc) * misc/dist/stk_gpquadform.m: modified (doc) 2014-04-14 Julien Bect stk_cholcov: new function, chol + regularization noise * core/stk_cholcov.m: New function. * config/stk_config_setup.m: Change the name of a warning. * paramestim/stk_param_init.m: Use stk_colcov instead of chol. * core/@stk_kreq_qr/get.m: Use stk_colcov instead of chol. * paramestim/stk_param_relik.m: Use stk_cholcov. * examples/01_kriging_basics/stk_example_kb07.m: Increase regularity for the forth subplot. Now we can, so why not? * examples/01_kriging_basics/stk_example_kb08.m: Remove FIXME comment. Change subplot titles. * utils/stk_generate_samplepaths.m: Use stk_colcov instead of chol. Remove FIXME comment. Remove observations points from the result when generating conditional sample paths (bugfix). 2014-04-13 Julien Bect Generation of conditioned sample paths made easy (ticket #3). * utils/stk_generate_samplepaths.m: Generate conditioned sample paths if additional (xi, zi) arguments are provided. * examples/01_kriging_basics/stk_example_kb08.m: New example. 2014-04-12 Julien Bect Move stk_feval.m to utils/arrays/generic. * utils/stk_feval.m: moved (from) * utils/arrays/generic/stk_feval.m: moved (to) 2014-04-10 Julien Bect Fix a bug in stk_predict (). * core/stk_predict.m: Fix a bug 2014-04-03 Julien Bect Simplify the code in stk_ortho_func (). * core/stk_ortho_func.m: Call feval (stk_lm_quadratic, x) instead of duplicating the code. And add the cubic case. Add (multivariate) cubic linear models. * lm/@stk_lm_cubic: New class * lm/@stk_lm_cubic/stk_lm_cubic.m: New function (constructor) * lm/@stk_lm_cubic/feval.m: New function 2014-03-31 Julien Bect Introduce a new (experimental) feature: linear models. * core/stk_ortho_func.m: Modified to handle model.order == nan. * paramestim/stk_param_init.m: Modified to handle model.order == nan. * config/stk_config_path.m: Add lm to the path. * lm/@stk_lm_affine/stk_lm_affine.m: New function * lm/@stk_lm_affine/feval.m: New function * lm/@stk_lm_constant/stk_lm_constant.m: New function * lm/@stk_lm_constant/feval.m: New function * lm/@stk_lm_matrix/stk_lm_matrix.m: New function * lm/@stk_lm_matrix/feval.m: New function * lm/@stk_lm_null/stk_lm_null.m: New function * lm/@stk_lm_null/feval.m: New function * lm/@stk_lm_quadratic/stk_lm_quadratic.m: New function * lm/@stk_lm_quadratic/feval.m: New function * examples/03_miscellaneous/stk_example_misc03.m: New example script. 2014-03-29 Julien Bect Do not add config to in the path. * config/stk_config_path.m: Remove config from the list of STK subdirectories to be added to the path. * stk_init.m: Remove config from the path at the end of initialization. * misc/test/stk_runtests.m: Do not assume that config is in the path. 2014-03-26 Julien Bect Rename stk_config_graphicstoolkit tp graphics_toolkit. * config/stk_config_graphicstoolkit.m: Renamed. * misc/mole/graphics_toolkit/graphics_toolkit.m: Formerly known as stk_config_graphicstoolkit. Modified to be a (partial) replacement of the Octave function with the same name. * misc/mole/init.m: Add graphics_toolkit to the path only when needed, i.e., when using Matlab or an old version of Octave. * examples/03_miscellaneous/stk_example_misc02.m: Modified. stk_param_relik: Adding a little bit of noise to help chol succeed. * paramestim/stk_param_relik.m: Add a little bit of noise to help chol succeed, when the first factorization returned by chol is not complete. Emit a warning when doing so. * config/stk_config_setup.m: By default, hide the warning emitted by stk_param_relik. 2014-03-25 Julien Bect stk_config_addpath: Add MOLE subdirectories to the path. * config/stk_config_addpath.m: modified stk_version: Simpler is better. * config/stk_version.m: Moved... * stk_version.m: ...here. STK's version number is now hard-coded in this file, and read from README anymore. * README: Refer to stk_version.m for the version number. * config/stk_config_path.m: Add STK's root to the path unless STK is used as an Octave package. * etc/RELEASE_CHECKLIST: Related changes. stk_config_getroot: Simpler is better. * config/stk_config_getroot.m: Simplify the way we locate STK's root. Use stk_param_relik instead of stk_test as a reference, as stk_test will probably not be included in the Octave package. * admin/make_octave_package.m: Modified. stk_make_htmldoc: Remove dependency on stk_config_getroot. * admin/stk_make_htmldoc.m: modified. stk_param_relik: Improved implementation, or so I hope. * paramestim/stk_param_relik.m: Several modifications, that seem to reduce the number of warnings related to bad conditioning, and also improve the performance for large n (about 1000, say). Fix minor problems in stk_config_rmpath and stk_config_path. * config/stk_config_path.m: modified * config/stk_config_rmpath.m: modified Test examples using stk_runtests instead of stk_runexamples. * examples/01_kriging_basics/stk_example_kb01.m: add %!test * examples/01_kriging_basics/stk_example_kb02.m: add %!test * examples/01_kriging_basics/stk_example_kb03.m: add %!test * examples/01_kriging_basics/stk_example_kb04.m: add %!test * examples/01_kriging_basics/stk_example_kb05.m: add %!test * examples/01_kriging_basics/stk_example_kb06.m: add %!test * examples/01_kriging_basics/stk_example_kb07.m: add %!test * examples/02_design_of_experiments/stk_example_doe01.m: add %!test * examples/02_design_of_experiments/stk_example_doe02.m: add %!test * examples/02_design_of_experiments/stk_example_doe03.m: add %!test * examples/03_miscellaneous/stk_example_misc01.m: add %!test * examples/03_miscellaneous/stk_example_misc02.m: add %!test * misc/test/stk_runexamples.m: removed * misc/test/stk_runscript.m: removed 2014-03-23 Julien Bect Remove stk_init.m from the Octave package. * admin/make_octave_package.m: Create PKG_ADD.m (later renamed to PKG_ADD) by renaming stk_init. Therefore, we don't need the existing PKG_ADD.m anymore. * stk_init.m: Set STK_OCTAVE_PACKAGE to false. * etc/octave-pkg/PKG_ADD.m: Removed. Minor changes in stk_select_optimizer. * misc/optim/stk_select_optimizer.m: Minor changes. 2014-03-21 Julien Bect stk_param_relik: Fix help text. * paramestim/stk_param_relik.m: Fix help text. 2014-03-18 Julien Bect Restore the stk_ prefix for distrib_* functions. * misc/distrib/distrib_normal_cdf.m: renamed (from) * misc/distrib/distrib_normal_ei.m: renamed (from) * misc/distrib/distrib_normal_pdf.m: renamed (from) * misc/distrib/distrib_student_cdf.m: renamed (from) * misc/distrib/distrib_student_ei.m: renamed (from) * misc/distrib/distrib_student_pdf.m: renamed (from) * misc/distrib/stk_distrib_normal_cdf.m: rename (to) * misc/distrib/stk_distrib_normal_ei.m: rename (to) * misc/distrib/stk_distrib_normal_pdf.m: rename (to) * misc/distrib/stk_distrib_student_cdf.m: rename (to) * misc/distrib/stk_distrib_student_ei.m: rename (to) * misc/distrib/stk_distrib_student_pdf.m: rename (to) * examples/02_design_of_experiments/stk_example_doe03.m: modified * misc/distrib/README: modified 2014-03-17 Julien Bect Handle large values of nu better in stk_sf_matern. * misc/specfun/stk_sf_matern.m: Handle large values of nu better. 2014-03-14 Julien Bect Handle Gaussian covariance functions in stk_param_init. * paramestim/stk_param_init.m: Handle Gaussian covariance functions. * paramestim/stk_param_estim.m: Source formatting. 2014-03-14 Julien Bect Handle special cases in stk_sf_matern. * misc/specfun/stk_sf_gausscorr.m: modified * misc/specfun/stk_sf_matern.m: modified * misc/specfun/stk_sf_matern32.m: modified * misc/specfun/stk_sf_matern52.m: modified 2014-02-26 Julien Bect Improve building and Octave packaging. * admin/make_octave_package.m: modified * stk_build.m: renamed... * config/stk_config_buildmex.m: ...to this; modified. * config/stk_config_makeinfo.m: new function * config/stk_config_rmpath.m: modified * config/stk_config_testprivatemex.m: modified * etc/octave-pkg/Makefile: new file * etc/octave-pkg/PKG_ADD.m: modified * etc/octave-pkg/PKG_DEL.m: modified * etc/octave-pkg/pre_install.m: deleted * etc/octave-pkg/post_install.m: new script * stk_init.m: modified Reorganize the MOLE. * misc/mole/PKG_ADD.m: Renamed to init.m * misc/mole/init.m: Renamed from PKG_ADD.m. Add variables MOLE_DO_ADDPATH and MOLE_PRUNE_ADDPATH to control the behaviour of the script. * misc/mole/PKG_DEL.m: Remove (was not needed after all). * etc/octave-pkg/pre_install.m: Call init.m (renamed from PKG_ADD.m) with MOLE_DO_ADDPATH = false and MOLE_PRUNE_ADDPATH = true. Remove call to PKG_DEL.m (was not needed, after all). * misc/mole/README: Bring up to date with the new organization of the MOLE. * misc/mole/common/isoctave.m: Moved to ../isoctave. * misc/mole/isoctave/isoctave.m: Moved from ../common. * misc/mole/install_mole_function.m: Helper function for init.m. * stk_init.m: Modified (call init.m instead of PKG_ADD.m). 2014-02-25 Julien Bect Get rid of ismatlab (). Just use ~ isoctave () instead. * config/stk_config_setup.m: Replace ismatlab -> ~isoctave. * misc/mole/common/ismatlab.m: Removed. Rename graphicstoolkit to stk_config_graphicstoolkit. * misc/mole/common/graphicstoolkit.m: removed * config/stk_config_graphicstoolkit.m: new function (formerly known as graphicstoolkit) * examples/03_miscellaneous/stk_example_misc02.m: modified Rename commonsize () to stk_commonsize (). * misc/mole/common/commonsize.m: renamed to... * utils/arrays/generic/stk_commonsize.m: ...this * misc/distrib/distrib_normal_cdf.m: modified * misc/distrib/distrib_normal_ei.m: modified * misc/distrib/distrib_normal_pdf.m: modified * misc/distrib/distrib_student_cdf.m: modified * misc/distrib/distrib_student_ei.m: modified * misc/distrib/distrib_student_pdf.m: modified * misc/mole/README: modified doc: update some help texts (script names have changed) * paramestim/stk_param_estim.m: fix doc * utils/stk_conditioning.m: fix doc * utils/stk_generate_samplepaths.m: fix doc 2014-02-24 Julien Bect Rewrite Octave packaging script in Octave (instead of Python). * admin/make_octave_package.m: Translation to the Octave langage of make_octave_package.py . Version number now properly set in DESCRIPTION based on the one returned by stk_version (). * admin/make_octave_package.py: deleted Try to solve the problem with MEX-files in private directories. * stk_init.m: Build the MEX-files *before* adding STK's subdirectories to the path. Finger crossed. * stk_build.m: Don't test if MEX-files located in private directories are found (not at this point). * config/stk_config_testprivatemex.m: New function to test if MEX-files located in private directories are found. Add load/unload scripts for the MOLE. * misc/mole/PKG_ADD.m: New initialization script, that adds selected subdirectories of the MOLE to the path. * misc/mole/PKG_DEL.m: Remove MOLE subdirectories from the path. * config/stk_config_path.m: Remove the part that is now handled by the new script (misc/mole/PKG_ADD.m). * etc/octave-pkg/pre_install.m: Run misc/mole/PKG_ADD.m first and PKG_DEL.m at the end (otherwise the load path would contain deleted temp directories after the installation). * stk_init.m: Run misc/mole/PKG_ADD.m first. 2014-02-22 Julien Bect Rewrite stk_config_rmpath without a call to stk_config_path. * config/stk_config_rmpath.m: Rewrite without a call to stk_config_path, in prevision of forthcoming changes. Rewrite stk_config_addpath in a cleaner way. * config/stk_config_addpath.m: Rewrite the function in a cleaner way, without the useless output argument. * config/stk_config_getroot.m: Add an additional output argument, to indicate if STK is present in the path. 2014-02-18 Julien Bect stk_param_getdefaultbounds.m: Handle Gaussian covariance functions. * paramestim/stk_param_getdefaultbounds.m: Handle the case of Gaussian isotropic and anisotropic covariance functions. 2014-02-17 Julien Bect Improve stk_config_getroot. * config/stk_config_getroot.m: Make it work even if STK has not been added to the search path. 2014-02-16 Julien Bect stk_sampling_maximinlhs.m: minor change * stk_sampling_maximinlhs.m (lhsdesign_): No need to check if x is empty since we start the loop at j == 2, now. 2014-02-12 Julien Bect stk_sampling_maximinlhs.m: Do not compute the criterion if niter == 1. * stk_sampling_maximinlhs.m: modified @stk_kreq_qr: heuristic improvement of numerical conditioning. * core/@stk_kreq_qr/private: new folder * core/@stk_kreq_qr/private/compute_P_scaling.m: new function * core/@stk_kreq_qr/stk_update.m: modified * core/@stk_kreq_qr/stk_kreq_qr.m: modified * core/@stk_kreq_qr/stk_set_righthandside.m: modified 2014-02-05 Julien Bect stk_testfun_braninhoo.m: Fix domain bound in the documentation. * examples/test_functions/stk_testfun_braninhoo.m: Fix domain bound in the documentation. 2014-01-17 Julien Bect Fix a bug in stk_param_init. * paramestim/stk_param_init.m: modified 2014-01-16 Julien Bect Add size checks to several functions. * core/stk_predict.m: modified * paramestim/stk_param_init.m: modified * paramestim/stk_param_estim.m: modified 2014-01-15 Julien Bect Warn Octave users about the problem with MEX-files in privates folders. * stk_build.m: modified 2014-01-10 Julien Bect First draft for the automatic generation of an Octave package. * admin/make_octave_package.py: new script * etc/octave-pkg: new folder * etc/octave-pkg/pre_install.m: new function * etc/octave-pkg/PKG_DEL.m: new function * etc/octave-pkg/PKG_ADD.m: new function Create a misc folder for optimization related functions. * misc/optim: new folder * config/stk_select_optimizer.m: moved to misc/optim * config/stk_config_addpath.m: modified Rename stk_configure -> stk_config_setup * misc/stk_configure.m: renamed * misc/stk_config_setup.m: formerly known as stk_configure.m Move 'config' up one level and rewrite part of the configuration system. * config: formerly known as misc/config * config/stk_configure.m: new function * config/stk_config_addpath.m: replacement for stk_set_root.m * config/stk_config_getroot.m: replacement for stk_get_root.m * config/stk_config_path.m: replacement for stk_path.m * config/stk_config_rmpath.m: new function * misc/config: moved to config * misc/config/stk_set_root.m: moved/renamed/modified * misc/config/stk_get_root.m: moved/renamed/modified * misc/config/stk_path.m: moved/renamed/modified * misc/config/stk_configure_octave.m: moved/modified * misc/config/stk_version.m: moved/modified * misc/config/stk_configure_matlab.m: removed/merged in stk_configure * misc/config/stk_configure_octave.m: removed/merged in stk_configure * misc/config/stk_select_optimizer.m: moved * stk_init.m: modified * stk_build.m: modified * misc/test/stk_runexamples.m: modified * misc/test/stk_runtests.m: modified * misc/mole/matlab/page_screen_output.m: new function * admin/stk_make_htmldoc.m: modified Rename stk_compile_all -> stk_build. * config/stk_compile_all.m: moved/renamed * stk_build: formerly known as stk_compile_all.m Rename stk_is_fmincon_available -> stk_optim_hasfmincon. * misc/config/stk_is_fmincon_available.m: moved/renamed * misc/optim/stk_optim_hasfmincon.m: formerly known as stk_is_fmincon_available.m Rename stk_is_pct_installed -> stk_parallel_haspct. * misc/config/stk_is_pct_installed.m: moved/renamed * misc/parallel/stk_parallel_haspct.m: formerly known as stk_is_pct_installed.m Remove obsolete function stk_is_octave_in_use. * misc/config/stk_is_octave_in_use.m: deleted 2014-01-01 Julien Bect stk_init: move some Matlab-specific configuration to a dedicated function. * misc/config/stk_octave_config.m: renamed to stk_configure_octave * misc/config/stk_configure_octave.m: formerly known as stk_octave_config * misc/config/stk_configure_matlab.m: new function * stk_init.m: modified 2013-12-19 Julien Bect Minimalist support for linear indexing on dataframes. * utils/arrays/@stk_dataframe/subsref.m: modified * utils/arrays/@stk_dataframe/subsasgn.m: modified * examples/02_design_of_experiments/stk_example_doe03.m: modified Overload reshape for stk_dataframe objects. * utils/arrays/@stk_dataframe/reshape.m: new function Set row names on the output of stk_generate_samplepaths. * utils/stk_generate_samplepaths.m: modified 2013-12-06 Julien Bect Thicker lines in examples kb01 and kb02. * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified Improve the robustness of @stk_dataframe/set.m. * utils/arrays/@stk_dataframe/subsasgn.m: modified * utils/arrays/@stk_dataframe/set.m: modified Change the behaviour of dataframes without row or column names. * misc/config/stk_compile_all.m: modified * utils/arrays/@stk_dataframe/private/make_numeric_rownames.c: removed * utils/arrays/@stk_dataframe/subsasgn.m: modified * utils/arrays/@stk_dataframe/subsref.m: modified * utils/arrays/generic/stk_sprintf_data.m: modified 2013-12-05 Julien Bect Make stk_dataframe row manipulations faster. * utils/arrays/@stk_dataframe/private/make_numeric_rownames.c: new * utils/arrays/@stk_dataframe/subsref.m: modified * utils/arrays/@stk_dataframe/subsasgn.m: modified * misc/config/stk_compile_all.m: modified * misc/include/stk_mex.h: modified Handle infinities in stk_sprintf_colvect_* functions. * misc/text/stk_sprintf_colvect_fixedpoint.m: modified * misc/text/stk_sprintf_colvect_scientific.m: modified Add an optional max_width argument to @stk_dataframe/disp. * utils/arrays/@stk_dataframe/disp.m: modified 2013-12-03 Julien Bect Fix @stk_kreq_qr/stk_update. Add tests. * core/@stk_kreq_qr/stk_kreq_qr.m: modified * core/@stk_kreq_qr/stk_update.m: modified * misc/test/stk_isequal_tolabs.m: modified 2013-12-02 Julien Bect Remove residual occurences of stk_kriging_equations. * core/@stk_kreq_qr/stk_update.m: modified * misc/benchmarks/stk_benchmark_logdet.m: modified Advertise the mailing-list and the ticket manager on Sourceforge. * stk_init.m: modified * README: modified 2013-12-01 Julien Bect Reorganize the MOLE. Add linsolve only if necessary. * misc/mole/octave: removed * misc/mole/octave/linsolve.m: moved to misc/mole/linsolve * misc/mole/linsolve: new folder * misc/mole/linsolve/linsvoled.m: moved from misc/mole/octave * misc/config/stk_path.m: modified * misc/config/stk_set_root.m: modified Overload isequal for Octave 3.2.4 support. * utils/arrays/@stk_dataframe/isequal.m: new function * core/@stk_kreq_qr/isequal.m: new function * etc/CODING_GUIDELINES: modified 2013-11-30 Julien Bect Fix a bug in stk_octave_config. * misc/config/stk_octave_config.m: modified Reorganize the MOLE for the sake of flexibility. * misc/mole/corr: new folder * misc/mole/corr/corr.m: moved from misc/mole/matlab/stats * misc/mole/quantile: new folder * misc/mole/quantile/quantile.m: moved from misc/mole/matlab/stat * misc/mole/matlab/stats: removed * misc/mole/matlab/stats/quantile.m: moved to misc/mole/quantile * misc/mole/matlab/stats/corr.m: moved to misc/mole/corr * misc/config/stk_path.m: modified 2013-11-29 Julien Bect Add a new function to the MOLE: corr. * misc/mole/matlab/stats/corr.m: new function Move octave_quantile to the MOLE. * misc/stats: removed * misc/stats/octave_quantile.m: removed * misc/mole/matlab/stats: new directory * misc/mole/matlab/stats/quantile.m: formerly known as misc/stats/octave_quantile * utils/arrays/@stk_dataframe/quantile.m: modified * misc/config/stk_path.m: modified Make stk_runexamples fail if at least one example failed. * trunk/misc/test/stk_runexamples.m: modified 2013-11-28 Julien Bect Add a new MOLE function: graphicstoolkit. * misc/mole/matlab/graphics_toolkit.m: removed * misc/mole/common/graphicstoolkit.m: new function * examples/03_miscellaneous/stk_example_misc02: modified 2013-11-25 Julien Bect Use a more conservative form of subplot (without options). * misc/plot/stk_subplot.m: modified Fix a bug in stk_path. * misc/config/stk_path.m: modified 2013-11-24 Julien Bect Fix a typo (missing parenthesis) in stk_rescale. * utils/arrays/generic/stk_rescale.m: modified Fix a copy-paste typo in stk_path. * misc/config/stk_path.m: modified Increase test tolerance. * misc/distrib/distrib_student_cdf.m: modified Provide a replacement for graphics_toolkit in Matlab. * misc/mole/matlab/graphics_toolkit.m: modified Remove the legend in example 'misc02' if using gnuplot. * examples/03_miscellaneous/stk_example_misc02.m: modified Choose a slightly less singular example for 'doe03'. * examples/02_design_of_experiments/stk_example_doe03.m: modified Fix stk_select_optimizer: sqp is in Octave core. * misc/config/stk_select_optimizer.m: modified Add documentation for stk_select_optimizer. * misc/config/stk_select_optimizer.m: modified 2013-11-22 Julien Bect Add a new example. * examples/01_kriging_basics/stk_example_kb07.m: new script 2013-11-19 Julien Bect Change plot options in example 'doe01'. * examples/02_design_of_experiments/stk_example_doe01.m: modified Add a smoke test of all examples. * misc/test/stk_runexamples.m: modified 2013-11-18 Julien Bect Remove TRUE_NOISE_STD in example 'kb03'. * examples/01_kriging_basics/stk_example_kb03.m: modified Use the variance returned by stk_param_init for noiseless data. * examples/01_kriging_basics/stk_example_kb02.m: modified * examples/01_kriging_basics/stk_example_kb03.m: modified 2013-11-15 Julien Bect Remove stk_plot1dsim. * misc/plot/stk_plot1dsim.m: removed * misc/plot/stk_plot1d.m: modified * examples/01_kriging_basics/stk_example_kb05.m: modified 2013-11-14 Julien Bect Rewrite one-line descriptions of all examples. * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified * examples/01_kriging_basics/stk_example_kb03.m: modified * examples/01_kriging_basics/stk_example_kb04.m: modified * examples/01_kriging_basics/stk_example_kb05.m: modified * examples/01_kriging_basics/stk_example_kb06.m: modified * examples/02_design_of_experiments/stk_example_doe01.m: modified * examples/02_design_of_experiments/stk_example_doe02.m: modified * examples/02_design_of_experiments/stk_example_doe03.m: modified * examples/03_miscellaneous/stk_example_misc01.m: modified * examples/03_miscellaneous/stk_example_misc02.m: modified Rewrite the description of example 'kb02'. * examples/01_kriging_basics/stk_example_kb02.m: modified 2013-11-12 Julien Bect Rewrite the description of example 'misc02'. * examples/03_miscellaneous/stk_example_misc02.m: modified 2013-11-11 Julien Bect New functions: stk_axes, stk_subplot, stk_title. * misc/plot/stk_subplot.m: new function * misc/plot/stk_axes.m: new function * misc/plot/stk_title.m: new function * misc/options/stk_options_set.m: modified * misc/plot/stk_figure.m: modified * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified * examples/01_kriging_basics/stk_example_kb03.m: modified * examples/01_kriging_basics/stk_example_kb04.m: modified * examples/01_kriging_basics/stk_example_kb05.m: modified * examples/01_kriging_basics/stk_example_kb06.m: modified * examples/02_design_of_experiments/stk_example_doe01.m: modified * examples/02_design_of_experiments/stk_example_doe02.m: modified * examples/02_design_of_experiments/stk_example_doe03.m: modified * examples/03_miscellaneous/stk_example_misc01.m: modified * examples/03_miscellaneous/stk_example_misc02.m: modified 2013-11-10 Julien Bect Change plot labels in several examples. * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified * examples/01_kriging_basics/stk_example_kb04.m: modified * examples/01_kriging_basics/stk_example_kb05.m: modified New functions to create labels with options. * misc/plot/stk_xlabel.m: new function * misc/plot/stk_ylabel.m: new function * misc/plot/stk_labels.m: new function * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified * examples/01_kriging_basics/stk_example_kb04.m: modified * examples/01_kriging_basics/stk_example_kb05.m: modified * examples/02_design_of_experiments/stk_example_doe03.m: modified * examples/03_miscellaneous/stk_example_misc01.m: modified * examples/03_miscellaneous/stk_example_misc02.m: modified * misc/benchmarks/stk_benchmark_cov2.m: modified * misc/plot/stk_figure.m: modified * misc/plot/stk_plot2d.m: modified * misc/options/stk_options_set.m: modified * utils/arrays/@stk_dataframe/plot.m: modified 2013-11-07 Julien Bect New function to create figures for the examples. * misc/plot/stk_figure.m: new function * misc/options/stk_options_set.m: modified * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified * examples/01_kriging_basics/stk_example_kb03.m: modified * examples/01_kriging_basics/stk_example_kb04.m: modified * examples/01_kriging_basics/stk_example_kb05.m: modified * examples/01_kriging_basics/stk_example_kb06.m: modified * examples/02_design_of_experiments/stk_example_doe01.m: modified * examples/02_design_of_experiments/stk_example_doe02.m: modified * examples/02_design_of_experiments/stk_example_doe03.m: modified * examples/03_miscellaneous/stk_example_misc02.m: modified * examples/03_miscellaneous/stk_example_misc01.m: modified * misc/benchmarks/stk_benchmark_cov2.m: modified Plot directly on the current axes. * misc/plot/stk_plot1d.m: modified * misc/plot/stk_plot1dsim.m: modified Minor changes in stk_plot1dsim. * misc/plot/stk_plot1dsim.m: modified Add figures in example kb05. * examples/01_kriging_basics/stk_example_kb05.m: modified 2013-11-02 Julien Bect Remove example misc01, rename misc02 and misc03. * stk_example_misc01.m: deleted * stk_example_misc02.m: renamed to misc01 * stk_example_misc03.m: renamed to misc02 Add a new example. * examples/01_kriging_basics/stk_example_kb06.m: new script Raise current axis to the top layer in stk_plot_shadedci. * misc/plot/stk_plot_shadedci.m: modified Add the Gaussian correlation to example 'misc02'. * examples/03_miscellaneous/stk_example_misc02.m: modified 2013-11-01 Julien Bect Add Gaussian isotropic and anisotropic covariance functions. * covfcs/stk_gausscov_iso.m: new function * covfcs/stk_gausscov_aniso.m: new function * utils/stk_model.m: modified Add the Gaussian correlation function. * misc/specfun/stk_sf_gausscorr.m: new function Improve the precision of stk_sf_matern around 0 for high nu. * misc/specfun/stk_sf_matern.m: modified 2013-10-29 Julien Bect Remove obsolete references to example01.m * core/stk_predict.m: modified * misc/plot/stk_plot1d.m: modified * examples/01_kriging_basics/stk_example_kb04.m: modified * examples/03_miscellaneous/stk_example_misc01.m: modified 2013-10-28 Julien Bect Rewrite the description of examples 'doe02' and 'doe03'. * examples/02_design_of_experiments/stk_example_doe02.m: modified * examples/02_design_of_experiments/stk_example_doe03.m: modified 2013-10-26 Julien Bect Rewrite example 'doe01'. * examples/02_design_of_experiments/stk_example_doe01.m: modified Add an optional 'box' argument to stk_sampling_halton_rr2. * sampling/stk_sampling_halton_rr2.m: modified Rewrite the description of examples 'kb04' and 'kb05'. * examples/01_kriging_basics/stk_example_kb04.m: modified * examples/01_kriging_basics/stk_example_kb05.m: modified 2013-10-23 Julien Bect Rewrite the description of example 'kb03'. * examples/01_kriging_basics/stk_example_kb03.m: modified 2013-10-20 Julien Bect Fix a bug in stk_predict and add a test. * core/stk_predict.m: modified 2013-10-16 Julien Bect Rewrite the description of example 'kb02'. * examples/01_kriging_basics/stk_example_kb02.m: modified 2013-10-15 Julien Bect Rewrite the description of example 'kb01'. * examples/01_kriging_basics/stk_example_kb01.m: modified Insert an empty line before the example header. * misc/text/stk_disp_examplewelcome.m: modified 2013-10-13 Julien Bect New example script: 1D Bayesian optimization. * examples/02_design_of_experiments/stk_example_doe03.m: new script Display help text when running an example script. * misc/text/stk_disp_examplewelcome.m: modified Restore output verbosity at the end of example scripts. * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified Use input row names for the output of stk_feval. * utils/stk_feval.m: modified Fix a bug in @stk_dataframe/subsref. * utils/arrays/@stk_dataframe/subsref.m: modified 2013-10-12 Julien Bect Fix a bug in stk_dataframe.m and add a copy constructor. * utils/arrays/@stk_dataframe/stk_dataframe.m: modified Provide Gaussian and Student EI functions. * misc/distrib/distrib_student_ei.m: new function * misc/distrib/distrib_normal_ei.m: new function 2013-10-10 Julien Bect distrib_normal_*: return nan for negative standard deviations. * misc/distrib/distrib_normal_pdf.m: modified * misc/distrib/distrib_normal_cdf.m: modified 2013-10-09 Julien Bect Provide a first set of pdf/cdf replacement functions. * misc/distrib: new folder * misc/distrib/README: new text file * misc/distrib/distrib_student_pdf.m: new function * misc/distrib/distrib_normal_pdf.m: new function * misc/distrib/distrib_student_cdf.m: new function * misc/distrib/distrib_normal_cdf.m: new function * misc/config/stk_path.m: modified 2013-10-07 Julien Bect Make commonsize work directly on cell arrays when nargin == 1. * misc/mole/common/commonsize.m: modified 2013-09-27 Julien Bect Make Matlab/Octave compatibility easier to achieve. * misc/mole: new folder * misc/mole/README: new text file * misc/mole/common: new folder * misc/mole/common/commonsize.m: new function * misc/mole/common/ismatlab.m: new function * misc/mole/common/isoctave.m: new function * misc/mole/matlab: new folder * misc/mole/matlab/file_in_path.m: moved form misc/matlab * misc/mole/matlab/file_in_loadpath.m: moved form misc/matlab * misc/mole/matlab/stdout.m: moved form misc/matlab * misc/mole/matlab/index.m: moved form misc/matlab * misc/mole/matlab/fflush.m: moved form misc/matlab * misc/matlab: deleted * misc/mole/octave: new folder * misc/mole/octave/linsolve.m: new function * stk_init.m: modified * admin/stk_make_htmldoc.m: modified * core/@stk_kreq_qr/linsolve.m: modified * misc/test/stk_test.m: modified * misc/test/stk_runscript.m: modified * misc/config/stk_select_optimizer.m: modified * misc/config/stk_path.m: modified * misc/config/stk_octave_config.m: modified * misc/config/stk_is_octave_in_use.m: modified 2013-09-19 Julien Bect Fix a bug in stk_predict. * core/stk_predict.m: modified 2013-09-18 Julien Bect Fix a bug in stk_sampling_olhs. * sampling/stk_sampling_olhs.m: modified Add new criterions for the design of computer experiments. * misc/design: new folder * misc/design/stk_phipcrit.m: new function * misc/design/stk_maxabscorr.m: new function * misc/config/stk_path.m: modified 2013-09-13 Julien Bect New approach for the encapsulation of QR-based kriging computations. * core/@stk_kriging_equation: removed * core/@stk_kreq_qr: new class * core/stk_predict.m: modified 2013-09-13 Emmanuel Vazquez Switch to verbose display mode for examples kb01 and kb02. * examples/01_kriging_basics/stk_example_kb01.m: modified * examples/01_kriging_basics/stk_example_kb02.m: modified 2013-09-12 Julien Bect Control the verbosity of display for dataframe objects. * misc/options/stk_options_set.m: modified * utils/arrays/@stk_factorialdesign/disp.m: modified * utils/arrays/@stk_dataframe/disp.m: modified * utils/arrays/@stk_dataframe/display.m: modified * stk_init.m: modified Display row and column names between simple quotes. * utils/arrays/@stk_dataframe/stk_sprintf_colnames.m: modified * utils/arrays/@stk_dataframe/stk_sprintf_rownames.m: modified stk_param_estim.m: Fix a stupid bug. * paramestim/stk_param_estim.m: modified Reorganize folders. * utils/arrays: new folder * utils/arrays/generic: new folder * utils/@stk_dataframe: moved to utils/arrays * utils/@stk_factorialdesign: moved to utils/arrays * utils/@struct: moved to utils/arrays * misc/text/stk_sprintf_data.m: moved to utils/arrays/generic * misc/text/stk_sprintf_rownames.m: moved to utils/arrays/generic * misc/text/stk_sprintf_info.m: moved to utils/arrays/generic * misc/text/stk_sprintf_sizetype.m: moved to utils/arrays/generic * misc/text/stk_sprintf_colnames.m: moved to utils/arrays/generic * utils/stk_rescale.m: moved to utils/arrays/generic * utils/stk_normalize.m: moved to utils/arrays/generic * misc/config/stk_path.m: modified * misc/config/stk_compile_all.m: modified Fill .info field after the construction of a dataframe. * core/stk_predict.m: modified * core/@stk_kriging_equation/stk_predict.m: modified * utils/stk_feval.m: modified * sampling/stk_sampling_olhs.m: modified * sampling/stk_sampling_randunif.m: modified * sampling/stk_sampling_maximinlhs.m: modified * sampling/stk_sampling_halton_rr2.m: modified * sampling/stk_sampling_randomlhs.m: modified 2013-09-11 Julien Bect @stk_dataframe, @stk_factorialdesign: Improve display. * utils/@stk_dataframe/stk_sprintf_info.m: new function * utils/@stk_dataframe/stk_sprintf_data.m: new function * utils/@stk_dataframe/disp.m: modified * utils/@stk_dataframe/stk_sprintf_colnames.m: new function * utils/@stk_dataframe/stk_dataframe.m: modified * utils/@stk_dataframe/stk_sprintf_rownames.m: new function * utils/@stk_dataframe/stk_sprintf_sizetype.m: new function * utils/@stk_factorialdesign/disp.m: new function * utils/@stk_factorialdesign/stk_factorialdesign.m: modified * utils/@stk_factorialdesign/stk_sprintf_levels.m: new function * sampling/stk_sampling_regulargrid.m: modified * misc/text/stk_sprintf_sizetype.m: new function * misc/text/stk_sprintf_rownames.m: new function * misc/text/stk_sprintf_info.m: new function * misc/text/stk_sprintf_colnames.m: new function * misc/text/stk_sprintf_data.m: new function Allow string arguments in stk_isequal_tolabs and stk_isequal_tolrel. * misc/test/stk_isequal_tolrel.m: modified * misc/test/stk_isequal_tolabs.m: modified 2013-09-11 Emmanuel Vazquez @stk_dataframe: Increase display verbosity. * utils/@stk_dataframe/display.m: modified * utils/@stk_dataframe/disp.m: modified @stk_dataframe: Make 'data' available through get/set and dot-indexation. * utils/@stk_dataframe/private/get_column_number.c: modified stk_disp_examplewelcome.m: Define a default welcome message. * misc/text/stk_disp_examplewelcome.m: modified 2013-09-10 Julien Bect Use strtrim instead of deblank + fliplr. * misc/config/stk_version.m: modified (bugfix) * admin/m2html/m2html.m: modified * admin/m2html/private/mfileparse.m: modified Do not display Octave-style unit tests in the HTML documentation. * admin/m2html/m2html.m: modified Clarify author & copyright information in README. * README: modified 2013-09-08 Julien Bect Fix a bug with y-labels (empty legend) in @stk_dataframe/plot. * utils/@stk_dataframe/plot.m: modified Preserve row names when removing rows from a dataframe. * utils/@stk_dataframe/subsref.m: modified * utils/@stk_dataframe/subsasgn.m: modified 2013-09-07 Julien Bect Rename internal field 'vnames' to 'colnames' in @stk_dataframe. * utils/@stk_dataframe/subsasgn.m: modified * utils/@stk_dataframe/stk_dataframe.m: modified * utils/@stk_dataframe/get.m: modified * utils/@stk_dataframe/set.m: modified * utils/@stk_dataframe/disp.m: modified * utils/@stk_dataframe/bsxfun.m: modified * utils/@stk_dataframe/fieldnames.m: modified Return an stk_dataframe when using ()-indexing on an stk_dataframe. * utils/@stk_dataframe/subsref.m: modified * utils/stk_feval.m: modified * utils/@stk_dataframe/subsasgn.m: modified (nothing serious) * utils/@stk_dataframe/end.m: modified (tests) * sampling/stk_sampling_vdc_rr2.m: modified (tests) * sampling/stk_sampling_halton_rr2.m: modified (tests) 2013-09-05 Julien Bect Plot dataframes with two columns or more. * utils/@stk_dataframe/plot.m: modified 2013-09-04 Julien Bect Make @stk_dataframe behave more like matrices wrt row/column deletion. * utils/@stk_dataframe/subsasgn.m: modified Make line lengths equal in README. * README: modified 2013-09-01 Julien Bect Improve Octave 3.2.x compatibility. * utils/@stk_dataframe/max.m: modified * utils/@stk_dataframe/apply.m: modified * utils/@stk_dataframe/display.m: modified * utils/@stk_dataframe/xor.m: modified * utils/@stk_dataframe/disp.m: modified * utils/@stk_dataframe/stk_normalize.m: modified * utils/@stk_dataframe/min.m: modified * utils/@stk_factorialdesign/stk_factorialdesign.m: modified * utils/@stk_factorialdesign/stk_rescale.m: modified * utils/@stk_factorialdesign/stk_normalize.m: modified * misc/config/stk_octave_config.m: modified * misc/stats/octave_quantile.m: modified * misc/test/stk_isequal_tolabs.m: modified * misc/test/stk_test_dfbinaryop.m: modified Provide a quantile function since Matlab (base) does not have it. * misc/stats/octave_quantile.m: new function * utils/@stk_dataframe/quantile.m: modified * misc/config/stk_path.m: modified 2013-08-31 Julien Bect Add return code to several C functions. * sampling/stk_sampling_vdc_rr2.c: modified Remove unused variables in several C functions. * misc/dist/private/stk_dist_pairwise.c: modified * misc/dist/private/stk_gpquadform_pairwise.c: modified * utils/@stk_dataframe/private/get_column_number.c: modified Fix a problem with bsxfun/realpow in Matlab R2007a. * utils/@stk_dataframe/bsxfun.m: modified 2013-08-30 Julien Bect Fix several issues in stk_compile_all. * misc/config/stk_compile_all.m: modified Fix stk_octave_config to make it work in Octave 3.4.3. * misc/config/stk_octave_config.m: modified Rename stk_remlqrg to stk_param_relik. * paramestim/stk_param_relik.m: formerly known as stk_remlgrg.m * paramestim/stk_remlqrg.m: removed * paramestim/stk_param_init.m: modified * paramestim/stk_param_estim.m: modified Add new function that returns STK's version number. * misc/config/stk_version.m: new function. 2013-08-29 Julien Bect Use new covariance type 'stk_discretecov' instead of Kx_cache/Px_cache. * covfcs/stk_discretecov.m: new function. * core/@stk_kriging_equation/stk_predict.m: modified. * core/stk_ortho_func.m: modified. * core/stk_make_matcov.m: modified. * core/stk_predict.m: modified. * utils/stk_model.m: modified. Rewrite stk_noisecov for clarity. * covfcs/stk_noisecov.m: modified. 2013-08-28 Julien Bect Disable a warning in stk_predict. * stk_init.m: modified. Add checklist for creating releases. * etc/RELEASE_CHECKLIST: new text file. Add file AUTHORS (list of all contributors). * AUTHORS: new text file. Add admin script to find non-standard characters. * admin/findNonStandardCharacters: new bash script. Fix end of lines (use LF). * admin/fixEOL: new bash script to fix end of lines. * sampling/stk_sampling_vdc_rr2.c: fix EOL. * misc/dist/stk_filldist_exact.m: fix EOL. * misc/config/stk_octave_config.m: fix EOL. * misc/test/stk_runscript.m: fix EOL. 2013-08-27 Julien Bect Fix a test. * core/stk_predict.m: fix a test. 2013-08-22 Julien Bect Provide facilities for computing logdets. * core/@stk_kriging_equation/get.m: new function. * core/@stk_kriging_equation/set.m: new function. * misc/benchmarks/stk_benchmark_logdet.m: new script Prepare for future work on updating kreq objects. * core/@stk_kriging_equation/stk_update.m: new function Implement a greedy evaluation model in @stk_kriging_equation. * core/@stk_kriging_equation/stk_kriging_equation.m: modified. * core/@stk_kriging_equation/private/do_compute.m: new function. * core/@stk_kriging_equation/stk_squared_seminorm.m: new function. * core/@stk_kriging_equation/stk_predict.m: modified. * core/@stk_kriging_equation/get.m: new function. * core/@stk_kriging_equation/set.m: new function. * core/@stk_kriging_equation/linsolve.m: modified. * core/stk_predict.m: modified 2013-08-21 Julien Bect Fix horzcat/vertcat in the stk_dataframe class (Octave only). * utils/@stk_dataframe/vertcat.m: modified. * utils/@stk_dataframe/horzcat.m: modified. Rewrite get/set in the stk_dataframe class. * utils/@stk_dataframe/private/get_column_number.c: new MEX-file. * utils/@stk_dataframe/private/get_column_number.m: its brother. * utils/@stk_dataframe/get.m: new M-file. * utils/@stk_dataframe/set.m: its sister. * misc/config/stk_compile_all.m: modified. * utils/@stk_dataframe/src/get_column_number.h: removed * utils/@stk_dataframe/src/set.c: removed * utils/@stk_dataframe/src/get.c: removed * etc/CODING_GUIDELINES: Explain the rationale for this change. Fix a bug in sampling/stk_sampling_halton_rr2.m (Octave only). * sampling/stk_sampling_halton_rr2.m: modified. Get rid of a nested function in stk_compile_all.m. * misc/config/stk_compile_all.m: remove nested function. * etc/CODING_GUIDELINES: Explain the rationale for this change. Fix a bug in get_column_number.h. * utils/@stk_dataframe/src/get_column_number.h: modified. Get rid of stk_narginchk. * misc/error/stk_narginchk.m: Removed. Update argument checking in all STK functions accordingly. * etc/CODING_GUIDELINES: Explain the rationale for this change. Fix a bug in @stk_kriging_equation/stk_predict.m (nargin values). * core/@stk_kriging_equation/stk_predict.m: modified. 2013-07-22 Julien Bect Add functions to generate RR2-scrambled van der Corput and Halton sequences. Joint work with Alexandra Krauth and Elham Rahali. * sampling/stk_sampling_vdc_rr2.c: New MEX-file. * sampling/stk_sampling_vdc_rr2.m: MEX-file doc + tests. * sampling/stk_sampling_halton_rr2.m: New function. * misc/include/primes.h: New header. * misc/include/stk_mex.h: Modified. * misc/config/stk_compile_all.m: Modified. Fix a test. * core/stk_predict.m: Modified. Fix bugs in approximate comparison functions. * misc/test/stk_isequal_tolabs.m: Modified. * misc/test/stk_isequal_tolrel.m: Modified. 2013-07-18 Julien Bect Fix a minor bug in @stk_dataframe.horzcat. * utils/@stk_dataframe/horzcat.m: Modified. Benchmarks for parallelization. * misc/benchmarks: New folder. * misc/benchmarks/stk_benchmark_cov2.m: New script. * misc/benchmarks/stk_benchmark_cov1.m: New script. Rewrite parallelization of covariance evaluation. * core/private: Removed. * core/stk_make_matcov.m: Modified (much simpler now !) * misc/specfun/stk_sf_matern.m: Modified (parallelized) Add wrapper classes for parallel computation engines. * misc/parallel: New folder. * misc/parallel/@stk_parallel_engine_none: New class. * misc/parallel/@stk_parallel_engine_parfor: New class. * misc/parallel/stk_parallel_cutblocks.m: New function. * misc/parallel/stk_parallel_feval.m: New function. * misc/parallel/stk_parallel_start.m: New function. * misc/parallel/stk_parallel_engine_set.m: New function. * misc/parallel/stk_parallel_engine_get.m: New function. * misc/parallel/stk_parallel_stop.m: New function. * misc/config/stk_path.m: Modified. A new system for managing options. * misc/options: New folder. * misc/options/stk_options_set.m: New function. * misc/options/stk_options_get.m: New function. * misc/config/stk_path.m: Modified. 2013-07-15 Julien Bect Recompile a MEX-file if the source is more recent. * misc/config/stk_compile_all.m: Modified. Add MEX-file for an efficient access to the named properties of an stk_dataframe object. * utils/@stk_dataframe/src: New folder for MEX sources. * utils/@stk_dataframe/src/get.c: New method (source). * utils/@stk_dataframe/src/set.c: New method (source). * utils/@stk_dataframe/src/get_column_number.h: New C header. * misc/config/stk_compile_all.m: Compile get and set. * utils/@stk_factorialdesign/get.m: New method. * utils/@stk_factorialdesign/set.m: New method. * utils/@stk_dataframe/subsasgn.m: Use get/set. * utils/@stk_dataframe/subsref.m: Idem. * utils/@stk_dataframe/ctranspose.m: Idem. * utils/@stk_dataframe/transpose.m: Idem. * utils/@stk_factorialdesign/stk_factorialdesign.m: Idem. * utils/@stk_dataframe/stk_dataframe.m: Idem. * utils/@stk_dataframe/stk_get_rownames.m: Removed. * utils/@stk_dataframe/stk_get_colnames.m: Removed. * utils/@stk_dataframe/stk_set_rownames.m: Removed. * utils/@stk_dataframe/stk_get_colnames.m: Removed * utils/@stk_dataframe/private/get_column_indicator.m: Removed. Create a folder for common include files (*.h). * misc/include: New folder. * misc/include/stk_mex.h: Moved from misc/dist/private/. * misc/config/stk_compile_all.m: Add a -I flag for mex 2013-07-02 Julien Bect Encapsulate kriging equations in a dedicated class (bis). * core/stk_predict.m: Move the rhs loop (and a few other things) to @stk_kriging_equation.stk_predict(). Add tests. * core/@stk_kriging_equation/stk_predict.m: New function. * core/@stk_kriging_equation/linsolve.m: Cast xt to double. * core/@stk_kriging_equation/stk_kriging_equation.m: Cast xi to double. Add a third optional argument: 'xt'. 2013-06-28 Julien Bect Encapsulate kriging equations in a dedicated class. * core/@stk_kriging_equation: A new class that encapsulates the basic linear-algebraic operations related to the kriging equations. Methods: stk_kriging_equation.m, linsolve.m, stk_posterior_matcov.m and subsref.m. * core/stk_predict.m: Use the new class. 2013-06-19 Julien Bect Send a warning when negative variances are set to zero. * core/stk_predict.m: modified. 2013-06-18 Julien Bect Overloaded quantile() function for dataframe objects. * utils/@stk_dataframe/quantile.m: New function. 2013-06-16 Julien Bect Improve backward compatibility. * utils/@stk_dataframe/private/get_column_indicator.m: Return the 'var' field if it exists when 'v' is asked for, and display a warning. Fix a bug in stk_param_getdefaultbounds (not handling .a structures properly). * paramestim/stk_param_getdefaultbounds.m: Cast to double before calling var() to handle legacy .a structure properly. 2013-06-04 Julien Bect Return a dataframe from stk_conditioning(). * utils/stk_conditioning.m: Return a dataframe. Fix a bug in stk_predict (not handling .a structures properly). * core/stk_predict.m: Filter input arguments through double() to handle legacy .a structures properly. Add tests. Fix two bugs related to dataframe indexing. * utils/@stk_dataframe/private/get_column_indicator.m: Fixed. * utils/@stk_dataframe/subsref.m: Add tests. 2013-05-18 Julien Bect Use function name as variable name in stk_feval. * utils/stk_feval.m: Use function name as variable name. Get rid of local variable use_indices in stk_predict. * core/stk_predict.m: Get rid of local variable use_indices. 2013-05-09 Julien Bect Ensure that .a structures are still accepted. * utils/@struct/double.m: new overloaded function that returns the .a field of a structure, assuming it exists. * covfcs/stk_materncov32_aniso.m: add tests. 2013-04-14 Julien Bect Add two new classes: stk_dataframe, stk_factorialdesign * utils/@stk_dataframe: new class * utils/@stk_factorialdesign: new class * utils/stk_datastruct.m: removed (use overloaded double() instead) * misc/test/stk_test_dfbinaryop.m: new function to test binary operations on stk_dataframes objects * stk_sampling_regulargrid.m: modified to return an stk_factorialdesign * *.m: remove all occurences of .a, stk_datastruct, and use the new possibilities provided by the two added classes Return additional arguments from stk_rescale and stk_normalize. * utils/stk_rescale.m, utils/stk_normalize.m: modified to return additional output arguments a and b, such that y = a + b*x Reorganize exisiting text functions and add some new ones. * misc/disp/stk_disp_framedtext.m: removed, superseded by the new function stk_sprintf_framed() * misc/disp/stk_disp_examplewelcome.m: moved to misc/text * misc/text/stk_sprintf_colvect.m, stk_sprintf_colvect_fixedpoint.m, stk_sprintf_colvect_scientific.m: new functions * misc/test/stk_runexamples.m: modified * misc/config/stk_path.m: modified 2013-03-25 Julien Bect Make stk_test() silent as a grave. * misc/test/stk_test.m: Use evalc() instead of eval() to make stk_test() silent as a grave. Only works in Matlab for the time being, since evalc() is still unimplemented in Octave. 2013-03-20 Julien Bect Improve stk_runtests(). * misc/test/stk_runtests.m: Include class directories and private directories in the total number of directories. Silence warnings and display something if there were warnings during the tests. 2013-03-17 Julien Bect New function stk_param_getdefaultbounds(). * paramestim/stk_param_estim.m: Remove internal function get_default_bounds() and call stk_param_getdefaultbounds() instead. * paramestim/stk_param_getdefaultbounds.m: New function to be used instead of the internal function get_default_bounds() in stk_param_estim.m. This function can be overloaded for parameters objects. In stk_param_estim(), cast param0 to the appropriate type. * paramestim/stk_param_estim.m: Cast param0 into an object of the appropriate type and size and set model.param to the same value. Add local variables delta_p and delta_lnv in stk_remlqrg(). * paramestim/stk_remlqrg.m: Add local variables for (slightly) improved readability and efficiency. Modify stk_remlqrg() to support objects in model.param. * paramestim/stk_remlqrg.m: Ensure that param is a column vector; in the case where model.param is an object, this is actually a call to subsasgn() in disguise. 2013-03-16 Julien Bect Fix a (recently introduced...) bug in stk_param_init(). * paramestim/stk_param_init.m: Use log10() when calling logspace(). Add a non-regression test. Avoid unnecessary gradient computation in stk_param_estim(). * paramestim/stk_param_estim.m: Compute the gradient only when it is explicitely requested, both in f_() and in f_with_noise_(). 2013-03-14 Julien Bect Add a warning in stk_param_init() when lognoisevariance is defined. * paramestim/stk_param_init.m: Issue a warning if there is a non-empty lognoisevariance field, since its value won't be used. Fix other bugs in stk_param_init(). * paramestim/stk_param_init.m: Remove the second normalization that was performed in the internal function paraminit_(). Use the correct box diameter to choose the list of range values for isotropic covariance functions. 2013-03-13 Julien Bect Fix a bug in stk_param_init(). * paramestim/stk_param_init.m: Remove the value of the regularity parameter from param for stk_matercov32_iso and stk_materncov52_iso covariance functions. Avoid the use of 'stable' with unique(). * misc/dist/stk_filldist_exact.m: Avoid the use of 'stable' with unique() since Octave doesn't currently support it (and we don't really need it, anyway, or so it seems). 2013-03-12 Julien Bect Check the size of 'box' in stk_normalize. * utils/stk_normalize.m: Check the size of 'box' before using it. Raise an error if it's not [2 d]. Return empty from stk_param_estim when lnv is not estimated. * paramestim/stk_param_estim.m: Return empty for the second output argument when lognoisevariance is not estimated (to avoid warnings about output arguments not being assigned). 2013-02-27 Julien Bect Add function stk_gpquadform() to compute Gibbs-Paciorek quadratic forms. * misc/dist/stk_gpquadform.m: New function to compute Gibbs-Paciorek quadratic forms. * misc/dist/private/stk_gpquadform_pairwise.c, misc/dist/private/stk_gpquadform_matrixx.c, misc/dist/private/stk_gpquadform_matrixy.c: C sources for the fast computation of stk_quadform() in several special cases. * misc/config/stk_compile_all.m: Compile the new MEX-files. 2013-02-26 Julien Bect Prepare stk_param_estim for parameter objects (instead of vectors). * paramestim/stk_param_estim.m: Prepare for parameter objects. Rename the optimized vector for 'param' to 'u' for clarity (since it is sometimes an extended parameter vector). 2013-02-10 Julien Bect Fix and improve stk_datastruct(). * utils/stk_datastruct.m: Call inputname correctly, with an input argument. Return an empty data structure when nargin == 0. Add some tests. 2013-02-04 Julien Bect Implement the NOLHS construction of Cioppa & Luca (2007). * sampling/stk_sampling_olhs.m: The function now has an additional hidden option to trigger the construction of an extended (N)OLHS following the paper by Cioppa & Lucs (Technometrics, 2007). Fixed a bug in stk_rescale() and added regression tests. * utils/stk_rescale.m: Fixed a bug in the first part of the function (i.e., the part where the data is scaled from its original box to [0; 1]^d). Added some regression tests. 2013-01-21 Julien Bect Modified stk_set_root() to avoid the use of a persistent variable. * misc/config/stk_set_root.m: modified. The use of a persistent variable was failing to play its intended role when switching from one version of STK to another. The root folder is now detected using which('stk_test'). 2013-01-20 Julien Bect Fixed a test in stk_filldist(). * misc/dist/stk_filldist.m: modified test. Added a tolerance in a comparison; otherwise the test was failing from time to time because of numerical errors. 2013-01-19 Julien Bect Added a DoE example (sequential space-filling). * examples/02_design_of_experiments/stk_example_doe02.m: new script. Fixed a numerical issue in stk_filldist_exact(). * misc/dist/stk_filldist_exact.m: modified. Because of possible numerical inaccuracies, centers that are slightly outside the box must also be considered as candidates for being ymax. Fixed a bug in stk_filldist(). * misc/dist/stk_filldist.m: modified. Fixed a bug in the discretized case (the second output argument was the index of ymax instead of ymax itself, as advertised by the documentation). Added tests to all fill distance-related functions. * misc/dist/stk_filldist_exact.m: added tests. * misc/dist/stk_filldist_discretized.m: added tests. * misc/dist/stk_filldist.m: added tests. Added a second output argument to stk_filldist_discretized(). * misc/dist/stk_filldist_discretized.m: modified. The function now returns, as a second output argument, the point where the maximum distance is attained, as expected by stk_filldist(). 2013-01-17 Julien Bect Completed the documentation of stk_fill_dist and stk_filldist_discretized. * misc/dist/stk_filldist.m: modified (doc) * misc/dist/stk_filldist_discretized.m: modified (doc) 2013-01-14 Julien Bect Completed the documentation of stk_filldist_exact. * stk_filldist_exact.m: modified (documentation) Added a test in stk_filldist. * stk_filldist.m: modified (tests) 2013-01-13 Julien Bect Ensured that all misc/dist functions accept ".a" structures. * misc/dist/stk_dist.m: modified * misc/dist/stk_mindist.m: modified * misc/dist/stk_filldist.m: modified * misc/dist/stk_filldist_discretized.m: modified * misc/dist/private/stk_mindist.c: renamed * misc/dist/private/stk_filldist_discretized.c: renamed Moved misc/dist MEX-files into a private folder. * misc/dist/private: new folder * misc/dist/stk_dist_pairwise.c: moved to misc/dist/private * misc/dist/stk_dist_matrixx.c: idem * misc/dist/stk_dist_matrixy.c: idem * misc/dist/stk_filldist_discretized.c: idem * misc/dist/stk_mindist.c: idem * misc/dist/stk_mex.h: idem * misc/config/stk_path.m: modified * misc/config/stk_compile_all.m: modified Minor change in stk_dist (pairwise case). * misc/dist/stk_dist.m: modified 2013-01-12 Julien Bect Added a function to compute the exact fill distance, based on a paper by Luc Pronzato and Werner G. Müller (Statistics and Computing, 2011). * misc/dist/stk_filldist.m: replaced * misc/dist/stk_filldist_discretized.c: formerly stk_filldist.c * misc/dist/stk_filldist_discretized.m: formerly stk_filldist.m * misc/dist/stk_filldist_exact.m: new * misc/dist/stk_filldist.c: renamed * misc/config/stk_compile_all.m: modified =============================================== === Maintenance branch 1.2.x created here === =============================================== 2013-01-12 Julien Bect Fixed documentation. * misc/dist/stk_dist.m: modified * misc/dist/stk_mindist.m: modified * misc/dist/stk_filldist.m: modified 2013-01-03 Julien Bect Modified stk_makedoc to exclude misc/matlab from the generated HTML documentation. * stk_makedoc.m: modified Made stk_narginchk() slightly more efficient. * misc/error/stk_narginchk.m: modified Added the text of the GPLv3 license. * LICENSE: new Removed the NEWS file (to be written after creating the maintenance branch for a new release). * NEWS: removed Restored '.a' outputs for all stk_sampling_* functions and streamlined unit tests for that. * sampling/stk_sampling_olhs.m: modified * sampling/stk_sampling_randunif.m: modified * sampling/stk_sampling_regulargrid.m: modified * sampling/stk_sampling_randomlhs.m: modified * sampling/stk_sampling_maximinlhs.m: modified 2013-01-02 Julien Bect Added a script to generate the HTML documentation. * stk_makedoc.m: new script Fixed a bug in M2HTML (affecting option 'ignoredDir'). * misc/m2html/m2html.m: modified Added M2HTML version 1.5 (by Guillaume Flandin). * misc/m2html: new Removing folder ./htmldoc (to be generated after creating the maintenance branch for a new release). * htmldoc: removed 2012-12-31 Julien Bect Fixing bugs in stk_test() and stk_runtests(). * misc/test/stk_runtests.m: modified * misc/test/stk_test.m: modified 2012-12-16 Julien Bect Modified stk_runtests() to browse through private folders and class(@) folders. * misc/test/stk_runtests.m: modified Fixed a typo. * misc/test/stk_runtests.m: modified 2012-12-14 Benoit Jan Fixed a bug in stk_make_matcov's "parfor" private functions. * core/private/stk_make_matcov_inter_parfor.m: modified * core/private/stk_make_matcov_auto_parfor.m: modified 2012-12-14 Julien Bect Fixing a bug affecting stk_predict() in the 'blocked' case. * core/stk_predict.m: modified 2012-12-07 Julien Bect Minor improvement in stk_runexamples. * misc/test/stk_runexamples.m: modified 2012-12-06 Julien Bect Removed some internal ".a" fields. * core/stk_ortho_func.m: modified * core/stk_make_matcov.m: modified 2012-12-05 Julien Bect Modified stk_predict() to make it work with non-stationary covariance functions. * core/stk_predict.m: modified Added a "pairwise" option to stk_make_matcov(). * core/stk_make_matcov.m: modified 2012-12-04 Julien Bect Added a "pairwise" option to all covariance functions. * covfcs/stk_materncov*.m: modified 2012-12-02 Julien Bect Added a new MEX-file to compute distances "pairwise" (i.e., compute only the diagonal of the full distance matrix). * misc/dist/stk_distance_matrix.c: deleted * misc/dist/stk_mex.h: new C header * misc/dist/stk_dist_matrixx.c: new MEX-file * misc/dist/stk_dist_matrixy.c: new MEX-file * misc/dist/stk_dist_pairwise.c: new MEX-file * misc/config/stk_compile_all.m: modified * misc/dist/stk_mindist.c: modified * misc/dist/stk_filldist.c: modified Renamed stk_distancematrix() to stk_dist(). * misc/dist/stk_distance_matrix.m: renamed * misc/dist/stk_filldist.m: modified * covfcs/stk_materncov*.m: modified All stk_materncov* functions now also accepts simple matrix-type arguments. * covfcs/stk_materncov*.m: modified 2012-12-01 Julien Bect Fixed a typo in the documentation of stk_is_lhs(). * misc/test/stk_is_lhs.m: modified Fixed a bug in stk_runexamples(). * misc/test/stk_runexamples.m: modified 2012-11-29 Julien Bect Modified stk_predict() to return the posterior covariance matrix as a fourth output argument. * core/stk_predict.m: modified 2012-11-26 Julien Bect Modified all stk_sampling* functions to use stk_rescale() and stk_assert_box(). * sampling/stk_sampling_olhs.m: modified * sampling/stk_sampling_randunif.m: modified * sampling/stk_sampling_regulargrid.m: modified * sampling/stk_sampling_randomlhs.m: modified * sampling/stk_sampling_maximinlhs.m: modified Minor improvements in stk_is_lhs(). * misc/test/stk_is_lhs.m: modified Added a new function to rescale data from one box to another. * utils/stk_rescale.m: new function * utils/stk_normalize.m: (slightly) modified Added a new function to check "box" arguments. * misc/error/stk_assert_box.m: new function 2012-11-25 Julien Bect Added a new function to generate OLHSs, following Ye (1998). * sampling/stk_sampling_olhs.m: new function 2012-11-21 Julien Bect Added default values for some input arguments of stk_is_lhs(), and stricter dimension checking. * misc/test/stk_is_lhs.m: modified 2012-11-14 Julien Bect Changed the upper bound on nu in stk_param_estim(). * paramestim/stk_param_estim.m: modified Fixed a bug in stk_param_init(). * paramestim/stk_param_init.m: modified Added a new MEX-file to compute a discretized fill distance. * misc/dist/stk_filldist.c: new MEX-file (source) * misc/dist/stk_filldist.m: new MEX-file (doc + tests) * misc/dist/stk_mindist.m: modified * misc/config/stk_compile_all.m: modified Added a new function to help initialize stk_param_estim(). * paramestim/stk_param_init.m: new function * examples/01_kriging_basics/stk_example_kb02.m: modified * examples/01_kriging_basics/stk_example_kb03.m: modified Added a new function: stk_normalize(). * utils/stk_normalize.m: new function Renamed some internal variables in stk_param_estim(). * paramestim/stk_param_estim.m: modified 2012-11-06 Julien Bect Improved the flexibility of stk_predict() and stk_param_estim(), which are now accepting both matrices and "data structures" (with an 'a' field) as input arguments. * utils/stk_datastruct.m: new function * core/stk_predict.m: modified * paramestim/stk_param_estim.m: modified 2012-11-04 Julien Bect Improved graphical outputs in stk_example_kb03. * examples/01_kriging_basics/stk_example_kb03.m: modified Added a new function stk_plot2d() that serves has a wrapper around {surf|contour|mesh|pcolor}-type functions, to plot data defined over a two-dimensional regular grid. * misc/plot/stk_plot2d.m: new function Modified stk_predict() to avoid returning negative variances. When negative variances are encountered, they are set to zero and a warning is issued. * core/stk_predict.m: modified Modified stk_sampling_regulargrid() to return 'ndgrid-style' coordinate matrices stored in new .coord field. * sampling/stk_sampling_regulargrid.m: modified Improved Octave-specific configuration (GNUTERM=wxt). * misc/config/stk_octave_config.m: modified 2012-11-01 Julien Bect Added a new folder for test functions. * examples/test_functions: new folder * examples/test_functions/stk_testfun_braninhoo.m: new function * misc/config/stk_path.m: modified 2012-10-28 Julien Bect Improved Octave-specific configuration. * stk_init.m: modified * misc/config/stk_octave_config.m: new function * misc/config/stk_check_octave_packages.m: removed * README: modified 2012-10-24 Julien Bect Added a new example to demonstrate the effect of adding a prior on the covariance parameters. * examples/03_miscellaneous/stk_example_misc03.m: new script Added a new function to draw shaded area representing pointwise confidence intervals. * misc/plot/stk_plot_shadedci.m: new function * misc/plot/stk_plot1d.m: modified Added size checking and changed the upper bound for nu in stk_param_estim. * paramestim/stk_param_estim.m: modified Renamed "box" into "BOX" in all example scripts, to avoid conflicts with the box function. * 01_kriging_basics/stk_example_kb01.m: modified * 01_kriging_basics/stk_example_kb02.m: modified * 01_kriging_basics/stk_example_kb04.m: modified * 01_kriging_basics/stk_example_kb05.m: modified * 03_miscellaneous/stk_example_misc01.m: modified 2012-10-22 Julien Bect Improving welcome messages. * misc/disp: new folder * misc/disp/stk_disp_framedtext.m: new function * misc/disp/stk_disp_examplewelcome.m: new function * misc/config/stk_path.m: modified * examples/01_kriging_basics/stk_example_kb*.m: modified * examples/02_design_of_experiments/stk_example_doe01.m: modified * examples/03_miscellaneous/stk_example_misc*.m: modified * misc/test/stk_runexamples.m: modified Moving example scripts to subfolders. * misc/config/stk_path.m: modified * misc/test/stk_runexamples.m: new function * examples/example*.m: moved to a subfolder * examples/run_all_examples: deleted * examples/01_kriging_basics: new folder * examples/02_design_of_experiments: new folder * examples/03_miscellaneous: new folder 2012-09-26 Julien Bect Better initial guess for the log of the noise variance in example08.m (log(eps) wasn't working well with sqp()) * examples/example08.m: modified 2012-09-16 Julien Bect Fixing docs and copyright notices. * misc/dist/stk_mindist.m: doc modified * misc/dist/stk_distance_matrix.m: doc modified Fixing bugs in stk_runscript.m and run_all_examples.m * examples/run_all_examples.m: bugfix * misc/test/stk_runscript.m: bugfix 2012-09-08 Julien Bect Adding default bounds for Matern 3/2 covariances. * paramestim/stk_param_estim.m: modified ===================== === Release 1.1 === ===================== 2012-08-28 Emmanuel Vazquez Fixing comments (5/2 -> 3/2). * covfcs/stk_materncov32_aniso.m: doc modified * covfcs/stk_materncov32_iso.m: idem Updating HTML doc. * htmldoc/*: modified 2012-08-17 Julien Bect Preparing for release 1.1: updating copyright notices and copying permission statements, removing trailing white spaces, added a user-level log of changes. * almost-all-files: doc & code formatting modified * NEWS: new file Added a new function (stk_runscript) to solve a problem of inconsistent behaviour of the run function between Matlab and the latest version of Octave (one wants a '.m', the other doesn't). * misc/test/stk_runscript.m: new function * examples/run_all_examples.m: modified Renamed README.txt to README. Added explicit version requirements for GNU Octave (3.2.0) and Matlab (R2007a). * README.txt: renamed and renamed Added tests and a little bit of arg checking. * covfcs/stk_materncov32_aniso.m: tests + arg checking * covfcs/stk_materncov32_iso.m: idem * covfcs/stk_materncov52_aniso.m: idem * covfcs/stk_materncov52_iso.m: idem * covfcs/stk_noisecov.m: idem * covfcs/stk_materncov_aniso.m: idem * covfcs/stk_materncov_iso.m: idem 2012-08-10 Julien Bect Added tests, improved documentation (help, copyright notices, ...). Added a little bit of arg checking in stk_conditioning. * utils/stk_generate_samplepaths.m: tests + doc * utils/stk_feval.m: tests + doc * utils/stk_model.m: source code formatting only * utils/stk_conditioning.m: tests + doc + arg checking * core/stk_ortho_func.m: doc * core/stk_make_matcov.m: doc * core/stk_predict.m: doc * core/private/stk_make_matcov_inter_parfor.m: doc * core/private/stk_make_matcov_auto_parfor.m: doc 2012-08-08 Julien Bect Added a new function for approximate comparisons with an absolute tolerance threshold. * misc/test/stk_isequal_tolabs.m: new function Fixed a bug in stk_isequal_tolrel (the function wasn't working as expected for non-vector arrays) and improved documentation. * misc/test/stk_isequal_tolrel.m: modified Renamed stk_conditionning to stk_conditioning. * utils/stk_conditionning.m: renamed and modified * examples/example05.m: modified accordingly 2012-08-07 Julien Bect Added tests and improved documentation. * misc/specfun/stk_sf_matern.m: tests & doc * misc/specfun/stk_sf_matern32.m: idem * misc/specfun/stk_sf_matern52.m: idem 2012-07-15 Julien Bect Replaced a call to isrow(), which didn't exist in some recent Matlab versions (e.g., R2010b), by a direct call to size(). * misc/matlab/index.m: modified 2012-07-10 Julien Bect Fixed a warning generated by stk_compile_all under Octave. * misc/config/stk_compile_all.m: modified 2012-07-08 Julien Bect Added tests and improved documentation. * sampling/stk_sampling_randunif.m: tests & doc * sampling/stk_sampling_randomlhs.m: idem * sampling/stk_sampling_regulargrid.m: idem * sampling/stk_sampling_maximinlhs.m: idem New function to test the LHS property. * misc/test/stk_is_lhs.m: new function Renamed stk_sampling_cartesiangrid to stk_sampling_regulargrid, and changed the meaning of the first argument for consistency with other stk_sampling_* functions. * sampling/stk_sampling_cartesiangrid.m: renamed and modified * examples/example01.m: modified accordingly * examples/example02.m: idem * examples/example04.m: idem * examples/example05.m: idem * examples/example06.m: idem * examples/example07.m: idem * examples/example08.m: idem * paramestim/stk_param_estim.m: idem * core/stk_predict.m: idem 2012-07-04 Julien Bect Fixed a bug in stk_compile_all() under Octave, related to a strange behaviour of exist(). * misc/config/stk_compile_all.m: bugfix. Improved doc and added tests in several functions. Also, fixed a minor bug in stk_model(). * examples/example07.m: fixed comment * utils/stk_model.m: bugfix + doc + tests * paramestim/stk_remlqrg.m: doc + tests * paramestim/stk_param_estim.m: doc + tests 2012-06-30 Julien Bect Fixed a bug in stk_runtests() under Octave. It is now possible to write "stk_runtests core" from the STK's root, for instance. * misc/test/stk_runtests.m: bugfix. Added a new function for approximate comparisons. * misc/test/stk_isequal_tolrel.m: new function. * core/stk_predict.m: modified test. Miscellaneous. * misc/error/stk_narginchk.m: fixed doc and comments. * core/stk_ortho_func.m: tests. * core/stk_make_matcov.m: idem. 2012-06-29 Julien Bect A first series of Octave-style unit tests. * core/stk_predict.m: modified * sampling/stk_sampling_maximinlhs.m: modified * misc/dist/stk_distance_matrix.m: new function * misc/dist/stk_mindist.m: new function Modified STK's path handling. A separate function stk_path() has been created, since stk_set_root() is no longer the only function that needs it. Also, several new folders have been added to the path. * misc/config/stk_set_root.m: modified * misc/config/stk_path.m: new function Imported and adapted Octave's unit testing functions. * misc/test: new folder * misc/test/stk_test.m: new function * misc/test/stk_runtests.m: new function Removed old test scripts (the tests that they contained are now included as Octave-style unit tests in the M-file themselves). * tests: deleted * tests/test_distance_matrix.m: idem * tests/test_sampling_maximinlhs.m: idem * tests/test_Kx_cache.m: idem * tests/test_mindist.m: idem Added new functions for improved error handling. * misc/error: new folder * misc/error/stk_narginchk.m: new function * misc/error/stk_error.m: new function Added new functions for improved M/O inter-operability. * misc/matlab: new folder * misc/matlab/fflush.m: new function * misc/matlab/file_in_loadpath.m: idem * misc/matlab/file_in_path.m: idem * misc/matlab/index.m: idem * misc/matlab/stdout.m: idem 2012-06-05 Emmanuel Vazquez Changed stk_param_estim to make it possible to estimate noise variance. * examples/example02.m: Bug fix * examples/example08.m: Example added about noise estimation * paramestim/stk_param_estim.m: Modified 2012-06-05 Julien Bect Fixing a bug related to the change of parameter ordering. * tests/test_Kx_cache.m: Changed the position of the 'model' parameter in several function calls. 2012-05-31 Julien Bect Reorganizing folders. * misc/dist: New folder. * misc/dist/stk_mindist.c: Moved from sampling. * misc/dist/stk_distance_matrix.c: Moved from covfcs. * misc/config/stk_set_root.m: Added misc/dist to path. * misc/config/stk_compile_all.m: Changed paths. 2012-05-30 Julien Bect Reorganizing folders. * paramestim: New folder. * paramestim/stk_param_estim.m: Moved from core. * paramestim/stk_remlqrg.m: idem. * misc: New name of the "old" utils folder. * misc/config/stk_set_root.m: Changed path. * utils: New name of the "old" utils/misc folder. * utils/stk_model.m: Moved to utils. * utils/stk_conditionning.m: idem. * utils/stk_generate_samplepaths.m: idem. * stk_init.m: Changed the location of stk_set_root. Miscellaneous changes. * sampling/stk_mindist.c: Fixed a comment. 2012-05-30 Emmanuel Vazquez * almost-all-files: Changed the order of the arguments of the functions that use the structure 'model'. Now, 'model' is always the first argument. Because of this change, it seems better to make the argument 'param' in covariance functions coming in first position too. 2012-05-19 Julien Bect Preparing headers for release 1.1. * almost-all-files: Updated headers (copyright, version). Miscellaneous changes. * core/stk_feval.m: Added optional argument 'progress_msg'. * utils/config/stk_select_optimizer.m: Minor change to avoid systematic checking of which optimizer has to be used (as shown by the comments, this was a mistake...). * examples/example07.m: Fixed doc. 2012-05-02 Julien Bect Improved compatibility with older versions of Matlab. * core/stk_param_estim: Added a try-catch block to catch "invalid parameter" errors generated by optimset(). 2012-04-22 Julien Bect Removed the undue dependency on the 'optim' package under Octave. * utils/config/stk_check_octave_packages.m: Removed dependency. Doc fixing. * README.txt: Fixed doc. * utils/config/stk_check_octave_packages.m: Fixed doc. 2012-04-21 Julien Bect Docs fixing. * core/stk_make_matcov.m: Fixed doc. * core/stk_predict.m: Fixed doc. 2012-02-21 Julien Bect Added a test for presence of GLPK in stk_check_octave_packages(). * utils/config/stk_check_octave_packages.m: Added test. * README.txt: Fixed doc. 2012-02-20 Julien Bect Fixed two bugs in run_all_examples.m. * examples/run_all_examples.m: Two bugfixes + several minor changes. The first bug was related to the try/catch block ("advanced" syntax not supported by Octave, explicitly calling lasterror() is safer). The second bug was related to the possible occurence of errors without an error identifier. Fixed a bug in stk_set_root(). * utils/config/stk_set_root.m: Fixed a bug in stk_set_root() related to the use of rmpath(). This ensures compatibility with Octave 3.0.2. 2012-02-19 Julien Bect Fixed a bug under Octave (use of Matlab-like assert statements). * covfcs/stk_noisecov.m: Replaced Matlab-style assert() statements with explicit calls to error(). Bugfix for compatibility with older versions of Octave---more precisely, of the miscellaneous package. * utils/stk_is_octave_in_use.m: Test for the existence of built-in variable OCTAVE_VERSION to check if running under Octave (instead of calling ver(), which was not working properly with some old versions of the miscellaneous package). * stk_init.m: idem. Miscellaneous changes. * sampling/stk_mindist.c: removed unused variable lambda in stk_mindist.c 2012-02-18 Julien Bect Miscellaneous changes. * tests/test_Kx_cache.m: New script. * core/stk_make_matcov.m: Simplified syntax guessing. 2012-02-17 Emmanuel Vazquez Fixed two bugs related to the use of a "covariance cache": when xi is a vector of indices, xi.a does not exist ! * core/stk_make_matcov.m: Bugfix. * core/stk_predict.m: Bugfix. Renamed fields in "model" structures (covariance_cache to Kx_cache and P0 to Px_cache). * core/stk_ortho_func.m: Renamed variables. * core/stk_make_matcov.m: idem. * core/stk_predict.m: idem. * core/stk_model.m: idem. Miscellaneous changes, mostly doc fixing. * covfcs/stk_materncov_aniso.m: Fixed doc. Renamed a variable. * covfcs/stk_materncov32_aniso.m: idem. * covfcs/stk_materncov52_aniso.m: idem. * examples/example01.m: Fixed doc (SMTK -> STK). * examples/example03.m: idem. 2012-02-12 Julien Bect Added a new function to select an appropriate optimizer in stk_param_estim(). * utils/config/stk_select_optimizer.m: New function. * core/stk_param_estim.m: Modified to use the new function. * stk_init.m: Modified to use the new function. The stk_model() function now provides default parameters for several families of covariance functions. A new field 'dim' has been added to the 'model' structure. * core/stk_model.m: Added default parameters. * examples/example*.m: Modified to use stk_model(). Miscellaneous changes. * utils/config/stk_compile_all.m: Minor change in error messages. 2012-02-11 Julien Bect The 'statistics' packages is no longer required in Octave. * README.txt: Removed dependency. * utils/config/stk_check_octave_packages.m: Removed dependency. 2012-02-08 Julien Bect New MEX-file to compute the mindist criterion. * sampling/stk_mindist.c: New MEX-file. * examples/example04.m: Removed "be patient" message. * sampling/stk_sampling_maximinlhs.m: pdist() -> stk_mindist(). * tests/test_mindist.m: New script. * tests/test_sampling_maximinlhs.m: New script. * utils/config/stk_compile_all.m: Added new MEX to be compiled. New function to generate random Latin Hypercube Samples. * sampling/stk_sampling_randomlhs.m: New function. Miscellaneous changes. * tests/test_distance_matrix.m: Added missing header. 2012-02-07 Julien Bect Improved stk_distance_matrix(). * covfcs/stk_distance_matrix.c: Added a subfunction to handle the "symmetric" case more efficiently. * tests: New directory. * tests/test_distance_matrix.m: New script. Added a 'welcome' message to the examples. * examples/example0?.m: Added a 'welcome' message. * examples/run_all_examples.m: Minor changes. * stk_init.m: Turned output pagination off and disabled verbose help messages in Octave. New covariance function (Matern 3/2). * utils/specfun/stk_sf_matern32.m: New function. * covfcs/stk_materncov32_aniso.m: New function. * covfcs/stk_materncov32_iso.m: New function. * examples/example06.m: Added two subplots. * examples/example07.m: New script. * examples/run_all_examples.m: Increased NB_EXAMPLES. 2012-02-06 Julien Bect Fixing bugs and comments in covariance functions. * covfcs/stk_materncov52_aniso.m: Fixed a bug (an old function name was still used) and some comments. * utils/specfun/stk_sf_matern52.m: Fixed missing abs() in stk_sf_matern52(). The result was wrong for negative arguments. * covfcs/stk_materncov_aniso.m: Fixed comment. * covfcs/stk_materncov_iso.m: Fixed comment. 2012-02-05 Julien Bect New covariance function (Matern 5/2). * utils/specfun/stk_sf_matern52.m: New function. * covfcs/stk_materncov52_aniso.m: New function. * covfcs/stk_materncov52_iso.m: New function. * core/stk_param_estim.m: Added Matern 5/2 to get_default_bounds(). * examples/example06.m: New script. * examples/run_all_examples.m: Increased NB_EXAMPLES. Fixed issues in stk_param_estim.m related to the definition of the search domain and the selection of (constrained/unconstrained) optimizer. * core/stk_param_estim.m: Enlarged the search domain in such a way that param0 is always inside it. Changed the selection of optimizer to use fminsearch when either the upper- or the lower-bound are empty. Moved the definition of the 'options' struct to the Matlab-specific part of the code. Miscellaneous changes. * examples/example02.m: Doc & code formatting. * utils/plot/stk_plot1d.m: Added an optional argument to allow plotting on an existing axis. New directory for special functions (./utils/specfun). * utils/specfun: New directory. * utils/config/stk_set_root.m: Added ./utils/specfun to the path. * covfcs/stk_materncov_.m: Removed. * utils/specfun/stk_sf_matern.m: Replacement for stk_materncov_. * covfcs/stk_materncov_aniso.m: Modified to use stk_sf_matern. * covfcs/stk_materncov_iso.m: Modified to use stk_sf_matern. 2012-02-02 Julien Bect Miscellaneous changes. * README.txt: Improved requirements and recommendations. * core/stk_param_estim.m: Clarified selection of optimizer. Improved handling of Octave packages. * utils/stk_check_octave_packages.m: New function to check for required packages under Octave. * stk_init.m: Added a call to stk_check_octave_packages(). Removed some left-overs from an earlier version of stk_init where fminsearch() was used instead of sqp() under Octave. Moved call to stk_is_fmincon_available() to the Matlab-conditional part. Fixed a parsing problem occuring in Octave 3.4.3 (at least), related to the fact that parfor loops are supposed to end with an "endparfor" instead of a simple "end"... but we don't use "parfor" at all if we are running in Octave. * core/stk_make_matcov.m: Moved some sub-functions to independent M-files stored in a private sub-folder. * core/private: New folder. * core/private/stk_make_matcov_auto_parfor.m: New file (the code in this file was previously part of stk_make_matcov.m). * core/private/stk_make_matcov_inter_parfor.m: New file (the code in this file was previously part of stk_make_matcov.m). 2012-02-01 Julien Bect Minor bugfix + improved error message in stk_remlqrg() * core/stk_remlqrg.m: Minor bugfix: returns nan for the derivative with respect to the noise variance in the case of a model without observation noise. Improved error message if NOISEPRIOR && ~NOISYOBS (doesn't use assert anymore). * core/stk_remlqrg.m: minor bugfix + improved error message in stk_remlqrg() Added a script to run all the examples and report on errors. * examples/run_all_examples.m: new script * examples/example0*.m: remove "clear all; close all;" Improved script stk_init. * utils/config/stk_set_root.m: new function * utils/config/stk_get_root.m: new function * utils/config/stk_compile_all.m: new function * stk_init.m: Modified to use the new functions. Also, added a 'clear' statement for temporary variables STK_ROOT, fmincon_found, octave_in_use, s and ans at the end of the script. Created subdirectories in ./utils. * utils/config: new subdirectory * utils/stk_is_fmincon_available.m: moved to ./utils/config * utils/stk_is_octave_in_use.m: moved to ./utils/config * utils/stk_is_pct_installed.m: moved to ./utils/config * utils/plot: new subdirectory * utils/stk_plot1d.m: moved to ./utils/plot * utils/stk_plot1dsim.m: moved to ./utils/plot Moved stk_feval to ./core (where it should always have been). * utils/stk_feval.m: moved to ./core ===================== === Release 1.0 === ===================== 2011-09-28 Emmanuel Vazquez Initial commit of STK. stk/inst/0000775000175000017500000000000012617165722011263 5ustar bectbectstk/inst/core/0000775000175000017500000000000012617165716012216 5ustar bectbectstk/inst/core/stk_cholcov.m0000664000175000017500000000472512617165716014722 0ustar bectbect% STK_CHOLCOV [STK internal] % % CALL: C = stk_cholcov (A, ...) % % returns the result of chol (A, ...) when this succeeds. If chol fails, % then a small amount of "regularization noise" is added to the diagonal % of A, in order to make chol succeed (see the code for details). % % NOTE: why this function ? % % This is a first (rough) attempt at solving numerical problems that % arise when chol is used with a covariance matrix that is semi-positive % definite, or positive definite with some very small eigenvalues. See % tickets #3, #4 and #13 on Sourceforge: % % https://sourceforge.net/p/kriging/tickets/3/ % https://sourceforge.net/p/kriging/tickets/4/ % https://sourceforge.net/p/kriging/tickets/13/ % % See also: chol % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function C = stk_cholcov (A, varargin) % try to use a plain "chol" [C, p] = chol (A, varargin{:}); if p > 0, epsi = eps; u = diag (diag (A)); while p > 0, if epsi > 1, % avoids infinite while loops if ~ all (isfinite (A(:))) errmsg = 'A contains NaNs or Infs.'; else errmsg = 'A is not even close to positive definite'; end stk_error (errmsg, 'InvalidArgument'); end epsi = epsi * 10; [C, p] = chol (A + epsi * u); end warning ('STK:stk_cholcov:AddingRegularizationNoise', sprintf ... ('Adding a little bit of noise to help chol succeed (epsi = %.2e)', epsi)); end end % function stk_cholcov %#ok<*SPWRN> stk/inst/core/stk_make_matcov.m0000664000175000017500000001045412617165716015547 0ustar bectbect% STK_MAKE_MATCOV computes a covariance matrix (and a design matrix) % % CALL: [K, P] = stk_make_matcov (MODEL, X0) % % computes the covariance matrix K and the design matrix P for the model % MODEL at the set of points X0, which is expected to be an N x DIM % array. As a result, a matrix K of size N x N and a matrix P of size % N x L are obtained, where L is the number of regression functions in % the linear part of the model; e.g., L = 1 if MODEL.order is zero % (ordinary kriging). % % CALL: K = stk_make_matcov (MODEL, X0, X1) % % computes the covariance matrix K for the model MODEL between the sets % of points X0 and X1. The resulting K matrix is of size N0 x N1, where % N0 is the number of rows of XO and N1 the number of rows of X1. % % BE CAREFUL: % % stk_make_matcov (MODEL, X0) and stk_makematcov (MODEL, X0, X0) are NOT % equivalent if model.lognoisevariance > - inf (in the first case, the % noise variance is added on the diagonal of the covariance matrix). % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [K, P] = stk_make_matcov (model, x0, x1, pairwise) % Backward compatiblity: accept model structures with missing lognoisevariance if (~ isfield (model, 'lognoisevariance')) || (isempty (model.lognoisevariance)) model.lognoisevariance = - inf; end %=== process input arguments if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end x0 = double (x0); if (nargin > 2) && (~ isempty (x1)), x1 = double (x1); make_matcov_auto = false; else x1 = x0; make_matcov_auto = true; end pairwise = (nargin > 3) && pairwise; %=== compute the covariance matrix K = feval (model.covariance_type, model.param, x0, x1, -1, pairwise); if make_matcov_auto && (any (model.lognoisevariance ~= -inf)) K = K + stk_noisecov (size (K,1), model.lognoisevariance, -1, pairwise); end %=== compute the regression functions if nargout > 1, P = stk_ortho_func (model, x0); end end % function stk_make_matcov %!shared model, model2, x0, x1, n0, n1, d, Ka, Kb, Kc, Pa, Pb, Pc %! n0 = 20; n1 = 10; d = 4; %! model = stk_model ('stk_materncov52_aniso', d); model.order = 1; %! model.param = log ([1.0; 2.1; 2.2; 2.3; 2.4]); %! model2 = model; model2.lognoisevariance = log(0.01); %! x0 = stk_sampling_randunif (n0, d); %! x1 = stk_sampling_randunif (n1, d); %!error [KK, PP] = stk_make_matcov (); %!error [KK, PP] = stk_make_matcov (model); %!test [Ka, Pa] = stk_make_matcov (model, x0); % (1) %!test [Kb, Pb] = stk_make_matcov (model, x0, x0); % (2) %!test [Kc, Pc] = stk_make_matcov (model, x0, x1); % (3) %!error [KK, PP] = stk_make_matcov (model, x0, x1, pi); %!assert (isequal (size (Ka), [n0 n0])); %!assert (isequal (size (Kb), [n0 n0])); %!assert (isequal (size (Kc), [n0 n1])); %!assert (isequal (size (Pa), [n0 d + 1])); %!assert (isequal (size (Pb), [n0 d + 1])); %!assert (isequal (size (Pc), [n0 d + 1])); % In the noiseless case, (1) and (2) should give the same results %!assert (isequal (Kb, Ka)); % In the noisy case, however... %!test [Ka, Pa] = stk_make_matcov (model2, x0); % (1') %!test [Kb, Pb] = stk_make_matcov (model2, x0, x0); % (2') %!error assert (isequal (Kb, Ka)); % The second output depends on x0 only => should be the same for (1)--(3) %!assert (isequal (Pa, Pb)); %!assert (isequal (Pa, Pc)); stk/inst/core/stk_ortho_func.m0000664000175000017500000001045612617165716015431 0ustar bectbect% STK_ORTHO_FUNC [deprecated] % % CALL: P = stk_ortho_func (MODEL, X) % % computes the design matrix for the linear part of model MODEL at the set of % evaluation points X. In general (see special case below), X is expected to % be a structure, whose field 'a' contains the actual numerical data as an N % x DIM matrix, where N is the number of evaluation points and and DIM the % dimension of the space of factors. A matrix P of size N x L is returned, % where L is the number of regression functions in the linear part of the % model; e.g., L = 1 if MODEL.order is zero (ordinary kriging). % % DEPRECATED: % % At the present time, stk_ortho_func() only handles polynomial regressions, % up to order 3 through the "historical" mechanism based on model.order. % % An experimental mechanisme that uses "linear model" objects is already % available (see the code for details on how to activate this feature). % % stk_orth_func is deprecated and will be removed from future versions of % STK (http://sourceforge.net/p/kriging/tickets/12). % % See also stk_make_matcov % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function P = stk_ortho_func (model, x) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end x = double (x); if strcmp (model.covariance_type, 'stk_discretecov') P = model.param.P(x, :); else if isfield (model, 'lm') %--- BEGIN EXPERIMENTAL FEATURE: linear model ------------------------------------ if ~ isnan (model.order) error ('To use the EXPERIMENTAL "lm" feature, please set model.order to NaN'); end P = feval (model.lm, x); %--- END EXPERIMENTAL FEATURE: linear model -------------------------------------- else P = stk_ortho_func_ (model.order, x); end end end % function stk_ortho_func %%%%%%%%%%%%%%%%%%%%%%% %%% stk_ortho_func_ %%% %%%%%%%%%%%%%%%%%%%%%%% function P = stk_ortho_func_ (order, x) n = size (x, 1); switch order case -1, % 'simple' kriging P = zeros (n, 0); case 0, % 'ordinary' kriging P = ones (n, 1); case 1, % affine trend P = [ones(n, 1) x]; case 2, % quadratic trend P = feval (stk_lm_quadratic, x); case 3, % cubic trend P = feval (stk_lm_cubic, x); otherwise, % syntax error error ('order should be in {-1, 0, 1, 2, 3}'); end end % function stk_ortho_func_ %!shared model, x, n, d %! n = 15; d = 4; %! model = stk_model ('stk_materncov_aniso', d); %! x = stk_sampling_randunif (n, d); %!error P = stk_ortho_func (); %!error P = stk_ortho_func (model); %!test P = stk_ortho_func (model, x); %!error P = stk_ortho_func (model, x, pi); %!test %! model.order = -1; P = stk_ortho_func (model, x); %! assert (isequal (size (P), [n, 0])); %!test %! model.order = 0; P = stk_ortho_func (model, x); %! assert (isequal (size (P), [n, 1])); %!test %! model.order = 1; P = stk_ortho_func (model, x); %! assert (isequal (size (P), [n, d + 1])); %!test %! model.order = 2; P = stk_ortho_func (model, x); %! assert (isequal (size (P), [n, 1 + d * (d + 3) / 2])); %!test %! model.order = 3; P = stk_ortho_func (model, x); %! assert (isequal (size (P), [n, 1 + d * (11 + d * (6 + d)) / 6])); %!error %! model.order = 4; P = stk_ortho_func (model, x); %! % model.order > 3 is not allowed stk/inst/core/@stk_kreq_qr/0000775000175000017500000000000012617165716014643 5ustar bectbectstk/inst/core/@stk_kreq_qr/stk_update.m0000664000175000017500000000532612617165716017172 0ustar bectbect% STK_UPDATE [STK internal] % % CALL: kreq = stk_update (kreq, Kjj, Kji, Pj, Ktj) % % Experimental... % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function kreq = stk_update (kreq, Kjj, Kji, Pj, Ktj) % Poor man's update... % TODO: implement efficient update equations (use qrinsert) LS = kreq.LS_Q * kreq.LS_R; Kii = LS(1:kreq.n, 1:kreq.n); Pi = bsxfun (@rdivide, LS(1:kreq.n, (kreq.n + 1):end), kreq.P_scaling); Kii = [[Kii Kji']; [Kji Kjj]]; Pi = [Pi; Pj]; old_scaling = kreq.P_scaling; kreq.P_scaling = compute_P_scaling (Kii, Pi); Pi = bsxfun (@times, Pi, kreq.P_scaling); LS = [[Kii Pi]; [Pi' zeros(kreq.r)]]; [kreq.LS_Q, kreq.LS_R] = qr (LS); if ~ isempty (kreq.RS) Kti = kreq.RS(1:kreq.n, :)'; Pt = bsxfun (@rdivide, kreq.RS((kreq.n + 1):end, :)', old_scaling); kreq = stk_set_righthandside (kreq, [Kti Ktj], Pt); elseif nargin > 4 stk_error ('Too many input arguments: no RS to update', 'TooManyInputArgs'); end kreq.n = kreq.n + size (Kjj, 1); end % function stk_update %!shared model, x, y %! model = stk_model ('stk_materncov32_iso', 1); %! model.param = log ([1.0; 2.8]); %! x = [1.2; 0.3; -1.9]; %! y = 0.0; %!test %! kreqA = stk_kreq_qr (model, x); %! [Kii, Pi] = stk_make_matcov (model, x); %! kreqB = stk_kreq_qr (model, x(1)); %! kreqB = stk_update (kreqB, Kii(2, 2), Kii(2, 1), Pi(2)); %! kreqB = stk_update (kreqB, Kii(3, 3), Kii(3, [1 2]), Pi(3)); %! assert (stk_isequal_tolabs (kreqA, kreqB, 3 * eps)) %!test %! kreqA = stk_kreq_qr (model, x, y); %! [Kii, Pi] = stk_make_matcov (model, x); %! [Kti, Pt] = stk_make_matcov (model, y, x); %! kreqB = stk_kreq_qr (model, x(1), y); %! kreqB = stk_update (kreqB, Kii(2, 2), Kii(2, 1), Pi(2), Kti(2)); %! kreqB = stk_update (kreqB, Kii(3, 3), Kii(3, [1 2]), Pi(3), Kti(3)); %! assert (stk_isequal_tolabs (kreqA, kreqB, 3 * eps)) stk/inst/core/@stk_kreq_qr/linsolve.m0000664000175000017500000000254312617165716016660 0ustar bectbect% LINSOLVE [STK internal] % % CALL: w = linsolve (kreq, rs) % % Overload base function 'linsolve' for stk_kreq_qr objects. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function w = linsolve (kreq, rs) if nargin < 2, rs = kreq.RS; end % Solves the linear equation A * ws = rs, where A is the kriging matrix w = linsolve (kreq.LS_R, kreq.LS_Q' * rs, struct ('UT', true)); end % function linsolve stk/inst/core/@stk_kreq_qr/isequal.m0000664000175000017500000000226212617165716016466 0ustar bectbect% ISEQUAL [STK internal] % % CALL: b = isequal (x, y) % % Overload base function 'isequal' for stk_kreq_qr objects. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function b = isequal (x, y) b = strcmp (class (x), class (y)) ... && isequal (struct (x), struct (y)); end % function isequal stk/inst/core/@stk_kreq_qr/subsref.m0000664000175000017500000000254612617165716016501 0ustar bectbect% SUBSREF [STK internal] % % CALL: value = subsref (kreq, idx) % % implements 'subsref' for stk_kreq_qr objects. % % See also: subsref % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function value = subsref (kreq, idx) if strcmp (idx(1).type, '.') value = get (kreq, idx(1).subs); if length(idx) > 1, value = subsref(value, idx(2:end)); end else stk_error('Illegal indexing.', 'IllegalIndexing'); end end % function subsref stk/inst/core/@stk_kreq_qr/private/0000775000175000017500000000000012617165716016315 5ustar bectbectstk/inst/core/@stk_kreq_qr/private/compute_P_scaling.m0000664000175000017500000000220612617165716022126 0ustar bectbect% COMPUTE_P_SCALING [STK internal] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Authors: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = compute_P_scaling (Kii, Pi) t = sum (Pi .^ 2); s = ones (1, size (Pi, 2)); s(t > 0) = sqrt ((max (sum (Kii .^ 2))) ./ t(t > 0)); end % function compute_P_scaling stk/inst/core/@stk_kreq_qr/stk_set_righthandside.m0000664000175000017500000000304712617165716021376 0ustar bectbect% STK_SET_RIGHTHANDSIDE [STK internal] % % CALL: kreq = stk_set_righthandside (kreq, Kti, Pt) % % sets the right-hand side for an stk_kreq_qr object. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function kreq = stk_set_righthandside (kreq, Kti, Pt) % This class implements GREEDY EVALUATION: computations are made as soon as the % required inputs are made available. % prepare the right-hand side of the kriging equation Pt = bsxfun (@times, Pt, kreq.P_scaling); kreq.RS = [Kti Pt]'; % Solve the kriging equation to get the extended % kriging weights vector (weights + Lagrange multipliers) kreq.lambda_mu = linsolve (kreq); end % function stk_set_righthandside stk/inst/core/@stk_kreq_qr/get.m0000664000175000017500000001003212617165716015574 0ustar bectbect% GET [STK internal] % % CALL: value = get (kreq, propname) % % implements 'get' for stk_kreq_qr objects. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function value = get (kreq, propname) try % if it's a field in the underlying structure, don't waste time value = kreq.(propname); catch switch propname case 'lambda' value = kreq.lambda_mu(1:kreq.n, :); case 'mu' value = kreq.lambda_mu((kreq.n + 1):end, :); case 'delta_var' value = dot (kreq.lambda_mu, kreq.RS, 1)'; case 'log_abs_det_kriging_matrix' % LS_Q has +/- 1 determinant, so we only need to care about LS_R value = sum (log (abs (diag (kreq.LS_R)))); case 'log_det_covariance_matrix_a' n = kreq.n; Q11 = kreq.LS_Q(1:n, 1:n); R11 = kreq.LS_R(1:n, 1:n); value = log (det (Q11 * R11)); % K = Q11 * R11 % note: this method seems much less accurate than the others, % we strongly recommend to avoid using it case 'log_det_covariance_matrix_b' n = kreq.n; Q11 = kreq.LS_Q(1:n, 1:n); R11 = kreq.LS_R(1:n, 1:n); Kchol = stk_cholcov (Q11 * R11); % K = Q11 * R11 value = 2 * sum (log (diag (Kchol))); case 'log_det_covariance_matrix_c' % note: very efficient (but not the best) and quite simple to understand n = kreq.n; Q11 = kreq.LS_Q(1:n, 1:n); diag_R = diag (kreq.LS_R); logdet1 = log (abs (det (Q11))); logdet2 = sum (log (abs (diag_R(1:n)))); value = logdet1 + logdet2; case {'log_det_covariance_matrix', 'log_det_covariance_matrix_d'} % note: this is the fastest of all five solutions for large matrices % (for small matrices, the difference is negligible)... but also % the trickiest ! n = kreq.n; QL = kreq.LS_Q((n + 1):end, :); % lowerpart of LS_Q diag_R = diag (kreq.LS_R); logdet1 = sum (log (abs (diag_R))); T = kreq.LS_R \ (QL'); logdet2 = log (abs (det (T((n + 1):end, :)))); value = logdet1 + logdet2; case 'log_det_covariance_matrix_e' % note: the most time consuming of all five solutions (blame qrdelete), % we strongly recommend to avoid using it n = kreq.n; r = kreq.r; Q = kreq.LS_Q; R = kreq.LS_R; for i = 0:(r - 1), [Q, R] = qrdelete (Q, R, n + r - i, 'row'); [Q, R] = qrdelete (Q, R, n + r - i, 'col'); end value = sum (log (abs (diag (R)))); otherwise error ('There is no property called ''%s''.', propname); end % switch end % try_catch end % function get %#ok<*CTCH> stk/inst/core/@stk_kreq_qr/stk_kreq_qr.m0000664000175000017500000000343312617165716017351 0ustar bectbect% STK_KREQ_QR [STK internal] % % CALL: kreq = stk_kreq_qr (model, xi, xt) % % constructs an stk_kreq_qr object. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function kreq = stk_kreq_qr (model, xi, xt) [Kii, Pi] = stk_make_matcov (model, xi); [n, r] = size (Pi); % heuristics: scale Pi to (try to) avoid conditioning issues later P_scaling = compute_P_scaling (Kii, Pi); Pi = bsxfun (@times, Pi, P_scaling); % kriging matrix (left-hand side of the kriging equation) LS = [[Kii, Pi]; [Pi', zeros(r)]]; % orthogonal-triangular decomposition [Q, R] = qr (LS); kreq = struct ('n', n, 'r', r, 'P_scaling', P_scaling, ... 'LS_Q', Q, 'LS_R', R, 'RS', [], 'lambda_mu', []); kreq = class (kreq, 'stk_kreq_qr'); % prepare the right-hand side of the kriging equation if nargin > 2, [Kti, Pt] = stk_make_matcov (model, xt, xi); kreq = stk_set_righthandside (kreq, Kti, Pt); end end % function stk_kreq_qr stk/inst/core/@stk_kreq_qr/stk_squared_seminorm.m0000664000175000017500000000310212617165716021253 0ustar bectbect% STK_SQUARED_SEMINORM [STK internal] % % CALL: s = stk_squared_seminorm (kreq, zi) % % computes the squared semi-norm associated to the left-hand side of an % stk_kreq_qr object. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_squared_seminorm (kreq, zi) % Extend the observation vector with zeros zz = [double(zi); zeros(kreq.r, 1)]; % Compute the squared seminorm s = zz' * (linsolve (kreq, zz)); % % Alternative (slower) implementation: % ni = size (kreq.LS_Q, 1) - kreq.r; % zi = double (zi); % QU = kreq.LS_Q(1:ni, :); % T = kreq.LS_R \ (QU' * zi); % s = zi' * T(1:ni, :); % Guard against numerical issues if s < 0, s = 0; end end % function stk_squared_seminorm stk/inst/core/stk_model.m0000664000175000017500000001303612617165716014360 0ustar bectbect% STK_MODEL generates a model with default covariance parameters % % CALL: MODEL = stk_model () % % returns a structure MODEL (see below for a description of the fields in such % a structure) corresponding to one-dimensional Gaussian process prior with a % constant but unknown mean ("ordinary" kriging) and a stationary Matern % covariance function. % % CALL: MODEL = stk_model (COVARIANCE_TYPE) % % uses the user-supplied COVARIANCE_TYPE instead of the default. % % CALL: MODEL = stk_model (COVARIANCE_TYPE, DIM) % % creates a DIM-dimensional model. Note that, for DIM > 1, anisotropic % covariance functions are provided with default parameters that make them % isotropic. % % In STK, a Gaussian process model is described by a 'model' structure, % which has mandatory fields and optional fields. % % MANDATORY FIELDS: covariance_type, param, order, lognoisevariance % OPTIONAL FIELD: param_prior, noise_prior, response_name, lm % % See also stk_materncov_iso, stk_materncov_aniso, ... % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function model = stk_model (covariance_type, varargin) % Accept a handle instead of a function name % (completion works when typing @stk_... not when typing 'stk_...) if (nargin > 0) && (isa (covariance_type, 'function_handle')) covariance_type = func2str (covariance_type); end if nargin < 1, % use the (isotropic, 1D) Matern covariance function as a default choice model = stk_model_ ('stk_materncov_iso'); elseif strcmp (covariance_type, 'stk_discretecov') % special case: build a discrete model model = stk_model_discretecov (varargin{:}); else % general case model = stk_model_ (covariance_type, varargin{:}); end end % function stk_model %%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% stk_model_discretecov %%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%% function model_out = stk_model_discretecov (model_base, x) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Backward compatiblity: accept model structures with missing lognoisevariance if (~ isfield (model_base, 'lognoisevariance')) ... || (isempty (model_base.lognoisevariance)) model_base.lognoisevariance = - inf; end [K, P] = stk_make_matcov (model_base, x, x); model_out = struct ( ... 'covariance_type', 'stk_discretecov', ... 'param', struct ('K', K, 'P', P)); model_out.lognoisevariance = model_base.lognoisevariance; end % function stk_model_discretecov %%%%%%%%%%%%%%%%%% %%% stk_model_ %%% %%%%%%%%%%%%%%%%%% function model = stk_model_ (covariance_type, dim) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end model = struct(); model.covariance_type = covariance_type; % use ordinary kriging as a default choice model.order = 0; % default dimension is d = 1 if nargin < 2, model.dim = 1; else model.dim = dim; end % For known covariance types, the field param is initialized with a vector of % nan of the appropriate size. This serves as a reminder, for the user, of the % correct size for a parameter vector---nothing more. switch model.covariance_type case 'stk_materncov_iso' model.param = nan (3, 1); case {'stk_materncov32_iso', 'stk_materncov52_iso', 'stk_gausscov_iso'} model.param = nan (2, 1); case 'stk_materncov_aniso' model.param = nan (2 + model.dim, 1); case {'stk_materncov32_aniso', ... 'stk_materncov52_aniso', 'stk_gausscov_aniso'} model.param = nan (1 + model.dim, 1); otherwise model.param = []; end % switch model.lognoisevariance = - inf; end % function stk_model_ %!test model = stk_model(); %!test model = stk_model('stk_materncov_iso'); %!test model = stk_model('stk_materncov_iso', 1); %!test model = stk_model('stk_materncov_iso', 3); %!test model = stk_model('stk_materncov_aniso'); %!test model = stk_model('stk_materncov_aniso', 1); %!test model = stk_model('stk_materncov_aniso', 3); %!test model = stk_model('stk_materncov32_iso'); %!test model = stk_model('stk_materncov32_iso', 1); %!test model = stk_model('stk_materncov32_iso', 3); %!test model = stk_model('stk_materncov32_aniso'); %!test model = stk_model('stk_materncov32_aniso', 1); %!test model = stk_model('stk_materncov32_aniso', 3); %!test model = stk_model('stk_materncov52_iso'); %!test model = stk_model('stk_materncov52_iso', 1); %!test model = stk_model('stk_materncov52_iso', 3); %!test model = stk_model('stk_materncov52_aniso'); %!test model = stk_model('stk_materncov52_aniso', 1); %!test model = stk_model('stk_materncov52_aniso', 3); stk/inst/core/stk_predict.m0000664000175000017500000002164712617165716014721 0ustar bectbect% STK_PREDICT performs a kriging prediction from data % % CALL: ZP = stk_predict(MODEL, XI, ZI, XP) % % performs a kriging prediction at the points XP, given the observations % (XI, ZI) and the prior MODEL. The input arguments XI, ZI, and XP can be % either numerical matrices or dataframes. More precisely, on a factor space % of dimension DIM, % % * XI must have size NI x DIM, % * ZI must have size NI x 1, % * XP must have size NP x DIM, % % where NI is the number of observations and NP the number of prediction % points. The output ZP is a dataframe of size NP x 2, with: % % * the kriging predictor in the first column (ZP.mean), and % * the kriging variance in the second column (ZP.var). % % CALL: [ZP, LAMBDA, MU] = stk_predict(MODEL, XI, ZI, XP) % % also returns the matrix of kriging weights LAMBDA and the matrix of % Lagrange multipliers MU. % % CALL: [ZP, LAMBDA, MU, K] = stk_predict(MODEL, XI, ZI, XP) % % also returns the posterior covariance matrix K at the locations XP (this is % an NP x NP covariance matrix). From a frequentist point of view, K can be % seen as the covariance matrix of the prediction errors. % % SPECIAL CASE % % If ZI is empty, everything but ZP.mean is computed. Indeed, neither the % kriging variance ZP.var nor the matrices LAMBDA and MU actually depend on % the observed values. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [zp, lambda, mu, K] = stk_predict (model, xi, zi, xt) if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % TODO: these should become options display_waitbar = false; block_size = []; %--- Prepare the lefthand side of the KRiging EQuation ------------------------- if iscell (xi) % WARNING: experimental HIDDEN feature, use at your own risk !!! kreq = xi{2}; % already computed, I hope you know what you're doing ;-) xi = xi{1}; else kreq = stk_kreq_qr (model, xi); end %--- Convert and check input arguments: zi, xt --------------------------------- zi = double (zi); ni = kreq.n; if ~ (isempty (zi) || isequal (size (zi), [ni 1])) stk_error ('zi must have size ni x 1.', 'IncorrectSize'); end xt = double (xt); xi = double (xi); if strcmp (model.covariance_type, 'stk_discretecov') % use indices if isempty (xt) nt = size (model.param.K, 1); xt = (1:nt)'; else if ~ iscolumn (xt) warning ('STK:stk_predict:IncorrectSize', sprintf(['xt should be ' ... 'a column.\n --> Trying to continue with xt = xt(:) ...'])); xt = xt(:); end nt = size (xt, 1); end else nt = size (xt, 1); if ~ isequal (size (xt), [nt, size(xi, 2)]), errmsg = 'The size of xt is not correct.'; stk_error (errmsg, 'IncorrectSize'); end end %--- Prepare the output arguments ---------------------------------------------- zp_v = zeros (nt, 1); compute_prediction = ~ isempty (zi); % compute the kriging prediction, or just the variances ? if compute_prediction, zp_a = zeros (nt, 1); else zp_a = nan (nt, 1); end %--- Choose nb_blocks & block_size --------------------------------------------- if isempty (block_size) MAX_RS_SIZE = 5e6; SIZE_OF_DOUBLE = 8; % in bytes block_size = ceil( MAX_RS_SIZE / (ni * SIZE_OF_DOUBLE)); end % blocks of size approx. block_size nb_blocks = max (1, ceil(nt / block_size)); block_size = ceil (nt / nb_blocks); % The full lambda_mu matrix is only needed when nargout > 1 if nargout > 1, lambda_mu = zeros (ni + kreq.r, nt); end % The full RS matrix is only needed when nargout > 3 if nargout > 3, RS = zeros (size (lambda_mu)); end %--- MAIN LOOP (over blocks) --------------------------------------------------- % TODO: this loop should be parallelized !!! for block_num = 1:nb_blocks % compute the indices for the current block idx_beg = 1 + block_size * (block_num - 1); idx_end = min(nt, idx_beg + block_size - 1); idx = idx_beg:idx_end; % solve the kriging equation for the current block xt_ = xt(idx, :); [Kti, Pt] = stk_make_matcov (model, xt_, xi); kreq = stk_set_righthandside (kreq, Kti, Pt); % compute the kriging mean if compute_prediction, zp_a(idx) = kreq.lambda' * zi; end % The full lambda_mu matrix is only needed when nargout > 1 if nargout > 1 lambda_mu(:, idx) = kreq.lambda_mu; end % The full RS matrix is only needed when nargout > 3 if nargout > 3, RS(:, idx) = kreq.RS; end % compute kriging variances (this does NOT include the noise variance) zp_v(idx) = stk_make_matcov (model, xt_, xt_, true) - kreq.delta_var; % note: the following modification computes prediction variances for noisy % variance, i.e., including the noise variance also % zp_v(idx) = stk_make_matcov (model, xt_, [], true) ... % - dot (kreq.lambda_mu, kreq.RS); b = (zp_v < 0); if any (b), zp_v(b) = 0.0; warning('STK:stk_predict:NegativeVariancesSetToZero', sprintf ( ... ['Correcting numerical inaccuracies in kriging variance.\n' ... '(%d negative variances have been set to zero)'], sum (b))); end if display_waitbar, waitbar (idx_end/nt, hwb, sprintf ( ... 'In stk\\_predict(): %d/%d predictions completed',idx_end,nt)); end end if display_waitbar, close (hwb); end %--- Prepare outputs ----------------------------------------------------------- zp = stk_dataframe ([zp_a zp_v], {'mean' 'var'}); zp.info = 'Created by stk_predict'; if nargout > 1 % lambda requested lambda = lambda_mu(1:ni, :); end if nargout > 2 % mu requested mu = lambda_mu((ni+1):end, :); end if nargout > 3, K0 = stk_make_matcov (model, xt, xt); deltaK = lambda_mu' * RS; K = K0 - 0.5 * (deltaK + deltaK'); end end % function stk_predict ----------------------------------------------------- %#ok<*SPWRN> %!shared n, m, model, x0, x_obs, z_obs, x_prd, y_prd1, idx_obs, idx_prd %! %! n = 10; % number of observations %! m = n + 1; % number of predictions %! d = 1; % dimension of the input space %! %! x0 = stk_sampling_regulargrid(n+m, d, [0; pi]); %! %! idx_obs = (2:2:(n+m-1))'; %! idx_prd = (1:2:(n+m))'; %! %! x_obs = x0(idx_obs); %! z_obs = sin (double (x_obs)); %! x_prd = x0(idx_prd); %! %! model = stk_model('stk_materncov32_iso'); %! model.order = 0; % this is currently the default, but better safe than sorry %! model.param = log ([1.0; 2.1]); %!error y_prd1 = stk_predict(); %!error y_prd1 = stk_predict(model); %!error y_prd1 = stk_predict(model, x_obs); %!error y_prd1 = stk_predict(model, x_obs, z_obs); %!test y_prd1 = stk_predict(model, x_obs, z_obs, x_prd); %!error y_prd1 = stk_predict(model, x_obs, z_obs, x_prd, 0); %!test % nargout = 2 %! [y_prd1, lambda] = stk_predict (model, x_obs, z_obs, x_prd); %! assert (isequal (size (lambda), [n m])); %!test % nargout = 2, compute only variances %! [y_prd1, lambda] = stk_predict (model, x_obs, [], x_prd); %! assert (isequal (size (lambda), [n m])); %! assert (all (isnan (y_prd1.mean))); %!test % nargout = 3 %! [y_prd1, lambda, mu] = stk_predict (model, x_obs, z_obs, x_prd); %! assert (isequal (size (lambda), [n m])); %! assert (isequal (size (mu), [1 m])); % ordinary kriging %!test % nargout = 4 %! [y_prd1, lambda, mu, K] = stk_predict (model, x_obs, z_obs, x_prd); %! assert (isequal (size (lambda), [n m])); %! assert (isequal (size (mu), [1 m])); % ordinary kriging %! assert (isequal (size (K), [m m])); %!test % use old-style .a structures (legacy) %! y_prd2 = stk_predict(model, struct('a', double(x_obs)), ... %! struct('a', double(z_obs)), struct('a', double(x_prd))); %! assert(stk_isequal_tolrel(double(y_prd1), double(y_prd2))); %!test % predict on large set of locations %! x_obs = stk_sampling_regulargrid (20, 1, [0; pi]); %! z_obs = stk_feval (@sin, x_obs); %! x_prd = stk_sampling_regulargrid (1e5, 1, [0; pi]); %! y_prd = stk_predict (model, x_obs, z_obs, x_prd); stk/inst/utils/0000775000175000017500000000000012617165721012422 5ustar bectbectstk/inst/utils/stk_generate_samplepaths.m0000664000175000017500000001706512617165721017665 0ustar bectbect% STK_GENERATE_SAMPLEPATHS generates sample paths of a Gaussian process % % CALL: ZSIM = stk_generate_samplepaths (MODEL, XT) % % generates one sample path ZSIM, using the kriging model MODEL and the % evaluation points XT. Both XT and ZSIM are structures, whose field 'a' % contains the actual numerical values. % % CALL: ZSIM = stk_generate_samplepaths (MODEL, XT, NB_PATHS) % % generates NB_PATHS sample paths at once. % % CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT) % % generates one sample path ZSIM, using the kriging model MODEL and the % evaluation points XT, conditional on the evaluations (XI, ZI). % % CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT, NB_PATHS) % % generates NB_PATHS conditional sample paths at once. % % NOTE: Sample size limitation % % This function generates (discretized) sample paths using a Cholesky % factorization of the covariance matrix, and is therefore restricted to % moderate values of the number of evaluation points. % % NOTE: Output type % % The output argument ZSIM will be an stk_dataframe if at least one of the % following conditions is met: % % a) the MODEL structure has a non-empty char field named 'response_name'; % % b) one of the input arguments XT, XI or ZI is an stk_dataframe object. % % If both MODEL.response_name and ZI.colnames exist and are non-empty, they % must be equal (if they are not, ZSIM.colnames is empty). % % EXAMPLES: see stk_example_kb05, stk_example_kb07 % % See also stk_conditioning, stk_cholcov % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function zsim = stk_generate_samplepaths (model, varargin) % Note: we know that none of the input argument is an stk_dataframe object % (otherwise we would have ended up in @stk_dataframe/stk_generate_samplepaths) switch nargin, case {0, 1}, stk_error ('Not enough input arguments.', 'NotEnoughInputArgs'); case 2, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XT) xt = varargin{1}; nb_paths = 1; conditional = false; case 3, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XT, NB_PATHS) xt = varargin{1}; nb_paths = varargin{2}; conditional = false; case 4, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT) xi = varargin{1}; zi = varargin{2}; xt = varargin{3}; nb_paths = 1; conditional = true; case 5, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT, NB_PATHS) xi = varargin{1}; zi = varargin{2}; xt = varargin{3}; nb_paths = varargin{4}; conditional = true; otherwise stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Prepare extended dataset for conditioning, if required % (TODO: avoid duplicating observations points if xi is a subset of xt) if conditional, xt = [xi; xt]; xi_ind = 1:(size (xi, 1)); end %--- Generate unconditional sample paths -------------------------------------- % Pick unique simulation points [xt_unique, i_ignore, j] = unique (xt, 'rows'); %#ok % Did we actually find duplicates in xt ? duplicates_detected = (size (xt_unique, 1) < size (xt, 1)); % Compute the covariance matrix % (even if there no duplicates, it is not guaranteed % that xt_unique and xt are equal) if duplicates_detected, K = stk_make_matcov (model, xt_unique, xt_unique); else K = stk_make_matcov (model, xt, xt); end % Cholesky factorization of the covariance matrix V = stk_cholcov (K); % Generates samplepaths zsim = V' * randn (size (K, 1), nb_paths); % Duplicate simulated values, if necessary if duplicates_detected, zsim = zsim(j, :); end %--- Generate conditional sample paths ---------------------------------------- if conditional, % Backward compatiblity: tolerate missing lognoisevariance if (~ isfield (model, 'lognoisevariance')) ... || (isempty (model.lognoisevariance)) model.lognoisevariance = - inf; end % Carry out the kriging prediction at points xt [zp_ignore, lambda] = stk_predict (model, xi, zi, xt); %#ok if model.lognoisevariance == -inf, % Simulate sample paths conditioned on noiseless observations zsim = stk_conditioning (lambda, zi, zsim, xi_ind); else % Noisy case % Simulate noise values s = sqrt (exp (model.lognoisevariance)); ni = length (xi_ind); if isscalar (s) noise_sim = s * randn (ni, nb_paths); else s = reshape (s, ni, 1); noise_sim = bsxfun (@times, s, randn (ni, nb_paths)); end % Simulate sample paths conditioned on noisy observations zsim = stk_conditioning (lambda, zi, zsim, xi_ind, noise_sim); end % TEMPORARY FIX (until stk_conditioning is fixed as well) zsim = double (zsim); zsim(xi_ind, :) = []; end %--- stk_dataframe output ? -------------------------------------------------- try %#ok response_name = model.response_name; assert ((~ isempty (response_name)) && (ischar (response_name))); if nb_paths == 1, zsim_colnames = {response_name}; else zsim_colnames = arrayfun ( ... @(i)(sprintf ('%s_%d', response_name, i)), ... 1:nb_paths, 'UniformOutput', false); end zsim = stk_dataframe (zsim, zsim_colnames); end end % function stk_generate_samplepaths %!shared model, xi, zi, xt, n, nb_paths %! dim = 1; n = 50; nb_paths = 5; %! model = stk_model ('stk_materncov32_iso', dim); %! model.param = log ([1.0; 2.9]); %! xt = stk_sampling_regulargrid (n, dim, [-1.0; 1.0]); %! xi = [xt(1, :); xt(end, :)]; zi = [0; 0]; %!error zsim = stk_generate_samplepaths (); %!error zsim = stk_generate_samplepaths (model); %!test zsim = stk_generate_samplepaths (model, xt); %!test zsim = stk_generate_samplepaths (model, xt, nb_paths); %!test zsim = stk_generate_samplepaths (model, xi, zi, xt); %!test zsim = stk_generate_samplepaths (model, xi, zi, xt, nb_paths); %!error zsim = stk_generate_samplepaths (model, xi, zi, xt, nb_paths, log (2)); %!test %! zsim = stk_generate_samplepaths (model, xt); %! assert (isequal (size (zsim), [n, 1])); %!test %! zsim = stk_generate_samplepaths (model, xt, nb_paths); %! assert (isequal (size (zsim), [n, nb_paths])); %!test % duplicate simulation points %! zsim = stk_generate_samplepaths (model, [xt; xt], nb_paths); %! assert (isequal (size (zsim), [2 * n, nb_paths])); %! assert (isequal (zsim(1:n, :), zsim((n + 1):end, :))); stk/inst/utils/stk_conditioning.m0000664000175000017500000001362212617165721016151 0ustar bectbect% STK_CONDITIONING produces conditioned sample paths % % CALL: ZSIMC = stk_conditioning (LAMBDA, ZI, ZSIM, XI_IND) % % produces conditioned sample paths ZSMIC from the unconditioned sample paths % ZSIM, using the matrix of kriging weights LAMBDA. Conditioning is done with % respect to a finite number NI of observations, located at the indices given % in XI_IND (vector of length NI), with corresponding noiseless observed % values ZI. % % The matrix LAMBDA must be of size NI x N, where N is the number of % evaluation points for the sample paths; such a matrix is typically provided % by stk_predict(). % % Both ZSIM and ZSIMC have size N x NB_PATHS, where NB_PATH is the number % sample paths to be dealt with. ZI is a column of length NI. % % CALL: ZSIMC = stk_conditioning (LAMBDA, ZI, ZSIM) % % assumes that the oberved values ZI correspond to the first NI evaluation % points. % % CALL: ZSIMC = stk_conditioning (LAMBDA, ZI, ZSIM, XI_IND, NOISE_SIM) % % produces conditioned sample paths ZSMIC from the unconditioned sample paths % ZSIM, using the matrix of kriging weights LAMBDA. Conditioning is done with % respect to a finite number NI of observations, located at the indices given % in XI_IND (vector of length NI), with corresponding noisy observed values % ZI, using a NI x N matrix NOISE_SIM of simulated noise values. % % NOTE: Conditioning by kriging % % stk_conditioning uses the technique called "conditioning by kriging" % (see, e.g., Chiles and Delfiner, Geostatistics: Modeling Spatial % Uncertainty, Wiley, 1999) % % NOTE: Output type % % The output argument ZSIMC will be an stk_dataframe if either LAMBDA or ZSIM % are stk_dataframe. In case of conflicting row names (coming from % ZSIM.rownames on the one hand and LAMBDA.colnames on the other hand), % ZSIMC.rownames is {}. % % EXAMPLE: stk_example_kb05 % % See also stk_generate_samplepaths, stk_predict % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function zsimc = stk_conditioning (lambda, zi, z_sim, xi_ind, noise_sim) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Are we dealing with noisy observations ? noisy = (nargin > 4) && (~ isempty (noise_sim)); zi = double (zi); z_sim = double (z_sim); [ni, n] = size (lambda); m = size (z_sim, 2); if (nargin < 4) || (isempty (xi_ind)) xi_ind = (1:ni)'; else xi_ind = xi_ind(:); end if ~ isequal (size (zi), [ni 1]) stk_error (sprintf (['Considering the size of lambda (%d x %d), zi ' ... 'should have size %d x 1'], ni, n, ni), 'IncorrectSize'); end if ~ isequal (size (z_sim), [n m]) stk_error (sprintf (['Considering the size of lambda (%d x %d), zsim ' ... 'should have size %d x N, where N is the number of evaluation ' ... 'points for the sample paths.'], ni, n, n), 'IncorrectSize'); end if ~ isequal (size (xi_ind), [ni 1]) stk_error (sprintf (['Considering the size of lambda (%d x %d), xi_ind ' ... 'should have size %d x 1'], ni, n, ni), 'IncorrectSize'); end if noisy && (~ isequal (size (noise_sim), [ni m])) stk_error (sprintf (['Considering the size of lambda (%d x %d) and the ' ... 'size of z_sim (%d x %d), noise_sim should have size %d x %d'], ni, ... n, n, m, ni, m), 'IncorrectSize'); end delta = bsxfun (@minus, zi, z_sim(xi_ind, :)); if noisy delta = delta - noise_sim; end zsimc = z_sim + lambda' * delta; end % function stk_conditioning %!shared n, m, ni, xi_ind, lambda, zsim, zi %! %! n = 50; m = 5; ni = 10; xi_ind = 1:ni; %! lambda = 1/ni * ones (ni, n); % prediction == averaging %! zsim = ones (n, m); % const unconditioned samplepaths %! zi = zeros (ni, 1); % conditioning by zeros %!error zsimc = stk_conditioning (); %!error zsimc = stk_conditioning (lambda); %!error zsimc = stk_conditioning (lambda, zi); %!test zsimc = stk_conditioning (lambda, zi, zsim); %!test zsimc = stk_conditioning (lambda, zi, zsim, xi_ind); %!error zsimc = stk_conditioning (lambda, zi, zsim, xi_ind, pi^2); %!test %! zsimc = stk_conditioning (lambda, zi, zsim, xi_ind); %! assert (stk_isequal_tolabs (double (zsimc), zeros (n, m))); %!test %! zi = 2 * ones (ni, 1); % conditioning by twos %! zsimc = stk_conditioning (lambda, zi, zsim, xi_ind); %! assert (stk_isequal_tolabs (double (zsimc), 2 * ones (n, m))); %!test %! DIM = 1; nt = 400; %! xt = stk_sampling_regulargrid (nt, DIM, [-1.0; 1.0]); %! %! NI = 6; xi_ind = [1 20 90 200 300 350]; %! xi = xt(xi_ind, 1); %! zi = (1:NI)'; % linear response ;-) %! %! % Carry out the kriging prediction at points xt %! model = stk_model ('stk_materncov52_iso'); %! model.param = log ([1.0; 2.9]); %! [ignore_zp, lambda] = stk_predict (model, xi, [], xt); %! %! % Generate (unconditional) sample paths according to the model %! NB_PATHS = 10; %! zsim = stk_generate_samplepaths (model, xt, NB_PATHS); %! zsimc = stk_conditioning (lambda, zi, zsim, xi_ind); stk/inst/sampling/0000775000175000017500000000000012617165721013074 5ustar bectbectstk/inst/sampling/stk_sampling_maximinlhs.m0000664000175000017500000001066312617165721020204 0ustar bectbect% STK_SAMPLING_MAXIMINLHS generates a "maximin" LHS design % % CALL: X = stk_sampling_maximinlhs (N, DIM) % % generates a "maximin" Latin Hypercube Sample of size N in the % DIM-dimensional hypercube [0; 1]^DIM. More precisely, NITER = 1000 % independent random LHS are generated, and the one with the biggest % separation distance is returned. % % CALL: X = stk_sampling_maximinlhs (N, DIM, BOX) % % does the same thing in the DIM-dimensional hyperrectangle specified by the % argument BOX, which is a 2 x DIM matrix where BOX(1, j) and BOX(2, j) are % the lower- and upper-bound of the interval on the j^th coordinate. % % CALL: X = stk_sampling_maximinlhs (N, DIM, BOX, NITER) % % allows to change the number of independent random LHS that are used. % % See also: stk_mindist, stk_sampling_randomlhs % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_sampling_maximinlhs (n, d, box, niter) if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Read argument dim if (nargin < 2) || ((nargin < 3) && (isempty (d))) d = 1; % Default dimension elseif (nargin > 2) && (~ isempty (box)) d = size (box, 2); end % Read argument 'box' if (nargin < 3) || isempty (box) box = stk_hrect (d); % build a default box else box = stk_hrect (box); % convert input argument to a proper box end if nargin < 4, niter = 1000; end if n == 0, % no input => no output xdata = zeros (0, d); else % at least one input point xx = lhsdesign_ (n, d, niter); xdata = stk_rescale (xx, [], box); end x = stk_dataframe (xdata, box.colnames); x.info = 'Created by stk_sampling_maximinlhs'; end % function stk_sampling_maximinlhs %%%%%%%%%%%%%%%%%% %%% lhsdesign_ %%% %%%%%%%%%%%%%%%%%% function x = lhsdesign_ (n, d, niter) x = generatedesign_ (n, d); if niter > 1, bestscore = stk_mindist (x); for j = 2:niter y = generatedesign_ (n, d); score = stk_mindist (y); if score > bestscore x = y; bestscore = score; end end end end % function lhsdesign_ %%%%%%%%%%%%%%%%%%%%%%% %%% generatedesign_ %%% %%%%%%%%%%%%%%%%%%%%%%% function x = generatedesign_ (n, d) x = zeros (n, d); for i = 1:d % for each dimension, draw a random permutation [sx, x(:,i)] = sort (rand (n,1)); %#ok end x = (x - rand (size (x))) / n; end % function generatedesign_ %% % Check error for incorrect number of input arguments %!shared x, n, dim, box, niter %! n = 20; dim = 2; box = [0, 0; 1, 1]; niter = 1; %!error x = stk_sampling_maximinlhs (); %!test x = stk_sampling_maximinlhs (n); %!test x = stk_sampling_maximinlhs (n, dim); %!test x = stk_sampling_maximinlhs (n, dim, box); %!test x = stk_sampling_maximinlhs (n, dim, box, niter); %!error x = stk_sampling_maximinlhs (n, dim, box, niter, pi); %% % Check that the output is a dataframe % (all stk_sampling_* functions should behave similarly in this respect) %!assert (isa (x, 'stk_dataframe')); %% % Check that column names are properly set, if available in box %!assert (isequal (x.colnames, {})); %!test %! cn = {'W', 'H'}; box = stk_hrect (box, cn); %! x = stk_sampling_maximinlhs (n, dim, box); %! assert (isequal (x.colnames, cn)); %% % Check output argument %!test %! for dim = 1:5, %! x = stk_sampling_randomlhs (n, dim); %! assert (isequal (size (x), [n dim])); %! u = double (x); u = u(:); %! assert (~ any (isnan (u) | isinf (u))); %! assert ((min (u) >= 0) && (max (u) <= 1)); %! assert (stk_is_lhs (x, n, dim)); %! end stk/inst/sampling/stk_sampling_randomlhs.m0000664000175000017500000000617412617165721020024 0ustar bectbect% STK_SAMPLING_RANDOMLHS generates a random LHS design % % CALL: X = stk_sampling_randomlhs (N, DIM) % % generates a random Latin Hypercube Sample of size N in the DIM-dimensional % hypercube [0; 1]^DIM. % % CALL: X = stk_sampling_randomlhs (N, DIM, BOX) % % generates a random Latin Hypercube Sample of size N in the DIM-dimensional % hyperrectangle specified by the argument BOX, which is a 2 x DIM matrix % where BOX(1, j) and BOX(2, j) are the lower- and upper-bound of the interval % on the j^th coordinate. % % See also: stk_sampling_maximinlhs, stk_sampling_randunif % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_sampling_randomlhs (n, dim, box) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Read argument dim if (nargin < 2) || ((nargin < 3) && (isempty (dim))) dim = 1; % Default dimension elseif (nargin > 2) && (~ isempty (box)) dim = size (box, 2); end % Read argument box if (nargin < 3) || isempty (box) box = stk_hrect (dim); end niter = 1; x = stk_sampling_maximinlhs (n, dim, box, niter); x.info = 'Created by stk_sampling_randomlhs'; end % function stk_sampling_randomlhs %% % Check error for incorrect number of input arguments %!shared x, n, dim, box %! n = 10; dim = 2; box = [0, 0; 1, 1]; %!error x = stk_sampling_randomlhs (); %!test x = stk_sampling_randomlhs (n); %!test x = stk_sampling_randomlhs (n, dim); %!test x = stk_sampling_randomlhs (n, dim, box); %!error x = stk_sampling_randomlhs (n, dim, box, pi); %% % Check that the output is a dataframe % (all stk_sampling_* functions should behave similarly in this respect) %!assert (isa(x, 'stk_dataframe')); %% % Check that column names are properly set, if available in box %!assert (isequal (x.colnames, {})); %!test %! cn = {'W', 'H'}; box = stk_hrect (box, cn); %! x = stk_sampling_randomlhs (n, dim, box); %! assert (isequal (x.colnames, cn)); %% % Check output argument %!test %! for dim = 1:5, %! x = stk_sampling_randomlhs(n, dim); %! assert(isequal(size(x), [n dim])); %! u = double(x); u = u(:); %! assert(~any(isnan(u) | isinf(u))); %! assert((min(u) >= 0) && (max(u) <= 1)); %! assert(stk_is_lhs(x, n, dim)); %! end stk/inst/sampling/stk_sampling_randunif.m0000664000175000017500000000650012617165721017634 0ustar bectbect% STK_SAMPLING_RANDUNIF generates uniformly distributed points % % CALL: X = stk_sampling_randunif (N, DIM) % % generates N points, independent and uniformly distributed in the % DIM-dimensional hypercube [0; 1]^DIM. % % CALL: X = stk_sampling_randunif (N, DIM, BOX) % % does the same thing in the DIM-dimensional hyperrectangle specified by the % argument BOX, which is a 2 x DIM matrix where BOX(1, j) and BOX(2, j) are % the lower- and upper-bound of the interval on the j^th coordinate. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_sampling_randunif (n, dim, box) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Read argument n if ~ ((isscalar (n)) && (isnumeric (n))) error ('n should be a numerical scalar.'); end % Read argument dim if (nargin < 2) || ((nargin < 3) && (isempty (dim))) dim = 1; % Default dimension elseif (nargin > 2) && (~ isempty (box)) dim = size (box, 2); end % Read argument box if (nargin < 3) || isempty (box) box = stk_hrect (dim); % build a default box else box = stk_hrect (box); % convert input argument to a proper box end if n == 0, % empty sample xdata = zeros (0, dim); else % at least one input point xdata = stk_rescale (rand(n, dim), [], box); end x = stk_dataframe (xdata, box.colnames); x.info = 'Created by stk_sampling_randunif'; end % function stk_sampling_randunif %% % Check error for incorrect number of input arguments %!shared x, n, dim, box %! n = 10; dim = 2; box = [0, 0; 2, 2]; %!error x = stk_sampling_randunif (); %!test x = stk_sampling_randunif (n); %!test x = stk_sampling_randunif (n, dim); %!test x = stk_sampling_randunif (n, dim, box); %!error x = stk_sampling_randunif (n, dim, box, pi); %% % Check that the output is a dataframe % (all stk_sampling_* functions should behave similarly in this respect) %!assert (isa(x, 'stk_dataframe')); %% % Check that column names are properly set, if available in box %!assert (isequal (x.colnames, {})); %!test %! cn = {'W', 'H'}; box = stk_hrect (box, cn); %! x = stk_sampling_randunif (n, dim, box); %! assert (isequal (x.colnames, cn)); %% % Check output argument %!test %! for dim = 1:5, %! x = stk_sampling_randunif(n, dim); %! assert(isequal(size(x), [n dim])); %! u = double(x); u = u(:); %! assert(~any(isnan(u) | isinf(u))); %! assert((min(u) >= 0) && (max(u) <= 1)); %! end stk/inst/sampling/stk_sampling_vdc_rr2.m0000664000175000017500000000407212617165721017371 0ustar bectbect% STK_SAMPLING_VDC_RR2 generates points from the "RR2" van der Corput sequence % % CALL: X = __stk_sampling_vdc_rr2__(N, J) % % computes the first N terms of the j^th RR2-scrambled van der Corput % sequence. % % REFERENCE % % Ladislav Kocis and William J. Whiten, "Computational investigations of low % discrepancy sequences", ACM Transactions on Mathematical Software, % 23(2):266-294, 1997. % http://dx.doi.org/10.1145/264029.264064 % % SEE ALSO: stk_sampling_halton_rr2 % Copyright Notice % % Copyright (C) 2013 Alexandra Krauth, Elham Rahali & SUPELEC % % Authors: Julien Bect % Alexandra Krauth % Elham Rahali % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . %!error __stk_sampling_vdc_rr2__() % two inputs required %!error __stk_sampling_vdc_rr2__(10) % two inputs required %!error __stk_sampling_vdc_rr2__(10, 3, -1) % two inputs required %!test %! n = 300; j = 25; %! x = __stk_sampling_vdc_rr2__(n, j); %! assert(isequal(size(x), [n 1])) %!test %! x = __stk_sampling_vdc_rr2__(2000, 7); %! y = double (x(1998:2000, :)); %! yref = [0.849786281294525; 0.085080398941584; 0.555668634235701]; %! assert(stk_isequal_tolrel(y, yref, 1e-13)); stk/inst/sampling/stk_sampling_olhs.m0000664000175000017500000001773612617165721017010 0ustar bectbect% STK_SAMPLING_OLHS generates a random Orthogonal Latin Hypercube (OLH) sample % % CALL: X = stk_sampling_olhs (N) % % generates a random Orthogonal Latin Hypercube (OLH) sample X, using the % construction of Ye (1998). The algorithm only works for sample sizes N % of the form 2^(R+1)+1, with R >= 1. Trying to generate an OLHS with a % value of N that is not of this form generates an error. The number of % factors is D = 2*R, and the OLHS is defined on [-1; 1]^D. % % CALL: X = stk_sampling_olhs (N, D) % % does exactly the same thing, provided that there exists an integer R % such that N = 2^(R+1)+1 and D = 2*R (or D is empty). % % CALL: X = stk_sampling_olhs (N, D, BOX) % % generates an OLHS on BOX. Again, D can be empty since the number of % factors can be deduced from N. % % CALL: X = stk_sampling_olhs (N, D, BOX, PERMUT) % % uses a given permutation PERMUT, instead of a random permutation, to % initialize the construction of Ye (1998). As a result, the generated % OLHS is not random anymore. PERMUT must be a permutation of 1:2^R. If % BOX is empty, then the default domain [-1, 1]^D is used. % % NOTE: orthogonality % % The samples generated by this functions are only orthogonal, stricty- % speaking, if BOX is a symmetric domain (e.g., [-1, 1] ^ D). Otherwise, % the generated samples should be called "uncorrelated". % % REFERENCE % % Kenny Q. Ye, "Orthogonal Column Latin Hypercubes and Their % Application in Computer Experiments", Journal of the American % Statistical Association, 93(444), 1430-1439, 1998. % http://dx.doi.org/10.1080/01621459.1998.10473803 % % See also: stk_sampling_randomlhs, stk_sampling_maximinlhs % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, aux] = stk_sampling_olhs (n, d, box, permut, extended) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Read argument dim if (nargin < 2) || ((nargin < 3) && (isempty (d))) d = 1; % Default dimension elseif (nargin > 2) && (~ isempty (box)) d = size (box, 2); end if nargin < 5, extended = false; end %%% PROCESS INPUT ARGUMENTS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % recover the "order" r from the value of n r = floor(log2(n - 1) - 1); n_ = 2^(r + 1) + 1; if (r <= 0) || (abs(n - n_) > eps), errmsg = 'n must be an integer of the form 2^(r+1) + 1 with r > 0'; stk_error(errmsg, 'IncorrectArgument'); end n = n_; if ~extended % check that d has the correct value for a "full" Ye98-OLHS % (other values of d can be reached by removing columns from a full OLHS) if (nargin > 1) && ~isempty(d), if d ~= 2 * r, errmsg = 'Incorrect value of d, please read the documentation...'; stk_error(errmsg, 'IncorrectArgument'); end else d = 2 * r; end else % check that d has the correct value for a "full" Cioppa-Lucas(2007) NOLHS % (other values of d can be reached by removing columns from a full NOLHS) if (nargin > 1) && ~isempty(d), if d ~= r + 1 + nchoosek(r, 2), errmsg = 'Incorrect value of d, please read the documentation...'; stk_error(errmsg, 'IncorrectArgument'); end else d = r + 1 + nchoosek(r, 2); end end % number of "positive levels" q = 2^r; % = (n - 1)/2 % read argument 'box' if (nargin < 3) || isempty (box) box = stk_hrect (repmat ([-1; 1], 1, d)); % build a default box else box = stk_hrect (box); % convert input argument to a proper box end % permutation if (nargin < 4) || isempty(permut), permut = randperm(q)'; else permut = permut(:); if ~isequal(sort(permut), (1:q)'), errmsg = sprintf('permut should be a permutation of 1:%d.', q); stk_error(errmsg, 'IncorrectArgument'); end end %%% CONSTRUCT AN "ORTHOGONAL" LHS FOLLOWING PROCESS INPUT ARGUMENTS %%%%%%%%%%% % Construct permutation matrices A1, A2, ..., Ar A = cell(1, r); for i = 1:r, Ai = 1; for j = 1:i, Z = zeros(size(Ai)); Ai = [Z Ai; Ai Z]; %#ok end for j = (i+1):r, Z = zeros(size(Ai)); Ai = [Ai Z; Z Ai]; %#ok end A{i} = Ai; end % Construct the matrix M M = [permut zeros(q, 2*r-1)]; for j = 1:r, % from column 2 to column r+1 M(:, j+1) = A{j} * permut; end if ~extended, % OLHS / Ye (1998) for j = 1:(r-1), % from column r+2 to column 2*r M(:, j+r+1) = A{j} * A{r} * permut; end else % NOLHS / Cioppa & Lucas(2007) col = r + 2; for j = 1:(r-1), for k = (j + 1):r, M(:, col) = A{j} * A{k} * permut; col = col + 1; end end end % Construct the matrix S S = ones(q, 2*r); for j = 1:r, % from column 2 to column r+1 aj = 1; for l = r:(-1):1, if l == r - j + 1, aj = [-aj; aj]; %#ok else aj = [aj; aj]; %#ok end end S(:, j+1) = aj; end if ~extended, % OLHS / Ye (1998) for j = 1:(r-1), % from column r+2 to column 2*r S(:, r+1+j) = S(:, 2) .* S(:, j+2); end else % NOLHS / Cioppa & Lucas(2007) col = r + 2; for j = 1:(r - 1), for k = (j + 1):r, S(:, col) = S(:, j+1) .* S(:, k+1); col = col + 1; end end end % Construct the matrix T T = M .* S; % Construct the OLHS X (with integer levels -q, ..., 0, ... +q) x_integer_levels = [T; zeros(1, d); -T]; %%% CONVERT TO THE REQUESTED BOX %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Convert to positive integer levels (1 ... n) x = x_integer_levels + q + 1; % Convert to [0; 1]-valued levels x = (2*x - 1) / (2*n); % And, finally, convert to box x = stk_dataframe (stk_rescale (x, [], box), box.colnames); x.info = 'Created by stk_sampling_olhs'; % Note: the results reported in Cioppa & Lucas correspond to the scaling % x = struct('a', stk_rescale(x, [min(x); max(x)], box)); %%% OUTPUT SOME AUXILIARY DATA IF REQUESTED %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if nargout > 1, aux = struct('M', M, 'S', S, 'X', x_integer_levels); end end % function stk_sampling_olhs %% % Check error for incorrect number of input arguments %!shared x, n, d, box, permut %! n = 5; d = 2; box = [0 0; 1, 1]; permut = 1:2; %!error x = stk_sampling_olhs(); %!test x = stk_sampling_olhs(n); %!test x = stk_sampling_olhs(n, d); %!test x = stk_sampling_olhs(n, d, box); %!test x = stk_sampling_olhs(n, d, box, permut); %!error x = stk_sampling_olhs(n, d, box, permut, pi); %% % Check that the output is a dataframe % (all stk_sampling_* functions should behave similarly in this respect) %!assert (isa (x, 'stk_dataframe')); %% % Check that column names are properly set, if available in box %!assert (isequal (x.colnames, {})); %!test %! cn = {'W', 'H'}; box = stk_hrect (box, cn); %! x = stk_sampling_olhs (n, d, box); %! assert (isequal (x.colnames, cn)); %% % Check output argument %!test %! for r = 1:5 %! %! n = 2 ^ (r + 1) + 1; d = 2 * r; %! x = stk_sampling_olhs (n, d); %! %! assert (isequal (size (x), [n d])); %! %! box = repmat ([-1; 1], 1, d); %! assert (stk_is_lhs (x, n, d, box)); %! %! x = double (x); w = x' * x; %! assert (stk_isequal_tolabs (w / w(1,1), eye (d))); %! %! end stk/inst/sampling/stk_sampling_halton_rr2.m0000664000175000017500000000740112617165721020101 0ustar bectbect% STK_SAMPLING_HALTON_RR2 generates points from the Halton/RR2 sequence % % CALL: X = stk_sampling_halton_rr2 (N, D) % % computes the first N terms of the D-dimensional RR2-scrambled Halton % sequence. % % REFERENCE % % Ladislav Kocis and William J. Whiten, "Computational investigations of low % discrepancy sequences", ACM Transactions on Mathematical Software, % 23(2):266-294, 1997. http://dx.doi.org/10.1145/264029.264064 % % SEE ALSO: __stk_sampling_vdc_rr2__ % Copyright Notice % % Copyright (C) 2014 SUPELEC % Copyright (C) 2013 Alexandra Krauth, Elham Rahali & SUPELEC % % Authors: Julien Bect % Alexandra Krauth % Elham Rahali % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_sampling_halton_rr2 (n, d, box) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Read argument dim if (nargin < 2) || ((nargin < 3) && (isempty (d))) d = 1; % Default dimension elseif (nargin > 2) && (~ isempty (box)) d = size (box, 2); end % Read argument 'box' if (nargin < 3) || isempty (box) colnames = {}; else box = stk_hrect (box); % convert input argument to a proper box colnames = box.colnames; end xdata = zeros (n, d); for j = 1:d, xdata(:, j) = double (__stk_sampling_vdc_rr2__ (n, j)); end x = stk_dataframe (xdata, colnames); x.info = 'Created by stk_sampling_halton_rr2'; if nargin > 2, x = stk_rescale (x, [], box); end end % function stk_sampling_halton_rr2 %!error stk_sampling_halton_rr2 () % nargin < 1 %!error stk_sampling_halton_rr2 (10, 3, [], -1) % nargin > 3 %!test %! n = 300; d = 25; %! x = stk_sampling_halton_rr2 (n, d); %! assert (isequal (size (x), [n d])) %!test %! x = stk_sampling_halton_rr2 (1000, 3); %! y = double (x(end, :)); %! yref = [0.9052734375 0.028349336991312 0.74848]; %! assert (stk_isequal_tolrel (y, yref, 1e-13)); %% % Check that column names are properly set, if available in box %!test %! dim = 2; box = stk_hrect (dim); %! x = stk_sampling_halton_rr2 (5, dim, box); %! assert (isequal (x.colnames, {})); %!test %! dim = 2; cn = {'W', 'H'}; box = stk_hrect (dim, cn); %! x = stk_sampling_halton_rr2 (5, dim, box); %! assert (isequal (x.colnames, cn)); %% % Comparison with Scilab+lowdisc % % Matlab/Octave STK test script % % NREP = 10; % M = 1e5; % DIM = 20; % % tic; % for i = 1:NREP % x = stk_sampling_halton_rr2(M, DIM); % end; % t1 = toc/NREP; % fprintf('time elapsed: %.2e seconds\n', t1); % % fprintf('%.15f\n', x(1:5, 2)) % // Scilab lowdisc test script % % NREP = 10; % M = 1e5; % DIM = 20; % % tic(); % for i = 1:NREP, % rng = lowdisc_new("halton"); % rng = lowdisc_configure(rng, "-dimension", DIM); % rng = lowdisc_configure(rng, "-scrambling", "RR2"); % rng = lowdisc_startup(rng); % [rng, x] = lowdisc_next(rng, M); % rng = lowdisc_destroy(rng); % end % t = toc() / NREP % % mprintf('%.15f\n', x(1:9, 2)) stk/inst/sampling/stk_sampling_regulargrid.m0000664000175000017500000001031112617165721020330 0ustar bectbect% STK_SAMPLING_REGULARGRID builds a regular grid % % CALL: X = stk_sampling_regulargrid (N, DIM) % % builds a regular grid in the DIM-dimensional hypercube [0; 1]^DIM. If N is % an integer, a grid of size N is built; in this case, acceptable sizes are % such that N^(1/DIM) is an integer. If N is a vector of length N, a grid of % size prod(N) is built, with N(j) points on coordinate j. % % CALL: X = stk_sampling_regulargrid (N, DIM, BOX) % % does the same thing in the DIM-dimensional hyperrectangle specified by the % argument BOX, which is a 2 x DIM matrix where BOX(1, j) and BOX(2, j) are % the lower- and upper-bound of the interval on the j^th coordinate. % % See also: linspace % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_sampling_regulargrid (n, dim, box) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Read argument dim if (nargin < 2) || ((nargin < 3) && (isempty (dim))) dim = 1; % Default dimension elseif (nargin > 2) && (~ isempty (box)) dim = size (box, 2); end % Read argument 'box' if (nargin < 3) || isempty (box) box = stk_hrect (dim); % build a default box else box = stk_hrect (box); % convert input argument to a proper box end if length (n) == 1 n_coord = round (n^(1/dim)); if n_coord ^ dim ~= n, stk_error ('n^(1/dim) should be an integer', 'InvalidArgument'); end n = n_coord * ones (1, dim); else if length (n) ~= dim errmsg = 'n should either be a scalar or a vector of length d'; stk_error (errmsg, 'IncorrectSize'); end end % levels levels = cell (1, dim); xmin = box.data(1, :); xmax = box.data(2, :); for j = 1:dim, levels{j} = linspace (xmin(j), xmax(j), n(j)); end x = stk_factorialdesign (levels, box.colnames); x.info = 'Created by stk_sampling_regulargrid'; end % function stk_sampling_regulargrid %#ok<*TRYNC> %% % Check error for incorrect number of input arguments %!shared x, n, dim, box %! n = 9; dim = 2; box = [0, 0; 1, 1]; %!error x = stk_sampling_regulargrid (); %!test x = stk_sampling_regulargrid (n); %!test x = stk_sampling_regulargrid (n, dim); %!test x = stk_sampling_regulargrid (n, dim, box); %!error x = stk_sampling_regulargrid (n, dim, box, pi); %% % Check that the output is an stk_dataframe % (all stk_sampling_* functions should behave similarly in this respect) % and an stk_factorialdesign (special kind of stk_dataframe) %!assert (isa (x, 'stk_dataframe')); %!assert (isa (x, 'stk_factorialdesign')); %% % Check that column names are properly set, if available in box %!assert (isequal (x.colnames, {})); %!test %! cn = {'W', 'H'}; box = stk_hrect (box, cn); %! x = stk_sampling_regulargrid (n, dim, box); %! assert (isequal (x.colnames, cn)); %% % Check output argument %!test %! for dim = 1:3, %! n = 3^dim; %! x = stk_sampling_regulargrid(n, dim); %! assert(isequal(size(x), [n dim])); %! u = double(x); u = u(:); %! assert(~any(isnan(u) | isinf(u))); %! assert((min(u) >= 0) && (max(u) <= 1)); %! end %!test %! nn = [3 4 5]; %! for dim = 1:3, %! x = stk_sampling_regulargrid(nn(1:dim), dim); %! assert(isequal(size(x), [prod(nn(1:dim)) dim])); %! u = double(x); u = u(:); %! assert(~any(isnan(u) | isinf(u))); %! assert((min(u) >= 0) && (max(u) <= 1)); %! end stk/inst/stk_version.m0000664000175000017500000000212712617165721014010 0ustar bectbect% STK_VERSION returns STK's version number % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function v = stk_version () v = '2.3.4'; end % function stk_version stk/inst/paramestim/0000775000175000017500000000000012617165721013424 5ustar bectbectstk/inst/paramestim/stk_param_getdefaultbounds.m0000664000175000017500000000654312617165721021212 0ustar bectbect% STK_PARAM_GETDEFAULTBOUNDS [STK internal] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [lb, ub] = stk_param_getdefaultbounds (covariance_type, param0, xi, zi) if isobject (param0) % param0 is an object from a class that does not implement % stk_param_getdefaultbounds (otherwise we wouldn't have ended up here). % We assume that this is a choice of the designer of the parameter class, % and therefore return [] without a warning. lb = []; ub = []; elseif ~ isfloat (param0) stk_error ('Incorrect type for param0.', 'TypeMismatch'); else % constants opts = stk_options_get ('stk_param_getdefaultbounds'); TOLVAR = opts.tolvar; TOLSCALE = opts.tolscale; % bounds for the variance parameter log_empirical_variance = log (var (double (zi))); if log_empirical_variance == - Inf logvar_lb = param0(1) - TOLVAR; logvar_ub = param0(1) + TOLVAR; else logvar_lb = min (log_empirical_variance, param0(1)) - TOLVAR; logvar_ub = max (log_empirical_variance, param0(1)) + TOLVAR; end dim = size (xi, 2); switch covariance_type, case {'stk_materncov_aniso', 'stk_materncov_iso'} nu_lb = min (log (0.5), param0(2)); nu_ub = max (log (min (50, 10 * dim)), param0(2)); range_mid = param0(3:end); range_lb = range_mid(:) - TOLSCALE; range_ub = range_mid(:) + TOLSCALE; lb = [logvar_lb; nu_lb; range_lb]; ub = [logvar_ub; nu_ub; range_ub]; case {'stk_materncov32_aniso', 'stk_materncov32_iso', ... 'stk_materncov52_aniso', 'stk_materncov52_iso', ... 'stk_gausscov_aniso', 'stk_gausscov_iso'} range_mid = param0(2:end); range_lb = range_mid(:) - TOLSCALE; range_ub = range_mid(:) + TOLSCALE; lb = [logvar_lb; range_lb]; ub = [logvar_ub; range_ub]; otherwise warning (sprintf (['Unknown covariance type: %s, ' ... 'returning empty bounds.'], covariance_type)); %#ok lb = []; ub = []; end % switch end % if end % function stk_param_getdefaultbounds stk/inst/paramestim/stk_param_estim.m0000664000175000017500000002753312617165721016776 0ustar bectbect% STK_PARAM_ESTIM estimates the parameters of a covariance function % % CALL: PARAM = stk_param_estim (MODEL, XI, YI, PARAM0) % CALL: [PARAM, LNV] = stk_param_estim (MODEL, XI, YI, PARAM0) % % estimates the parameters PARAM of the covariance function in MODEL % from the data (XI, YI) using the restricted maximum likelihood (ReML) % method. A starting point PARAM0 must be provided. % % The observations are assumed to be noisy if MODEL.lognoisevariance is % not -inf. In this case, the variance of the noise is estimated if % MODEL.lognoisevariance is nan, and assumed known otherwise. The % estimated log-variance is returned as the second output argument LNV % (equal to MODEL.lognoisevariance when it is assumed to be known). % % CALL: [PARAM, LNV] = stk_param_estim (MODEL, XI, YI, PARAM0, LNV0) % % additionally provides an initial guess LNV0 for the logarithm of the % noise variance. In this case the observations are automatically assumed % to be noisy, and the value of MODEL.lognoisevariance is ignored. % % CALL: PARAM = stk_param_estim (MODEL, XI, YI, PARAM0, [], CRIT) % CALL: [PARAM, LNV] = stk_param_estim (MODEL, XI, YI, PARAM0, LNV0, CRIT) % % uses the estimation criterion CRIT instead of the default ReML criterion. % % EXAMPLES: see, e.g., stk_example_kb02, stk_example_kb03, stk_example_kb04, % stk_example_kb06, stk_example_misc02 % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2014 SUPELEC & A. Ravisankar % Copyright (C) 2011-2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Ashwin Ravisankar % Remi Stroh % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [paramopt, lnvopt, info] = stk_param_estim ... (model, xi, zi, param0, lnv0, criterion) if nargin > 6, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Empty is the same as not provided if nargin < 6, criterion = []; end if nargin < 5, lnv0 = []; end if nargin < 4, param0 = []; end % size checking: xi, zi zi_data = double (zi); if ~ isequal (size (zi_data), [stk_length(xi) 1]), errmsg = 'zi should be a column, with the same number of rows as xi.'; stk_error (errmsg, 'IncorrectSize'); end % Warn about special case: constant response if (std (zi_data) == 0) warning ('STK:stk_param_estim:ConstantResponse', ['Constant-response ' ... 'data: the output of stk_param_estim is likely to be unreliable.']); end % Backward compatiblity: accept model structures with missing lognoisevariance if (~ isfield (model, 'lognoisevariance')) || (isempty (model.lognoisevariance)) model.lognoisevariance = -inf; end % Should we estimate the variance of the noise, too ? if ~ isempty (lnv0) % lnv0 present => noise variance *must* be estimated do_estim_lnv = true; else % Otherwise, noise variance estimation happens when lnv has NaNs lnv0 = model.lognoisevariance; do_estim_lnv = any (isnan (lnv0)); if do_estim_lnv && (~ isscalar (lnv0)) stk_error (['Estimating the variance of the noise is not possible ' ... 'in the hetereoscedastic case yet. Sorry.'], 'IncorrectArgument'); end end % Default criterion: restricted likelihood (ReML method) if isempty (criterion) criterion = @stk_param_relik; end % param0: provide a value (if not provided as input argument) [param0, lnv0] = provide_param0_value (model, xi, zi, param0, lnv0); % lnv0: try stk_param_init_lnv if we still have no acceptable value if do_estim_lnv && (isnan (lnv0)) model.param = param0; lnv0 = stk_param_init_lnv (model, xi, zi); end % TODO: allow user-defined bounds [lb, ub] = stk_param_getdefaultbounds (model.covariance_type, param0, xi, zi); if do_estim_lnv [lblnv, ublnv] = get_default_bounds_lnv (model, lnv0, xi, zi); lb = [lb ; lblnv]; ub = [ub ; ublnv]; u0 = [param0(:); lnv0]; else u0 = param0(:); end switch do_estim_lnv case false, f = @(u)(f_ (model, u, xi, zi, criterion)); nablaf = @(u)(nablaf_ (model, u, xi, zi, criterion)); % note: currently, nablaf is only used with sqp in Octave case true, f = @(u)(f_with_noise_ (model, u, xi, zi, criterion)); nablaf = @(u)(nablaf_with_noise_ (model, u, xi, zi, criterion)); end bounds_available = (~ isempty(lb)) && (~ isempty(ub)); optim_display_level = stk_options_get ('stk_param_estim', 'optim_display_level'); % switch according to preferred optimizer optim_num = stk_select_optimizer (bounds_available); switch optim_num, case 1, % Octave / sqp if ~ strcmp (optim_display_level, 'off') warning (sprintf (['Ignoring option: ' ... 'optim_display_level = %s'], optim_display_level)); end [u_opt, crit_opt] = sqp (u0, {f, nablaf}, [], [], lb, ub, [], 1e-5); case {2, 3}, % Matlab options = optimset ('Display', optim_display_level, ... 'MaxFunEvals', 300, 'TolFun', 1e-5, 'TolX', 1e-6); if optim_num == 2, % Matlab / fminsearch (Nelder-Mead) [u_opt, crit_opt] = fminsearch (f, u0, options); else % Matlab / fmincon options = optimset (options, 'GradObj', 'on'); try % try to use the interior-point algorithm, which has been % found to provide satisfactory results in many cases options = optimset (options, 'algorithm', 'interior-point'); catch % the 'algorithm' option does not exist in some old versions of % matlab (e.g., version 3.1.1 provided with r2007a)... err = lasterror (); if ~ strcmpi (err.identifier, ... 'matlab:optimset:invalidparamname') rethrow (err); end end [u_opt, crit_opt] = fmincon (f, u0, ... [], [], [], [], lb, ub, [], options); end otherwise, error ('Unexpected value returned by stk_select_optimizer.'); end % switch if do_estim_lnv lnvopt = u_opt(end); u_opt(end) = []; else lnvopt = model.lognoisevariance; end if isfloat (param0) % if a floating-point array was provided, return one also paramopt = u_opt; else % if an object of some user-defined class was provided, try to return an % object of the same class try paramopt = param0; paramopt(:) = u_opt; catch paramopt = u_opt; end end % if % Create 'info' structure, if requested if nargout > 2, info.criterion = criterion; info.crit_opt = crit_opt; info.lower_bounds = lb; info.upper_bounds = ub; end end % function stk_param_estim ------------------------------------------------- %#ok<*CTCH,*LERR,*SPWRN,*WNTAG> %--- The objective function and its gradient ---------------------------------- function [l, dl] = f_ (model, u, xi, zi, criterion) model.param(:) = u; if nargout == 1, l = criterion (model, xi, zi); else [l, dl] = criterion (model, xi, zi); end end % function f_ function dl = nablaf_ (model, u, xi, zi, criterion) model.param(:) = u; [l_ignored, dl] = criterion (model, xi, zi); %#ok end % function nablaf_ function [l, dl] = f_with_noise_ (model, u, xi, zi, criterion) model.param(:) = u(1:end-1); model.lognoisevariance = u(end); if nargout == 1, l = criterion (model, xi, zi); else [l, dl, dln] = criterion (model, xi, zi); dl = [dl; dln]; end end % function f_with_noise_ function dl = nablaf_with_noise_ (model, u, xi, zi, criterion) model.param(:) = u(1:end-1); model.lognoisevariance = u(end); [l_ignored, dl, dln] = criterion (model, xi, zi); %#ok dl = [dl; dln]; end % function nablaf_with_noise_ function [lblnv,ublnv] = get_default_bounds_lnv ... % -------------------------- (model, lnv0, xi, zi) %#ok TOLVAR = 0.5; % Bounds for the variance parameter empirical_variance = var(zi); lblnv = log (eps); ublnv = log (empirical_variance) + TOLVAR; % Make sure that lnv0 falls within the bounds if ~ isempty (lnv0) lblnv = min (lblnv, lnv0 - TOLVAR); ublnv = max (ublnv, lnv0 + TOLVAR); end end % function get_default_bounds_lnv ------------------------------------------ function [param0, lnv0] = provide_param0_value ... % --------------------------- (model, xi, zi, param0, lnv0) % param0: try to use input argument first if ~ isempty (param0) % Cast param0 into an object of the appropriate type if isfloat (model.param) param0 = double (param0); elseif isfloat (param0) param_tmp = model.param; param_tmp(:) = param0; % Note: if model.param is an object, this is actually a call to subsasgn % in disguise => parameter classes *must* support this form of indexing. param0 = param_tmp; elseif ~ isa (param0, class (model.param)) stk_error ('Incorrect type for param0.', 'TypeMismatch'); end % Test if param0 contains nans if any (isnan (param0(:))) warning ('param0 has nans, using model.param instead'); param0 = []; end end % param0: try to use model.param if we still have no acceptable value if (isempty (param0)) && (~ any (isnan (model.param(:)))) param0 = model.param; end % param0: try stk_param_init if we still have no acceptable value if isempty (param0) model.lognoisevariance = lnv0; [param0, lnv0] = stk_param_init (model, xi, zi); end end % function provide_param0_value %!shared f, xi, zi, NI, param0, model %! %! f = @(x)(- (0.8 * x + sin (5 * x + 1) + 0.1 * sin (10 * x)) ); %! DIM = 1; NI = 20; box = [-1.0; 1.0]; %! xi = stk_sampling_regulargrid (NI, DIM, box); %! %! SIGMA2 = 1.0; % variance parameter %! NU = 4.0; % regularity parameter %! RHO1 = 0.4; % scale (range) parameter %! param0 = log ([SIGMA2; NU; 1/RHO1]); %! %! model = stk_model ('stk_materncov_iso'); %!test % noiseless %! zi = stk_feval (f, xi); %! param1 = stk_param_estim (model, xi, zi, param0); %! param2 = stk_param_estim (model, xi, zi, param0, [], @stk_param_relik); %! % We cannot assume a DETERMINISTIC optimization algorithm %! % (for some reason, Octave's sqp is not exactly deterministic) %! assert (stk_isequal_tolrel (param1, param2, 1e-2)) %!test % noisy %! NOISE_STD_TRUE = 0.1; %! NOISE_STD_INIT = 1e-5; %! zi = zi + NOISE_STD_TRUE * randn(NI, 1); %! model.lognoisevariance = 2 * log(NOISE_STD_INIT); %! [param, lnv] = stk_param_estim ... %! (model, xi, zi, param0, model.lognoisevariance); % Incorrect number of input arguments %!error param = stk_param_estim () %!error param = stk_param_estim (model); %!error param = stk_param_estim (model, xi); %!error param = stk_param_estim (model, xi, zi, param0, log(eps), @stk_param_relik, pi); %!test % Constant response %! model = stk_model ('stk_materncov52_iso'); %! n = 10; x = stk_sampling_regulargrid (n, 1, [0; 1]); z = ones (size (x)); %! param = stk_param_estim (model, x, z, model.param); %! assert ((all (isfinite (param))) && (length (param) == 2)); stk/inst/paramestim/stk_param_init_lnv.m0000664000175000017500000000677512617165721017504 0ustar bectbect% STK_PARAM_INIT_LNV provides a rough estimate of the variance of the noise % % CALL: LNV = stk_param_init_lnv (MODEL, XI, YI) % % returns a rough estimate of the log of the noise variance computed using % the given MODEL and data (XI, YI), using the restricted maximum likelihood % (ReML) method. It selects the maximizer of the ReML criterion out of a % list of possible values. % % NOTE: assumption on the model % % The model is assumed to be a stationary Gaussian process, with % model.param(1) corresponding to the log of the Gaussian process variance. % This assumption is currently fulfilled by all the models shipped with STK. % % See also: stk_param_estim, stk_param_init % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function lnv = stk_param_init_lnv (model, xi, zi) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % size checking: xi, zi if ~ isequal (size (zi), [size(xi, 1) 1]), errmsg = 'zi should be a column, with the same number of rows as xi.'; stk_error (errmsg, 'IncorrectSize'); end % Warn about special case: constant response if (std (double (zi)) == 0) warning ('STK:stk_param_estim_lnv:ConstantResponse', ['Constant- ' ... 'response data: the output of stk_param_estim_lnv is likely ' ... 'to be unreliable.']); end % Backward compatiblity: accept model structures with missing lognoisevariance if (~ isfield (model, 'lognoisevariance')) || (isempty (model.lognoisevariance)) model.lognoisevariance = -inf; end % We will work with the ratio eta = sigma2_noise / sigma2 log_eta_min = -15; % exp(-15) = 3e-7 approx -> very small noise log_eta_max = +15; % exp(+15) = 3e+7 approx -> very large noise log_eta_list = linspace (log_eta_min, log_eta_max, 5); % Initialize parameter search log_eta_best = nan; aLL_best = +inf; % Try all values from log_eta_list for log_eta = log_eta_list model.lognoisevariance = model.param(1) + log_eta; aLL = stk_param_relik (model, xi, zi); if (~ isnan (aLL)) && (aLL < aLL_best) log_eta_best = log_eta; aLL_best = aLL; end end if isinf (aLL_best) errmsg = 'Couldn''t find reasonable parameter values... ?!?'; stk_error (errmsg, 'AlgorithmFailure'); end lnv = model.param(1) + log_eta_best; end % function stk_param_init_lnv %!test %! f = @(x)(- (0.8 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); %! ni = 20; %! xi = (linspace (-1, 1, ni))' + 0.2 * (randn (ni, 1)); %! zi = stk_feval (f, xi); %! %! model = stk_model ('stk_materncov_iso'); %! model.param = log ([1; 5/2; 1/0.4]); %! lnv = stk_param_init_lnv (model, xi, zi); %! %! assert ((isscalar (lnv)) && (lnv > -30) && (lnv < 30)); stk/inst/paramestim/stk_param_gls.m0000664000175000017500000000724712617165721016442 0ustar bectbect% STK_PARAM_GLS computes a generalised least squares estimate % % CALL: BETA = stk_param_gls (MODEL, XI, ZI) % % computes the generalised least squares estimate BETA of the vector of % coefficients for the linear part of MODEL, where XI and ZI stand for % the evaluation points and observed responses, respectively. % % CALL: [BETA, SIGMA2] = stk_param_gls (MODEL, XI, ZI) % % also returns the associated unbiased estimate SIGMA2 of sigma^2, assu- % ming that the actual covariance matrix of the Gaussian process part of % the model is sigma^2 K, with K the covariance matrix built from MODEL. % % SIGMA2 is actually the "best" unbiased estimate of sigma^2 : % % 1 % SIGMA2 = ----- * || ZI - P BETA ||^2_{K^{-1}} % n - r % % where n is the number of observations, r the length of BETA, P the % design matrix for the linear part of the model, and || . ||_{K^{-1}} % the norm associated to the positive definite matrix K^{-1}. It is the % best estimate with respect to the quadratic risk, among all unbiased % estimates which are quadratic in the residuals. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2014 SUPELEC & A. Ravisankar % Copyright (C) 2011-2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Ashwin Ravisankar % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [beta, sigma2, L] = stk_param_gls (model, xi, zi) n = size (xi, 1); % Build the covariance matrix and the design matrix [K, P] = stk_make_matcov (model, xi); % Cast zi into a double-precision array zi = double (zi); % Compute the Generalized Least Squares (GLS) estimate L = stk_cholcov (K, 'lower'); W = L \ P; u = L \ zi; beta = (W' * W) \ (W' * u); if nargin > 1, % Assuming that the actual covariance matrice is sigma^2 K, compute the % "best" unbiased estimate of sigma2 (best wrt the quadratic risk, among % all unbiased estimates which are quadratic in the residuals) r = length (beta); sigma2 = 1 / (n - r) * sum ((u - W * beta) .^ 2); end end % end function stk_param_gls %!shared xi, zi, model, beta, sigma2 %! xi = (1:10)'; zi = sin (xi); %! model = stk_model ('stk_materncov52_iso'); %! model.param = [0.0 0.0]; %! model.order = 0; % this is the default %!test [beta, sigma2] = stk_param_gls (model, xi, zi); %!assert (stk_isequal_tolabs (beta, 0.1346064, 1e-6)) %!assert (stk_isequal_tolabs (sigma2, 0.4295288, 1e-6)) %!test %! model.order = 1; %! [beta, sigma2] = stk_param_gls (model, xi, zi); %!assert (stk_isequal_tolabs (beta, [0.4728342; -0.0614960], 1e-6)) %!assert (stk_isequal_tolabs (sigma2, 0.4559431, 1e-6)) %!test %! model.order = -1; %! [beta, sigma2] = stk_param_gls (model, xi, zi); %!assert (isequal (beta, zeros (0, 1))) %!assert (stk_isequal_tolabs (sigma2, 0.3977993, 1e-6)) stk/inst/paramestim/stk_param_relik.m0000664000175000017500000001611312617165721016753 0ustar bectbect% STK_PARAM_RELIK computes the restricted likelihood of a model given data % % CALL: [ARL, dARL_dtheta, dARL_dLNV] = stk_param_relik (MODEL, XI, YI) % % computes the opposite of the restricted likelihood (denoted by ARL for % Anti-Restricted Likelihood) of MODEL given the data (XI, YI). The function % also returns the gradient dARL_dtheta of ARL with respect to the parameters % of the covariance function and the derivative dARL_dLNV of ARL with respect % to the logarithm of the noise variance. % % EXAMPLE: see paramestim/stk_param_estim.m % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [rl, drl_param, drl_lnv] = stk_param_relik (model, xi, yi) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Backward compatiblity: accept model structures with missing lognoisevariance if (~ isfield (model, 'lognoisevariance')) || (isempty (model.lognoisevariance)) model.lognoisevariance = - inf; end % Ensure that param is a column vector (note: in the case where model.param is % an object, this is actually a call to subsasgn() in disguise). param = model.param(:); PARAMPRIOR = isfield (model, 'prior'); NOISEPRIOR = isfield (model, 'noiseprior'); n = size (xi, 1); %% Compute the (opposite of) the restricted log-likelihood [K, P] = stk_make_matcov (model, xi); q = size (P, 2); if q == 0 % Special case: simple kriging G = K; else % General case [Q, R_ignored] = qr (P); %#ok %the second argument *must* be here W = Q(:, (q+1):n); % Compute G = W' * K * W M = (stk_cholcov (K)) * W; G = (M') * M; % Check if G is (at least close to) symmetric Delta = G - G'; s = sqrt (diag (G)); if any (abs (Delta) > eps * (s * s')) warning ('STK:stk_param_relik:NumericalAccuracyProblem', ... 'The computation of G = W'' * K * W is inaccurate.'); G = 0.5 * (G + G'); % Make it at least symmetric end end % Cholesky factorization: G = C' * C, with upper-triangular C C = stk_cholcov (G); % Compute log (det (G)) using the Cholesky factor ldetWKW = 2 * sum (log (diag (C))); % Compute (W' yi)' * G^(-1) * (W' yi) as u' * u, with u = C' \ (W' * yi) if q == 0 % Simple kriging u = linsolve (C, double (yi), struct ('UT', true, 'TRANSA', true)); else % General case u = linsolve (C, W' * double (yi), struct ('UT', true, 'TRANSA', true)); end attache = sum (u .^ 2); rl = 0.5 * ((n - q) * log(2 * pi) + ldetWKW + attache); %% Add priors if PARAMPRIOR delta_p = param - model.prior.mean; rl = rl + 0.5 * delta_p' * model.prior.invcov * delta_p; end if NOISEPRIOR delta_lnv = model.lognoisevariance - model.noiseprior.mean; rl = rl + 0.5 * (delta_lnv ^ 2) / model.noiseprior.var; end %% Compute gradient if nargout >= 2 nbparam = length(param); drl_param = zeros(nbparam, 1); if q == 0 % Simple kriging H = inv (G); else % General case F = linsolve (C, W', struct ('UT', true, 'TRANSA', true)); H = F' * F; % = W * G^(-1) * W' end z = H * double (yi); for diff = 1:nbparam, V = feval (model.covariance_type, model.param, xi, xi, diff); drl_param(diff) = 1/2 * (sum (sum (H .* V)) - z' * V * z); end if PARAMPRIOR drl_param = drl_param + model.prior.invcov * delta_p; end if nargout >= 3, if model.lognoisevariance == -inf drl_lnv = nan; else diff = 1; V = stk_noisecov (n, model.lognoisevariance, diff); drl_lnv = 1/2 * (sum (sum (H .* V)) - z' * V * z); if NOISEPRIOR drl_lnv = drl_lnv + delta_lnv / model.noiseprior.var; end end end end end % function stk_param_relik %!shared f, xi, zi, NI, model, J, dJ1, dJ2 %! %! f = @(x)(- (0.8 * x(:, 1) + sin (5 * x(:, 2) + 1) ... %! + 0.1 * sin (10 * x(:, 3)))); %! DIM = 3; NI = 20; box = repmat ([-1.0; 1.0], 1, DIM); %! xi = stk_sampling_halton_rr2 (NI, DIM, box); %! zi = stk_feval (f, xi); %! %! SIGMA2 = 1.0; % variance parameter %! NU = 4.0; % regularity parameter %! RHO1 = 0.4; % scale (range) parameter %! %! model = stk_model('stk_materncov_aniso'); %! model.param = log([SIGMA2; NU; 1/RHO1 * ones(DIM, 1)]); %!error [J, dJ1, dJ2] = stk_param_relik (); %!error [J, dJ1, dJ2] = stk_param_relik (model); %!error [J, dJ1, dJ2] = stk_param_relik (model, xi); %!test [J, dJ1, dJ2] = stk_param_relik (model, xi, zi); %!error [J, dJ1, dJ2] = stk_param_relik (model, xi, zi, pi); %!test %! TOL_REL = 0.01; %! assert (stk_isequal_tolrel (J, 21.6, TOL_REL)); %! assert (stk_isequal_tolrel (dJ1, [4.387 -0.1803 0.7917 0.1392 2.580]', TOL_REL)); %! assert (isnan (dJ2)); %!shared xi, zi, model, TOL_REL %! xi = [-1 -.6 -.2 .2 .6 1]'; %! zi = [-0.11 1.30 0.23 -1.14 0.36 -0.37]'; %! model = stk_model ('stk_materncov_iso'); %! model.param = log ([1.0 4.0 2.5]); %! model.lognoisevariance = log (0.01); %! TOL_REL = 0.01; %!test % Another simple 1D check %! [ARL, dARL_dtheta, dARL_dLNV] = stk_param_relik (model, xi, zi); %! assert (stk_isequal_tolrel (ARL, 6.327, TOL_REL)); %! assert (stk_isequal_tolrel (dARL_dtheta, [0.268 0.0149 -0.636]', TOL_REL)); %! assert (stk_isequal_tolrel (dARL_dLNV, -1.581e-04, TOL_REL)); %!test % Same 1D test, with model.order = -1, to test simple kriging %! model.order = - 1; %! [ARL, dARL_dtheta, dARL_dLNV] = stk_param_relik (model, xi, zi); %! assert (stk_isequal_tolrel (ARL, 7.475, TOL_REL)); %! assert (stk_isequal_tolrel (dARL_dtheta, [0.765 0.0238 -1.019]', TOL_REL)); %! assert (stk_isequal_tolrel (dARL_dLNV, 3.0517e-03, TOL_REL)); %!test % Check the gradient on a 2D test case %! %! f = @stk_testfun_braninhoo; %! DIM = 2; %! BOX = [[-5; 10], [0; 15]]; %! NI = 20; %! TOL_REL = 1e-2; %! DELTA = 1e-6; %! %! model = stk_model ('stk_materncov52_iso', DIM); %! xi = stk_sampling_halton_rr2 (NI, DIM, BOX); %! zi = stk_feval (f, xi); %! %! model.param = [1 1]; %! [r1 dr] = stk_param_relik (model, xi, zi); %! %! model.param = model.param + DELTA * [0 1]; %! r2 = stk_param_relik (model, xi, zi); %! %! assert (stk_isequal_tolrel (dr(2), (r2 - r1) / DELTA, TOL_REL)); stk/inst/paramestim/stk_param_init.m0000664000175000017500000004010312617165721016604 0ustar bectbect% STK_PARAM_INIT provides a starting point for stk_param_estim % % CALL: PARAM = stk_param_init (MODEL, XI, YI) % % provides a quick and dirty estimate of the parameters of MODEL based on the % data (XI, YI), that can be used as a starting point for stk_param_estim. It % selects the maximizer of the ReML criterion out of a list of possible values % given data (XI, YI). This syntax is appropriate for noiseless observations % and for noisy observations with known noise variance (i.e., when the % 'lognoisevariance' field in MODEL is either -Inf or has a finite value). % % CALL: [PARAM, LNV] = stk_param_init (MODEL, XI, YI) % % also returns a value for the 'lognoisevariance' field. In the case of % noiseless observations or noisy observations with known noise variance, this % is simply the value that was provided by the user in MODEL.lognoisevariance. % In the case where MODEL.lognoisevariance is NaN (noisy observation with % unknown noise variance), LNV is estimated by stk_param_init together with % PARAM. % % CALL: [PARAM, LNV] = stk_param_init (MODEL, XI, YI, BOX) % % takes into account the (hyper-rectangular) domain on which the model is % going to be used. It is used in the heuristics that determines the list of % parameter values mentioned above. BOX should be a 2 x DIM matrix with BOX(1, % j) and BOX(2, j) being the lower- and upper-bound of the interval on the % j^th coordinate, with DIM being the dimension of XI, DIM = size(XI,2). If % provided, If missing or empty, the BOX argument defaults to [min(XI); % max(XI)]. % % CALL: [PARAM, LNV] = stk_param_init (MODEL, XI, YI, BOX, DO_ESTIM_LNV) % % with DO_ESTIM_LNV = TRUE forces the estimation of the variance of the noise, % regardless of the value of MODEL.lognoisevariance. If FALSE, it prevents % estimation of the variance of the noise, which is only possible if the % 'lognoisevariance' field in MODEL is either -Inf or has a finite value. % % See also stk_example_kb02, stk_example_kb03, stk_example_misc03 % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2012-2014 SUPELEC % % Authors: Julien Bect % Paul Feliot % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [param, lnv] = stk_param_init (model, xi, zi, box, do_estim_lnv) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if ~ isequal (size (zi), [size(xi, 1) 1]), errmsg = 'zi should be a column, with the same number of rows as xi.'; stk_error (errmsg, 'IncorrectSize'); end %--- first, default values for arguments 'box' and 'noisy' --------------------- if nargin < 4, box = []; end if ~ isa (box, 'stk_hrect') if isempty (box), box = stk_boundingbox (xi); % Default: bounding box else box = stk_hrect (box); end end %--- lognoisevariance ? -------------------------------------------------------- % Backward compatiblity: accept model structures with missing lognoisevariance if (~ isfield (model, 'lognoisevariance')) || (isempty (model.lognoisevariance)) model.lognoisevariance = - inf; end lnv = model.lognoisevariance; % Noise variance estimation is not supported in the heteroscedastic case if (~ isscalar (lnv)) && (any (isnan (lnv))) stk_error (['model.lognoisevariance is non-scalar and contains nans. ' ... 'Noise variance estimation is not supported in the heteroscedastic ' ... 'case '], 'InvalidArgument'); end % Estimation of noise variance ? % * if do_estim_lnv is provided, use it to decide % * if not, estimation occurs when lnv is nan if nargin < 5 if isscalar (lnv) % In the homoscedastic case, estimate noise variance iff lnv is nan do_estim_lnv = isnan (lnv); else % Noise variance estimation is not supported in the heteroscedastic % case (see above). Heteroscedastic case with known noise variance: do_estim_lnv = false; end else % do_estim_lnv has been provided if isscalar (lnv) if do_estim_lnv lnv = nan; elseif isnan (lnv) stk_error (sprintf ... (['do_estim_lnv is false, but model.lognoisevariance ' ... 'is nan. If you don''t want the noise variance to be ' ... 'estimated, you must provide a value for it!']), ... 'MissingParameterValue'); end else % Noise variance estimation is not supported in the heteroscedastic % case (see above). if do_estim_lnv stk_error (['Noise variance estimation is not supported in the ' ... 'heteroscedastic case '], 'InvalidArgument'); end end end if (do_estim_lnv) && (nargout < 2) warning (['stk_param_init will be computing an estimation of the ' ... 'variance of the noise, perhaps should you call the function ' ... 'with two output arguments?']); end %--- linear model -------------------------------------------------------------- if isnan (model.order), lm = model.lm; else switch model.order case -1, % 'simple' kriging lm = stk_lm_null; case 0, % 'ordinary' kriging lm = stk_lm_constant; case 1, % affine trend lm = stk_lm_affine; case 2, % quadratic trend lm = stk_lm_quadratic; otherwise, % syntax error error ('model.order should be in {-1,0,1,2}'); end end %--- then, each type of covariance is dealt with specifically ------------------ switch model.covariance_type case 'stk_materncov_iso' nu = 5/2 * size (xi, 2); [param, lnv] = paraminit_ (xi, zi, box, nu, lm, lnv); case 'stk_materncov_aniso' nu = 5/2 * size (xi, 2); xi = stk_normalize (xi, box); [param, lnv] = paraminit_ (xi, zi, [], nu, lm, lnv); param = [param(1:2); param(3) - log(diff(box, [], 1))']; case 'stk_materncov32_iso' [param, lnv] = paraminit_ (xi, zi, box, 3/2, lm, lnv); param = [param(1); param(3)]; case 'stk_materncov32_aniso' xi = stk_normalize (xi, box); [param, lnv] = paraminit_ (xi, zi, [], 3/2, lm, lnv); param = [param(1); param(3) - log(diff(box, [], 1))']; case 'stk_materncov52_iso' [param, lnv] = paraminit_ (xi, zi, box, 5/2, lm, lnv); param = [param(1); param(3)]; case 'stk_materncov52_aniso' xi = stk_normalize (xi, box); [param, lnv] = paraminit_ (xi, zi, [], 5/2, lm, lnv); param = [param(1); param(3) - log(diff(box, [], 1))']; case 'stk_gausscov_iso' [param, lnv] = paraminit_ (xi, zi, box, +Inf, lm, lnv); param = [param(1); param(3)]; case 'stk_gausscov_aniso' xi = stk_normalize (xi, box); [param, lnv] = paraminit_ (xi, zi, [], +Inf, lm, lnv); param = [param(1); param(3) - log(diff(box, [], 1))']; otherwise errmsg = 'Unsupported covariance type.'; stk_error (errmsg, 'IncorrectArgument'); end end % function stk_param_init function [param, lnv] = paraminit_ (xi, zi, box, nu, lm, lnv) % Check for special case: constant response if (std (double (zi)) == 0) warning ('STK:stk_param_init:ConstantResponse', ... 'Parameter estimation is impossible with constant-response data.'); param = [0 log(nu) 0]; if any (isnan (lnv)), lnv = 0; end return % Return some default values end d = size (xi, 2); model = stk_model ('stk_materncov_iso'); model.order = nan; model.lm = lm; model.lognoisevariance = lnv; % list of possible values for the ratio eta = sigma2_noise / sigma2 if (isscalar (lnv) && (lnv ~= -inf)) % Homoscedastic noisy case, with known or unknown noise variance eta_list = 10 .^ (-6:3:0); else % Noiseless case or heteroscedastic noisy case (known noise variance) eta_list = 0; end % list of possible values for the range parameter if isempty (box) % assume box = repmat([0; 1], 1, d) box_diameter = sqrt (d); else box_diameter = sqrt (sum (diff (box) .^ 2)); end rho_max = 2 * box_diameter; rho_min = box_diameter / 50; rho_list = logspace (log10 (rho_min), log10 (rho_max), 5); % Initialize parameter search eta_best = NaN; rho_best = NaN; sigma2_best = NaN; aLL_best = +Inf; % Homoscedastic case ? homoscedastic = (isscalar (lnv)); % Try all possible combinations of rho and eta from the lists for eta = eta_list for rho = rho_list % First use sigma2 = 1.0 model.param = [0.0, log(nu), -log(rho)]; % The same code works for the noiseless case and for the case where lnv % must be estimated (in the first case, eta = 0 and thus lnv is -inf) if (eta == 0) || (homoscedastic && (isnan (lnv))) model.lognoisevariance = log (eta); [beta_ignored, sigma2] = stk_param_gls (model, xi, zi); %#ok if ~ (sigma2 > 0), continue; end log_sigma2 = log (sigma2); model.lognoisevariance = log (eta * sigma2); else % Known variances (homo- and hetero-scedastic cases) model.param = [0.0, log(nu), -log(rho)]; log_sigma2 = (mean (lnv)) - (log (eta)); sigma2 = exp (log_sigma2); end % Now, compute the antilog-likelihood model.param(1) = log_sigma2; aLL = stk_param_relik (model, xi, zi); if ~isnan(aLL) && (aLL < aLL_best) eta_best = eta; rho_best = rho; aLL_best = aLL; sigma2_best = sigma2; end end end if isinf (aLL_best) errmsg = 'Couldn''t find reasonable parameter values... ?!?'; stk_error (errmsg, 'AlgorithmFailure'); end param = log ([sigma2_best; nu; 1/rho_best]); if (isscalar (lnv)) && (isnan (lnv)) % Homoscedatic case with unknown variance... Here is our estimate: lnv = log (eta_best * sigma2_best); end end % function paraminit_ %!test %! xi = (1:10)'; zi = sin (xi); %! model = stk_model ('stk_materncov52_iso'); %! model.param = stk_param_init (model, xi, zi, [1; 10], false); %! xt = (1:9)' + 0.5; zt = sin (xt); %! zp = stk_predict (model, xi, zi, xt); %! assert (sum ((zt - zp.mean) .^ 2) < 1e-3); %!test % check equivariance of parameter estimates %! f = @(x) sin (x); %! xi = stk_sampling_regulargrid (10, 1); zi = stk_feval (f, xi); %! shift = 1000; scale = 0.01; %! model = stk_model ('stk_materncov32_iso'); %! p1 = stk_param_init (model, xi, zi); %! p2 = stk_param_init (model, xi, shift + scale .* zi); %! assert (stk_isequal_tolabs (p2(1), p1(1) + log (scale^2), 1e-10)) %! assert (stk_isequal_tolabs (p2(2), p1(2), eps)) %!shared xi, zi, BOX, xt, zt %! %! f = @(x)(- (0.8 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); %! DIM = 1; % Dimension of the factor space %! BOX = [-1.0; 1.0]; % Factor space %! %! xi = stk_sampling_regulargrid (20, DIM, BOX); % Evaluation points %! zi = stk_feval (f, xi); % Evaluation results %! %! NT = 400; % Number of points in the grid %! xt = stk_sampling_regulargrid (NT, DIM, BOX); % Generate a regular grid %! zt = stk_feval (f, xt); % Values of f on the grid %!test %! model = stk_model ('stk_materncov_iso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test %! model = stk_model ('stk_materncov_aniso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test %! model = stk_model ('stk_materncov32_iso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test %! model = stk_model ('stk_materncov32_aniso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test %! model = stk_model ('stk_materncov52_iso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test %! model = stk_model ('stk_materncov52_aniso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test %! model = stk_model ('stk_gausscov_iso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test %! model = stk_model ('stk_gausscov_aniso'); %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!test % Homoscedastic case / do_estim_lnv = true %! model = stk_model ('stk_materncov32_iso'); %! [model.param, model.lognoisevariance] = ... %! stk_param_init (model, xi, zi, BOX, true); %! [model.param, model.lognoisevariance] = ... %! stk_param_estim (model, xi, zi); %! zp = stk_predict (model, xi, zi, xt); %! assert (model.lognoisevariance > -inf); %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!error % Homoscedastic case / do_estim_lnv = false / model.lnv = nan %! model = stk_model ('stk_materncov32_iso'); %! model.lognoisevariance = nan; % not compatible with do_estim_lnv == false %! [model.param, model.lognoisevariance] = ... %! stk_param_init (model, xi, zi, BOX, false); %!error % Heteroscedastic case / do_estim_lnv = true %! model = stk_model ('stk_materncov32_iso'); %! lnv = log ((100 + rand (size (zi))) / 1e6); %! model.lognoisevariance = lnv; % here we say that lnv is known %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX, true); %!test % Heteroscedastic case / known noise variance %! model = stk_model ('stk_materncov32_iso'); %! lnv = log ((100 + rand (size (zi))) / 1e6); %! model.lognoisevariance = lnv; % here we say that lnv is known %! [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); %! model.param = stk_param_estim (model, xi, zi, param0); %! zp = stk_predict (model, xi, zi, xt); %! assert (isequal (model.lognoisevariance, lnv)); % should be untouched %! assert (max ((zp.mean - zt) .^ 2) < 1e-3) %!shared model, x, z %! model = stk_model ('stk_materncov52_iso'); %! n = 10; x = stk_sampling_regulargrid (n, 1, [0; 1]); z = ones (size (x)); %!test % Constant response, noiseless model %! [param, lnv] = stk_param_init (model, x, z); %! assert ((all (isfinite (param))) && (length (param) == 2)); %! assert (isequal (lnv, -inf)); %!test % Constant response, noisy model %! model.lognoisevariance = nan; %! [param, lnv] = stk_param_init (model, x, z); %! assert ((all (isfinite (param))) && (length (param) == 2)); %! assert (isscalar (lnv) && isfinite (lnv)); stk/inst/config/0000775000175000017500000000000012617165722012530 5ustar bectbectstk/inst/config/stk_config_path.m0000664000175000017500000000664012617165722016056 0ustar bectbect% STK_CONFIG_PATH returns the searchpath of STK % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function path = stk_config_path (root) if nargin == 0, root = stk_config_getroot (); end % Safer than calling isoctave directly (this allows stk_config_path to work % even if STK has already been partially uninstalled or is not properly installed) isoctave = (exist ('OCTAVE_VERSION', 'builtin') == 5); % Are we using STK installed as an octave package ? STK_OCTAVE_PACKAGE = true; % Don't include the root in the path when STK is used as an Octave package % (otherwise we get an infinite PKG_ADD loop) if STK_OCTAVE_PACKAGE path = {}; else path = {root}; end % main function folders path = [path {... fullfile(root, 'arrays' ) ... fullfile(root, 'arrays', 'generic' ) ... fullfile(root, 'core' ) ... fullfile(root, 'covfcs' ) ... fullfile(root, 'lm' ) ... fullfile(root, 'paramestim' ) ... fullfile(root, 'sampling' ) ... fullfile(root, 'utils' ) }]; % 'misc' folder and its subfolders misc = fullfile (root, 'misc'); path = [path {... fullfile(misc, 'design' ) ... fullfile(misc, 'dist' ) ... fullfile(misc, 'distrib' ) ... fullfile(misc, 'error' ) ... fullfile(misc, 'optim' ) ... fullfile(misc, 'options' ) ... fullfile(misc, 'parallel') ... fullfile(misc, 'plot' ) ... fullfile(misc, 'specfun' ) ... fullfile(misc, 'test' ) ... fullfile(misc, 'text' ) }]; % folders that contain examples path = [path {... fullfile(root, 'examples', '01_kriging_basics' ) ... fullfile(root, 'examples', '02_design_of_experiments') ... fullfile(root, 'examples', '03_miscellaneous' ) ... fullfile(root, 'examples', 'test_functions' ) }]; % Fix a problem with private folders in Octave 3.2.x % (add private folders to the path to make STK work...) if isoctave v = version; if strcmp (v(1:4), '3.2.') test_path = [path {... fullfile(root, 'arrays', '@stk_dataframe') ... fullfile(root, 'arrays', '@stk_factorialdesign') ... fullfile(root, 'core', '@stk_kreq_qr')}]; private_path = {}; for i = 1:(length (test_path)) p = fullfile (test_path{i}, 'private'); if exist (p, 'dir') private_path = [private_path {p}]; end end path = [path private_path]; end end end % function stk_config_path stk/inst/config/stk_config_mole.m0000664000175000017500000001141312617165716016053 0ustar bectbect% Initialization script for the Matlab/Octave Langage Extension (MOLE). % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_config_mole (root, do_addpath, prune_unused) mole_dir = fullfile (root, 'misc', 'mole'); % do_addpath: Do we want to add the subdirectories to the path ? % Defaults to true, for use in stk_init.m, typically. % do_appath = false is used in post_install.m, for octave packages. if nargin < 2 do_addpath = true; end % prune_unused: Do we want to remove unused subdirectories ? % Defaults to false, for use in stk_init.m, typically. % prune_unused = true is used in post_install.m, for octave packages. if nargin < 3 prune_unused = false; end if (exist ('OCTAVE_VERSION', 'builtin') == 5), % if Octave recursive_rmdir_state = confirm_recursive_rmdir (0); end opts = {mole_dir, do_addpath, prune_unused}; %--- isoctave ----------------------------------------------------------------- install_mole_function ('isoctave', opts{:}); % Note: if do_addpath is false, isoctave is not added to the search % path. Therefore, it cannot be assumed below that isoctave is defined. %--- Provide missing octave functions for Matlab users ------------------------ % TODO: extract functions that are REALLY needed in separate directories % and get rid of the others ! if (exist ('OCTAVE_VERSION', 'builtin') ~= 5), % if Matlab if do_addpath, addpath (fullfile (mole_dir, 'matlab')); end elseif prune_unused, rmdir (fullfile (mole_dir, 'matlab'), 's'); end %--- graphics_toolkit --------------------------------------------------------- % For Octave users: graphics_toolkit is missing in some old version of Octave % For Matlab users: there is no function named graphics_toolkit in Matlab. Our % implementation returns either 'matlab-jvm' or 'matlab-nojvm'. install_mole_function ('graphics_toolkit', opts{:}); %--- corr --------------------------------------------------------------------- % For Octave users: corr belongs to Octave core in recent releases of Octave, % but was missing in Octave 3.2.4 (when was it added ?) % For Matlab users: corr is missing from Matlab itself, but it provided by the % Statistics toolbox if you're rich enough to afford it. install_mole_function ('corr', opts{:}); %--- isrow -------------------------------------------------------------------- % For Octave users: ? % For Matlab users: missing in R2007a install_mole_function ('isrow', opts{:}); %--- linsolve ----------------------------------------------------------------- % For Octave users: linsolve has been missing in Octave for a long time % (up to 3.6.4) install_mole_function ('linsolve', opts{:}); %--- quantile ----------------------------------------------------------------- % For Matlab users: quantile is missing from Matlab itself, but it provided by % the Statistics toolbox if you're rich enough to afford it. install_mole_function ('quantile', opts{:}); %--- CLEANUP ------------------------------------------------------------------ if (exist ('OCTAVE_VERSION', 'builtin') == 5), % is octave confirm_recursive_rmdir (recursive_rmdir_state); end end % function stk_config_mole function install_mole_function (function_name, mole_dir, do_addpath, prune_unused) function_dir = fullfile (mole_dir, function_name); if isempty (which (function_name)), % if the function is absent function_mfile = fullfile (function_dir, [function_name '.m']); if exist (function_dir, 'dir') && exist (function_mfile, 'file') % fprintf ('[MOLE] Providing function %s\n', function_name); if do_addpath, addpath (function_dir); end else warning (sprintf ('[MOLE] Missing function: %s\n', function_name)); end elseif prune_unused && (exist (function_dir, 'dir')) rmdir (function_dir, 's'); end end % function install_mole_function %#ok<*SPWRN,*WNTAG> stk/inst/config/stk_config_addpath.m0000664000175000017500000000426712617165716016535 0ustar bectbect% STK_CONFIG_ADDTOPATH adds STK subfolders to the search path % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_config_addpath (root) while 1, % Remove other copies of STK from the search path [current_root, found_in_path] = stk_config_getroot (); if (~ found_in_path) || (strcmp (current_root, root)) break; end warning (sprintf (['Removing another copy of STK from the ' ... 'search path.\n (%s)\n'], current_root)); stk_config_rmpath (current_root); end % Add STK folders to the path path = stk_config_path (root); for i = 1:length (path), if exist (path{i}, 'dir') addpath (path{i}); else error (sprintf (['Directory %s does not exist.\n' ... 'Is there a problem in stk_config_path ?'], path{i})); end end % Selectively add MOLE subdirectories to compensate for missing functions % (note that stk_init.m also does that, but it is necessary to do it again here, % just in case some functions were provided by another copy of STK that has been removed % from the path by stk_config_addpath (see above)) stk_config_mole (root); end % function stk_config_addpath %#ok<*NODEF,*WNTAG,*SPERR,*SPWRN> stk/inst/config/stk_config_clearpersistents.m0000664000175000017500000000402612617165716020513 0ustar bectbect% STK_CONFIG_CLEARPERSISTENTS clears all persistent variables in STK % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_config_clearpersistents () %--- Unlock all mlocked files -------------------------------------------------- filenames = { ... 'isoctave', ... 'stk_optim_hasfmincon', ... 'stk_options_set', ... 'stk_parallel_engine_set', ... 'stk_select_optimizer'}; for i = 1:(length (filenames)) name = filenames{i}; if mislocked (name), munlock (name); end end %--- Clear all functions that contain persistent variables --------------------- filenames = { ... 'isoctave', ... 'stk_disp_progress', ... 'stk_gausscov_iso', ... 'stk_gausscov_aniso', ... 'stk_materncov_aniso', ... 'stk_materncov_iso', ... 'stk_materncov32_aniso', ... 'stk_materncov32_iso', ... 'stk_materncov52_aniso', ... 'stk_materncov52_iso', ... 'stk_options_set', ... 'stk_optim_hasfmincon', ... 'stk_parallel_engine_set', ... 'stk_select_optimizer'}; for i = 1:(length (filenames)) clear (filenames{i}); end end % function stk_config_clearpersistents stk/inst/config/stk_config_setup.m0000664000175000017500000000266212617165716016265 0ustar bectbect% STK_CONFIG_SETUP initializes the STK % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_config_setup () % Set default options stk_options_set; % Select optimizers for stk_param_estim stk_select_optimizer; % Select default "parallelization engine" stk_parallel_engine_set; % Hide some warnings about numerical accuracy warning ('off', 'STK:stk_predict:NegativeVariancesSetToZero'); warning ('off', 'STK:stk_cholcov:AddingRegularizationNoise'); warning ('off', 'STK:stk_param_relik:NumericalAccuracyProblem'); end % function stk_config_setup stk/inst/config/stk_config_getroot.m0000664000175000017500000000325112617165716016603 0ustar bectbect% STK_CONFIG_GETROOT returns STK's root folder % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [root, found_in_path] = stk_config_getroot () root = fileparts (which ('stk_param_relik')); if isempty (root), % STK is not in the search path -> Return the path to the copy of STK % that contains this specific version stk_config_getroot root = fileparts (fileparts (mfilename ('fullpath'))); found_in_path = false; else % STK is already in the search path -> Deduce the path of STK's root % from the full path of stk_param_relik. root = fileparts (root); % One level upper in the hierarchy found_in_path = true; end end % function stk_config_getroot stk/inst/config/stk_config_rmpath.m0000664000175000017500000000530712617165716016417 0ustar bectbect% STK_CONFIG_RMPATH removes a copy of STK from the search path % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_config_rmpath (root) if nargin == 0, root = stk_config_getroot (); end s = path (); regex1 = strcat ('^', escape_regexp (root)); % Safer than calling isoctave directly (this allows stk_config_rmpath to work % even if STK has already been partially uninstalled or is not properly installed) isoctave = (exist ('OCTAVE_VERSION', 'builtin') == 5); if isoctave, regex2 = strcat (escape_regexp (octave_config_info ('api_version')), '$'); end while ~ isempty (s) [d, s] = strtok (s, pathsep); %#ok if (~ isempty (regexp (d, regex1, 'once'))) ... && ((~ isoctave) || isempty (regexp (d, regex2, 'once'))) ... && (~ strcmp (d, root)) % See note below rmpath (d); end end % Note: it is important NOT to remove STK's root folder at this point. Indeed, % in the case where STK is used as an Octave package, this would trigger the % PKG_DEL directive in stk_init.m, and therefore stk_config_rmpath again, % causing an infinite loop. end % function stk_config_rmpath function s = escape_regexp (s) % For backward compatibility with Octave 3.2.x, we cannot use regexprep here: % % s = regexprep (s, '([\+\.\\])', '\\$1'); % % Indeed, compare the results with Octave 3.8.x % % >> regexprep ('2.2.0', '(\.)', '\$1') % ans = 2$12$10 % % >> regexprep ('2.2.0', '(\.)', '\\$1') % ans = 2\.2\.0 % % and those with Octave 3.2.4 % % >> regexprep ('2.2.0', '(\.)', '\$1') % ans = 2\.2\.0 % % >> regexprep ('2.2.0', '(\.)', '\\$1') % ans = 2\\.2\\.0 % s = strrep (s, '\', '\\'); s = strrep (s, '+', '\+'); s = strrep (s, '.', '\.'); end % function escape_regexp stk/inst/config/stk_config_testprivatemex.m0000664000175000017500000000467412617165716020216 0ustar bectbect% STK_CONFIG_TESTPRIVATEMEX checks if the MEX-files located in private dirs are found % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_config_testprivatemex () try n = 5; d = 2; x = rand (n, d); D = stk_dist (x); % calls a MEX-file internally assert (isequal (size (D), [n n])); catch err = lasterror (); if (~ isempty (regexp (err.message, '__stk_dist_matrixx__', 'once'))) ... && (~ isempty (regexp (err.message, 'undefined', 'once'))) fprintf ('\n\n'); warning (sprintf (['\n\n' ... '!>>>>>> PLEASE RESTART OCTAVE BEFORE USING STK <<<<<>>>>> PLEASE RESTART OCTAVE BEFORE USING STK <<<<< stk/inst/stk_init.m0000664000175000017500000000557512617165722013301 0ustar bectbect% STK_INIT initializes the STK % % CALL: stk_init() % % STK_INIT sets paths and environment variables % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . %% PKG_ADD: stk_init (); %% PKG_DEL: stk_init (true); function stk_init (do_quit) % Deduce the root of STK from the path to this script root = fileparts (mfilename ('fullpath')); config = fullfile (root, 'config'); % Add config to the path. It will be removed at the end of this script. addpath (config); % Unlock all possibly mlock-ed STK files and clear all STK functions % that contain persistent variables stk_config_clearpersistents (); if (nargin > 0) && (do_quit) % Remove STK subdirectories from the path stk_config_rmpath (root); % No need to remove config manually at the end of the script since % it is removed by stk_config_rmpath. We can exit. return end % Activate the MOLE stk_config_mole (root); % Are we using STK installed as an octave package ? STK_OCTAVE_PACKAGE = true; % Build MEX-files "in-place" (unless STK is used as an Octave package) if ~ STK_OCTAVE_PACKAGE stk_config_buildmex (); % To force recompilation of all MEX-files, use stk_config_buildmex (true); end % Add STK folders to the path (note: doing this ATFER building the MEX-files % seems to solve the problem related to having MEX-files in private folders) stk_config_addpath (root); % Check that MEX-files located in private folders are properly detected (note: % there are no MEX-files in private folders if STK is used as an Octave package) if isoctave && (~ STK_OCTAVE_PACKAGE), stk_config_testprivatemex (); end % Configure STK with default settings stk_config_setup; % Uncomment this line if you want to see a lot of details about the internals % of stk_dataframe and stk_factorialdesign objects: % stk_options_set ('stk_dataframe', 'disp_format', 'verbose'); % Remove config from the path rmpath (config); end % function stk_init stk/inst/arrays/0000775000175000017500000000000012617165716012567 5ustar bectbectstk/inst/arrays/@stk_factorialdesign/0000775000175000017500000000000012617165716016706 5ustar bectbectstk/inst/arrays/@stk_factorialdesign/stk_boundingbox.m0000664000175000017500000000305612617165715022266 0ustar bectbect% STK_BOUNDINGBOX [overload STK function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function box = stk_boundingbox (x) if nargin > 1, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end xmin = cellfun (@min, x.levels); xmax = cellfun (@max, x.levels); box = stk_hrect ([xmin; xmax]); box.colnames = x.stk_dataframe.colnames; end % function @stk_factorialdesign.stk_boundingbox %!shared x, y, cn %! cn = {'a', 'b', 'c'}; %! x = stk_factorialdesign ({[1 2], [3 4 5], [0 2 8]}, cn); %!error y = stk_boundingbox (); %!test y = stk_boundingbox (x); %!error y = stk_boundingbox (x, 1); %!assert (isequal (y, stk_hrect ([1 3 0; 2 5 8], cn))); stk/inst/arrays/@stk_factorialdesign/ndgrid.m0000664000175000017500000000505112617165715020333 0ustar bectbect% NDGRID produces ndgrid-style coordinate arrays % % CALL: [X1, X2, ...] = ndgrid (X) % % produces ndgrid-style coordinate arrays X1, X2, ... Xd based on the % @stk_factorialdesign object X (where d is the number of columns of % X). This is equivalent to % % [X1, ..., Xd] = ndgrid (X.levels{1}, ..., X.levels{d}); % % See also: ndgrid % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = ndgrid (x) d = length (x.levels); if nargout > d stk_error ('Too many output arguments.', 'TooManyOutputArgs'); else if (d == 0) || any (cellfun (@isempty, x.levels)) varargout = repmat ({[]}, 1, nargout); elseif d == 1 varargout = {x.levels{1}(:)}; else varargout = cell (1, max (nargout, 1)); [varargout{:}] = ndgrid (x.levels{:}); end end end % function ndgrid %--- general case ------------------------------------------------------------- %!shared data %! data = stk_factorialdesign ({[0 1], [5 6 7]}); %!test % nargout = 0 %! ndgrid (data); %! assert (isequal (ans, [0 0 0; 1 1 1])); %!test % nargout = 1 %! x = ndgrid (data); %! assert (isequal (x, [0 0 0; 1 1 1])); %!test % nargout = 2 %! [x, y] = ndgrid (data); %! assert (isequal ({x, y}, {[0 0 0; 1 1 1], [5 6 7; 5 6 7]})); %!error % nargout = 3 %! [x, y, z] = ndgrid (data); %--- special cases ------------------------------------------------------------ %!test %! data = stk_factorialdesign ({[], []}); %! [x, y] = ndgrid (data); %! assert (isequal ({x, y}, {[], []})); %!test %! data = stk_factorialdesign ({[1:3]}); %! x = ndgrid (data); %! assert (isequal (x, [1; 2; 3])); stk/inst/arrays/@stk_factorialdesign/stk_sprintf_levels.m0000664000175000017500000000315412617165716023007 0ustar bectbect% STK_SPRINTF_LEVELS prints the levels of a factorial design into a string % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_levels (x) colnames = get (x.stk_dataframe, 'colnames'); d = length (x.levels); for i = 1:d if isempty (colnames) line{i} = sprintf('levels for column #%d: ', i); else line{i} = sprintf('levels for variable %s: ', colnames{i}); end L = x.levels{i}; if isempty (L) line{i} = [line{i} '[]']; else for j = 1:(length(L) - 1) line{i} = [line{i} num2str(L(j)) ', ']; end line{i} = [line{i} sprintf('%s', num2str(L(end)))]; end end s = char (line{:}); end % function stk_sprintf_levels stk/inst/arrays/@stk_factorialdesign/pcolor.m0000664000175000017500000000217412617165715020365 0ustar bectbect% PCOLOR [overload base function] % % See also: stk_factorialdesign/contour, stk_factorialdesign/mesh, ... % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function pcolor (varargin) plot_surfmeshcontour (@pcolor, varargin{:}); end % function pcolor stk/inst/arrays/@stk_factorialdesign/stk_normalize.m0000664000175000017500000000316012617165716021745 0ustar bectbect% STK_NORMALIZE [overload STK function] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_normalize (x, varargin) if (~ isa (x, 'stk_factorialdesign')) % One of the box arguments is an stk_factorialdesign object stk_error (['stk_factorialdesign objects cannot be used as values ' ... 'for ''box'' arguments.'], 'TypeMismatch'); end % Normalize using @stk_dataframe/stk_normalize [x.stk_dataframe, a, b] = stk_normalize (x.stk_dataframe, varargin{:}); for j = 1:(length (x.levels)) x.levels{j} = a(j) + b(j) * x.levels{j}; end end % function stk_normalize %!test %! x = stk_factorialdesign ({[1 2], [5 6]}); %! y = stk_factorialdesign ({[0 1], [0 1]}); %! assert (stk_isequal_tolabs (stk_normalize (x), y)) stk/inst/arrays/@stk_factorialdesign/stk_sprintf.m0000664000175000017500000000542012617165716021433 0ustar bectbect% STK_SPRINTF ... % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf (x, verbosity, data_col_width) if (nargin < 2) || (isempty (verbosity)), verbosity = stk_options_get ('stk_dataframe', 'disp_format'); end if ~ ismember (verbosity, {'basic', 'verbose'}) errmsg = 'verbosity should be ''basic'' or ''verbose''.'; stk_error (errmsg, 'InvalidArgument'); end if (nargin < 3) || (isempty (data_col_width)), data_col_width = []; end % Print the stk_dataframe df = x.stk_dataframe; s = stk_sprintf (df, 'basic', data_col_width); % Print the levels first, if in verbose mode if strcmp (verbosity, 'verbose'), spstr = stk_options_get ('stk_dataframe', 'disp_spstr'); L = length (x.levels); s = char (... ... %-------------------------------------------------------------- '.info =', ... % alias for .stk_dataframe.info horzcat (spstr, stk_sprintf_info (df)), ... ... %-------------------------------------------------------------- '.colnames =', ... % alias for .stk_dataframe.colnames horzcat (spstr, stk_sprintf_colnames (df)), ... ... %-------------------------------------------------------------- '.rownames =', ... % alias for .stk_dataframe.rownames horzcat (spstr, stk_sprintf_rownames (df)), ... ... %-------------------------------------------------------------- sprintf ('.levels = <%s>', stk_sprintf_sizetype (x.levels)), ... horzcat (repmat (spstr, L, 1), stk_sprintf_levels (x)), ... ... %-------------------------------------------------------------- '.data =', ... % alias for .stk_dataframe.data horzcat (repmat (spstr, size (s, 1), 1), s) ... ); %--------------------------------------------------------------- end end % function stk_sprintf stk/inst/arrays/@stk_factorialdesign/contour.m0000664000175000017500000000217512617165715020561 0ustar bectbect% CONTOUR [overload base function] % % See also: stk_factorialdesign/surf, stk_factorialdesign/mesh, ... % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function contour (varargin) plot_surfmeshcontour (@contour, varargin{:}); end % function contour stk/inst/arrays/@stk_factorialdesign/mesh.m0000664000175000017500000000216412617165715020022 0ustar bectbect% MESH [overload base function] % % See also: stk_factorialdesign/contour, stk_factorialdesign/surf, ... % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function mesh (varargin) plot_surfmeshcontour (@mesh, varargin{:}); end % function mesh stk/inst/arrays/@stk_factorialdesign/meshc.m0000664000175000017500000000217012617165715020162 0ustar bectbect% MESHC [overload base function] % % See also: stk_factorialdesign/contour, stk_factorialdesign/surf, ... % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function meshc (varargin) plot_surfmeshcontour (@meshc, varargin{:}); end % function meshc stk/inst/arrays/@stk_factorialdesign/private/0000775000175000017500000000000012617165715020357 5ustar bectbectstk/inst/arrays/@stk_factorialdesign/private/plot_surfmeshcontour.m0000664000175000017500000001137012617165715025043 0ustar bectbect% PLOT_SURFMESHCONTOUR [STK internal] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % % This file recycles part of stk_plot2d.m (now deprecated): % % Copyright (C) 2014 SUPELEC % Copyright (C) 2013 SUPELEC & Valentin Resseguier % Copyright (C) 2012 SUPELEC % % Authors: Julien Bect % Valentin Resseguier % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function plot_surfmeshcontour (plotfun, varargin) [h, x, z, opts] = parse_args_ (varargin{:}); %--- Deal with various possible types for the 'z' argument ---------------- if ischar (z) || isa (z, 'function_handle') z = double (stk_feval (z, x)); else z = double (z); end %--- Do the actual plotting job ------------------------------------------- [xx1, xx2] = ndgrid (x); call_plotfun (plotfun, h, xx1, xx2, reshape (z, size (xx1)), opts{:}); % Create labels if x provides column names c = get (x.stk_dataframe, 'colnames'); if ~ isempty (c), stk_xlabel (c{1}); end if length (c) > 1, stk_ylabel (c{2}); end % Use interpolated shading for surf and pcolor plots if ismember (func2str (plotfun), {'surf', 'pcolor'}), shading ('interp'); end end % function plot_surfmeshcontour %#ok<*TRYNC> function [h, x, z, opts] = parse_args_ (arg1, varargin) %--- Formal grammar for the list of arguments ----------------------------- % % Terminal symbols % % h = a handle to an axes object % x = stk_factorial_design object % z = ordinate argument % % Derivation rules % % ::= | h % ::= x z % If the first argument can be interpreted as a handle, then it always is. arg1_handle = false; if isscalar (arg1) && isa (arg1, 'double'), try arg1_handle = strcmp (get (arg1, 'Type'), 'axes'); end end if arg1_handle, if nargin < 3, stk_error ('Not enough input arguments.', 'NotEnoughInputArgs'); end h = arg1; x = varargin{1}; z = varargin{2}; opts = varargin(3:end); else if nargin < 2, stk_error ('Not enough input arguments.', 'NotEnoughInputArgs'); end h = gca; x = arg1; z = varargin{1}; opts = varargin(2:end); end % Then, arg1 must be an stk_factorialdesign object if ~ isa (x, 'stk_factorialdesign') errmsg = 'x should be an stk_factorialdesign object.'; stk_error (errmsg, 'TypeMismatch'); end dim = size (x, 2); if dim ~= 2, errmsg = 'Only works for two-dimensional factor spaces.'; stk_error (errmsg, 'IncorrectArgument'); end end % function parse_args_ function call_plotfun (plotfun, h, x, y, z, varargin) % In Octave 3.6.4, pcolor supports neither the axis handle argument nor % the optional parameter/value arguments. This function has been created to % overcome this and other similar issues. try % When the full 'modern' syntax is supported, the result is usually better, % in particular when options are provided. Let's try that first. plotfun (h, x, y, z, varargin{:}); return; catch %#ok % Do we have an additional numeric argument ? if isempty (varargin) numarg = {}; opts = {}; else if ischar (varargin{1}) numarg = {}; opts = varargin; else numarg = varargin(1); opts = varargin(2:end); end end % Select the axes to draw on h1 = gca (); axes (h); try if strcmp (func2str (plotfun), 'contour') [C_ignored, h2] = contour (x, y, z, numarg{:}); %#ok else h2 = plotfun (x, y, z, numarg{:}); end if ~ isempty (opts) set (h2, opts{:}); end axes (h1); catch %#ok axes (h1); rethrow (lasterror ()); %#ok end end % try_catch end % function call_plotfun stk/inst/arrays/@stk_factorialdesign/set.m0000664000175000017500000000377012617165715017665 0ustar bectbect% SET [overload base function] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = set (x, propname, value) df = x.stk_dataframe; switch propname, case 'levels', % We proceed in two steps, instead of the seemingly simpler % x = stk_factorialdesign (value); % to preserve the value of the other fields (info, colnames, ...). tmp = stk_factorialdesign (value); x = set (df, 'data', tmp.data); case 'stk_dataframe', errmsg = 'Field .stk_dataframe is read-only.'; stk_error (errmsg, 'ReadOnlyField'); case {'colnames', 'rownames', 'info'}, x.stk_dataframe = set (df, propname, value); otherwise, if ismember (propname, fieldnames (df)) % The result is not an stk_factorialdesign object anymore, in % general. An implicit cast to stk_dataframe is thus performed. x = set (df, propname, value); else errmsg = sprintf ('There is no field named: %s.', propname); stk_error (errmsg, 'UnknownField'); end end end % function set stk/inst/arrays/@stk_factorialdesign/stk_factorialdesign.m0000664000175000017500000001764212617165715023114 0ustar bectbect% STK_FACTORIALDESIGN constructs a "full factorial design" array % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_factorialdesign(levels, varargin) if nargin == 0 % default constructor levels = {[]}; end % number of factors d = length(levels); if ~iscell(levels) || (numel(levels) ~= d) errmsg = 'Expecting a "flat" cell array as first argument.'; stk_error(errmsg, 'TypeMismatch'); else if ~all(cellfun(@isnumeric, levels)) errmsg = 'Only numeric factors are currently supported.'; stk_error(errmsg, 'TypeMismatch'); else % ok, numeric levels, we know how to handle that if (d == 0) || any(cellfun(@isempty, levels)) xdata = zeros(0, d); elseif d == 1 xdata = levels{1}(:); else % coordinate arrays coord = cell(1, d); [coord{:}] = ndgrid(levels{:}); % design matrix xdata = zeros(numel(coord{1}), d); for j = 1:d, xdata(:, j) = coord{j}(:); end end % base dataframe df = stk_dataframe (xdata, varargin{:}); df = set (df, 'info', 'Created by stk_factorialdesign'); % "factorial design" object x = struct ('levels', {levels}); x = class (x, 'stk_factorialdesign', df); end % if end % if end % function stk_factorialdesign %--- constructor -------------------------------------------------------------- %!test % default constructor %! x = stk_factorialdesign (); %! assert (strcmp (class (x), 'stk_factorialdesign')); %!test % constructor with two factors + column names %! x = stk_factorialdesign ({[0 1], [1 2 3]}, {'a', 'b'}); %! assert (isequal(x.colnames, {'a', 'b'})); %! assert (isequal(get (x, 'colnames'), {'a', 'b'})); % tests some incorrect values for 'levels' %!error stk_factorialdesign ('bouh'); %!error stk_factorialdesign (repmat ({[0 1]}, 2, 2)); % categorical variable not supported yet %!error stk_factorialdesign ({{'a' 'b'}}); %--- disp & display ----------------------------------------------------------- %!shared x, fmt %! try % doesn't work on old Octave versions, nevermind %! fmt = get (0, 'Format'); %! catch %! fmt = nan; %! end %! x = stk_sampling_regulargrid (3^2, 2); %!test format rat; disp (x); %!test format long; disp (x); %!test format short; disp (x); %! if ~ isnan (fmt), set (0, 'Format', fmt); end %!test disp (stk_sampling_regulargrid (0^1, 1)); %!test disp (stk_sampling_regulargrid (0^2, 2)); %!test display (x); %--- size, length, end -------------------------------------------------------- %!error length (stk_sampling_regulargrid (7^2, 2)) % not defined %!shared x %! x = stk_factorialdesign ({[0 1], [0 1]}); %!assert (isequal (x(2:end, :), x(2:4, :))) %!assert (isequal (x(2, 1:end), x(2, :))) %!assert (isequal (x(2:end, 2:end), x(2:4, 2))) %!error x(1:end, 1:end, 1:end) %--- cat, vertcat, horzcat ---------------------------------------------------- % Note: the output is a plain stk_dataframe %!shared x, y %! x = stk_sampling_regulargrid (3^2, 2); %! y = x; %!test %%%% vercat %! z = vertcat (x, y); %! assert (strcmp (class (z), 'stk_dataframe')); %! assert (isequal (double (z), [double(x); double(y)])); %!test %%%% same thing, using cat(1, ...) %! z = cat (1, x, y); %! assert (strcmp (class (z), 'stk_dataframe')); %! assert (isequal (double (z), [double(x); double(y)])); %!test %%%% horzcat %! y.colnames = {'y1' 'y2'}; z = horzcat (x, y); %! assert (strcmp (class (z), 'stk_dataframe')); %! assert (isequal (double (z), [double(x) double(y)])); %!test %%%% same thing, using cat (2, ...) %! z = cat (2, x, y); %! assert (strcmp (class (z), 'stk_dataframe')); %! assert (isequal (double (z), [double(x) double(y)])); %!error cat (3, x, y) %--- apply & related functions ------------------------------------------------ %!shared x, t %! x = stk_sampling_regulargrid (3^2, 2); %! t = double (x); %!assert (isequal (apply (x, 1, @sum), sum (t, 1))) %!assert (isequal (apply (x, 2, @sum), sum (t, 2))) %!error u = apply (x, 3, @sum); %!assert (isequal (apply (x, 1, @min, []), min (t, [], 1))) %!assert (isequal (apply (x, 2, @min, []), min (t, [], 2))) %!error u = apply (x, 3, @min, []); %!assert (isequal (min (x), min (t))) %!assert (isequal (max (x), max (t))) %!assert (isequal (std (x), std (t))) %!assert (isequal (var (x), var (t))) %!assert (isequal (sum (x), sum (t))) %!assert (isequal (mean (x), mean (t))) %!assert (isequal (mode (x), mode (t))) %!assert (isequal (prod (x), prod (t))) %!assert (isequal (median (x), median (t))) %--- bsxfun & related functions ----------------------------------------------- %!shared x1, x2, x3, u1, u2, u3 %! x1 = stk_sampling_regulargrid ([4 3], 2); u1 = double (x1); %! x2 = stk_sampling_regulargrid ([3 4], 2); u2 = double (x2); %! x3 = x1 + 1; u3 = u1 + 1; %!test %! z = bsxfun (@plus, x1, u2); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), u1 + u2)) %!test %! z = bsxfun (@plus, u1, x2); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), u1 + u2)) %!test %! z = bsxfun (@plus, x1, x2); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), u1 + u2)) %!test z = min (x1, x2); assert (isequal (double (z), min (u1, u2))); %!test z = max (x1, x2); assert (isequal (double (z), max (u1, u2))); %!error z = min (x1, x2, 1); %!error z = max (x1, x2, 1); %!test z = x1 + x2; assert (isequal (double (z), u1 + u2)); %!test z = x1 - x2; assert (isequal (double (z), u1 - u2)); %!test z = x1 .* x2; assert (isequal (double (z), u1 .* u2)); %!test z = x3 .\ x2; assert (isequal (double (z), u3 .\ u2)); %!test z = x2 ./ x3; assert (isequal (double (z), u2 ./ u3)); %!test z = x3 .^ x2; assert (isequal (double (z), u3 .^ u2)); %!test z = realpow (x3, x2); assert (isequal (double (z), realpow (u3, u2))); %!test z = (x1 == x2); assert (isequal (double (z), (u1 == u2))); %!test z = (x1 ~= x2); assert (isequal (double (z), (u1 ~= u2))); %!test z = (x1 <= x2); assert (isequal (double (z), (u1 <= u2))); %!test z = (x1 >= x2); assert (isequal (double (z), (u1 >= u2))); %!test z = (x1 < x2); assert (isequal (double (z), (u1 < u2))); %!test z = (x1 > x2); assert (isequal (double (z), (u1 > u2))); %!test z = x1 & x2; assert (isequal (double (z), u1 & u2)); %!test z = x1 | x2; assert (isequal (double (z), u1 | u2)); %!test z = xor (x1, x2); assert (isequal (double (z), xor (u1, u2))); %--- transpose, ctranspose ---------------------------------------------------- % Transposing a dataframe that represents a factorial design results in a % dataframe that does NOT represent a factorial design %!shared x %! x = stk_factorialdesign ({[0 1], [0 1 2]}); %!assert (strcmp (class (x'), 'stk_dataframe')) %!assert (strcmp (class (x.'), 'stk_dataframe')) stk/inst/arrays/@stk_factorialdesign/surf.m0000664000175000017500000000216412617165716020046 0ustar bectbect% SURF [overload base function] % % See also: stk_factorialdesign/contour, stk_factorialdesign/mesh, ... % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function surf (varargin) plot_surfmeshcontour (@surf, varargin{:}); end % function surf stk/inst/arrays/@stk_factorialdesign/get.m0000664000175000017500000000236112617165715017644 0ustar bectbect% GET [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function t = get (x, propname) switch propname, case 'levels' t = x.levels; case 'stk_dataframe' % Read-only access to the underlying df t = x.stk_dataframe; otherwise t = get (x.stk_dataframe, propname); end end % function get stk/inst/arrays/@stk_factorialdesign/fieldnames.m0000664000175000017500000000255212617165715021176 0ustar bectbect% FIELDNAMES [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function fn = fieldnames (x) fn = fieldnames (x.stk_dataframe); fn = [{'levels' 'stk_dataframe'} fn]; end % function fieldnames %!test %! x = stk_factorialdesign ({0:1, 3:5}, {'u' 'v'}); %! fn1 = sort (fieldnames (x)); %! fn2 = {'colnames', 'data', 'info', 'levels', ... %! 'rownames', 'stk_dataframe', 'u', 'v'}; %! assert (isequal (fn1, fn2)); stk/inst/arrays/@stk_factorialdesign/stk_rescale.m0000664000175000017500000000326012617165716021364 0ustar bectbect% STK_RESCALE [overload STK function] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, a, b] = stk_rescale (x, varargin) if (~ isa (x, 'stk_factorialdesign')) % One of the box arguments is an stk_factorialdesign object stk_error (['stk_factorialdesign objects cannot be used as values ' 'for ''box'' arguments.'], 'TypeMismatch'); end % Rescale using @stk_dataframe/stk_rescale [x.stk_dataframe, a, b] = stk_rescale (x.stk_dataframe, varargin{:}); % Apply the same normalization to levels for j = 1:(length (x.levels)) x.levels{j} = a(j) + b(j) * x.levels{j}; end end % function stk_rescale %!test %! x = stk_factorialdesign ({[1 2], [5 6]}); %! y = stk_factorialdesign ({[0 3], [0 3]}); %! z = stk_rescale (x, [1 5; 2 6], [0 0; 3 3]); %! assert (stk_isequal_tolabs (y, z)) stk/inst/arrays/@stk_factorialdesign/meshz.m0000664000175000017500000000217012617165715020211 0ustar bectbect% MESHZ [overload base function] % % See also: stk_factorialdesign/contour, stk_factorialdesign/surf, ... % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function meshz (varargin) plot_surfmeshcontour (@meshz, varargin{:}); end % function meshz stk/inst/arrays/@stk_factorialdesign/subsasgn.m0000664000175000017500000000402512617165716020712 0ustar bectbect% SUBSASGN [overload base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = subsasgn (x, idx, val) if ~ isa (x, 'stk_dataframe') % Inherit behaviour from @stk_dataframe % (see @stk_dataframe/subsasgn.m) x = subsasgn (x, idx, val.stk_dataframe); return end if all (builtin ('size', x) == 0) % This happens in Octave 3.2.x when doing B(idx) = D if B does not % exist and D is an stk_factorialdesign object. In this case, x is an % UNITIALIZED 0x0 stk_factorialdesign object. We have to initialize it. x = stk_factorialdesign (); end switch idx(1).type case '()' % The result is not an stk_factorialdesign object anymore, in % general. An implicit cast to stk_dataframe is thus performed. x = x.stk_dataframe; x = subsasgn (x, idx, val); case '{}' errmsg = 'Indexing with curly braces is not allowed.'; stk_error(errmsg, 'IllegalIndexing'); case '.' if length (idx) > 1 val = subsasgn (get (x, idx(1).subs), idx(2:end), val); end x = set (x, idx(1).subs, val); end end % function subsasgn stk/inst/arrays/@stk_factorialdesign/uminus.m0000664000175000017500000000235412617165716020410 0ustar bectbect% UMINUS [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = uminus (x) x.stk_dataframe = - x.stk_dataframe; x.levels = cellfun (@uminus, x.levels, 'UniformOutput', false); end % function uminus %!test %! x = stk_factorialdesign ({1:3, 1:2}); %! y = stk_factorialdesign ({-(1:3), -(1:2)}); %! assert (isequal (-x, y)) stk/inst/arrays/@stk_dataframe/0000775000175000017500000000000012617165715015473 5ustar bectbectstk/inst/arrays/@stk_dataframe/var.m0000664000175000017500000000301412617165715016437 0ustar bectbect% VAR [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = var(x, flag, dim) if nargin < 2, flag = 0; end % default: normalize by N-1 if nargin < 3, dim = 1; end % default: act along columns z = apply(x, dim, @var, flag); end % function var %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (var(df1), var(x1))) %!assert (isequal (var(df1, 0, 1), var(x1))) %!assert (isequal (var(df1, 0, 2), var(x1, 0, 2))) %!assert (isequal (var(df1, 1), var(x1, 1))) %!assert (isequal (var(df1, 1, 1), var(x1, 1))) %!assert (isequal (var(df1, 1, 2), var(x1, 1, 2))) stk/inst/arrays/@stk_dataframe/mean.m0000664000175000017500000000242112617165715016570 0ustar bectbect% MEAN [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = mean(x, dim) if nargin < 2, dim = 1; end z = apply(x, dim, @mean); end % function mean %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (mean(df1), mean(x1))) %!assert (isequal (mean(df1, 1), mean(x1))) %!assert (isequal (mean(df1, 2), mean(x1, 2))) stk/inst/arrays/@stk_dataframe/le.m0000664000175000017500000000234712617165715016257 0ustar bectbect% LE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = le(x1, x2) y = bsxfun(@le, x1, x2); end % function le %!test stk_test_dfbinaryop(@le, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@le, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@le, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/max.m0000664000175000017500000000412712617165715016442 0ustar bectbect% MAX [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = max (x, y, dim) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end varargout = cell (1, max (1, nargout)); if (nargin < 2) || (isempty (y)), % Act on rows or columns if nargin < 3, dim = 1; end [varargout{:}] = apply (x, dim, @max, []); else % Apply 'max' elementwise if nargin > 2, errmsg = 'Too many input arguments (elementwise max assumed)'; stk_error(errmsg, 'TooManyInputArgs'); else [varargout{:}] = bsxfun (@max, x, y); end end % if end % function max %!test stk_test_dfbinaryop ('max', rand(7, 2), rand(7, 2)); %!test stk_test_dfbinaryop ('max', rand(7, 2), pi); %!error stk_test_dfbinaryop ('max', rand(7, 2), rand(7, 3)); %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (max(df1), max(x1))) %!assert (isequal (max(df1, [], 1), max(x1))) %!assert (isequal (max(df1, [], 2), max(x1, [], 2))) %!error (max(df1, df1, 2)) %!test %! x = stk_dataframe ([1; 3; 2]); %! [M, k] = max (x); %! assert ((M == 3) && (k == 2)); stk/inst/arrays/@stk_dataframe/apply.m0000664000175000017500000000376312617165715017007 0ustar bectbect% APPLY maps a function to the rows or columns of a dataframe. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = apply (x, dim, F, u) if nargin == 4 uu = {u}; else uu = {}; end varargout = cell (1, max (1, nargout)); if dim == 1 % act along columns [varargout{:}] = feval (F, x.data, uu{:}, 1); else if dim ~= 2, stk_error ('Incorrect dimension specifier', 'IncorrectDimSpec'); else % act along rows (less usual) [varargout{:}] = feval (F, x.data, uu{:}, 2); end end end % function apply %!shared x, t, u %! t = rand (3, 2); %! x = stk_dataframe (t); %!test u = apply (x, 1, @sum); %!assert (isequal (u, sum (t, 1))) %!test u = apply (x, 2, @sum); %!assert (isequal (u, sum (t, 2))) %!error u = apply (x, 3, @sum); %!test u = apply (x, 1, @min, []); %!assert (isequal (u, min (t, [], 1))) %!test u = apply (x, 2, @min, []); %!assert (isequal (u, min (t, [], 2))) %!error u = apply (x, 3, @min, []); %!test %! t = [1; 3; 2]; %! x = stk_dataframe (t); %! [M, k] = apply (x, 1, @max, []); %! assert ((M == 3) && (k == 2)); stk/inst/arrays/@stk_dataframe/stk_boundingbox.m0000664000175000017500000000272012617165715021051 0ustar bectbect% STK_BOUNDINGBOX [overload STK function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function box = stk_boundingbox (x) if nargin > 1, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end box = stk_boundingbox (x.data); box.colnames = x.colnames; end % function @stk_dataframe.stk_boundingbox %!shared x, y, cn %! cn = {'a', 'b', 'c'}; %! x = stk_dataframe ([0 3 2; 1 4 1; 7 0 2], cn); %!error y = stk_boundingbox (); %!test y = stk_boundingbox (x); %!error y = stk_boundingbox (x, 1); %!assert (isequal (y, stk_hrect ([0 0 1; 7 4 2], cn))); stk/inst/arrays/@stk_dataframe/transpose.m0000664000175000017500000000263712617165715017677 0ustar bectbect% TRANSPOSE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = transpose(x) rn = get(x, 'rownames'); cn = get(x, 'colnames'); y = stk_dataframe(transpose(x.data), rn', cn'); end % function transpose %!test %! u = rand(3, 2) + 1i * rand(3, 2); %! data = stk_dataframe(u, {'x' 'y'}, {'obs1'; 'obs2'; 'obs3'}); %! data = data.'; %! assert (isa(data, 'stk_dataframe') && isequal(double(data), u.')); %! assert (isequal(data.rownames, {'x'; 'y'})); %! assert (isequal(data.colnames, {'obs1' 'obs2' 'obs3'})); stk/inst/arrays/@stk_dataframe/mode.m0000664000175000017500000000243412617165715016600 0ustar bectbect% MODE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = mode(x, dim) if nargin < 2, dim = 1; end z = apply(x, dim, @mode); end % function mode %!shared x1, df1 %! x1 = floor(3 * rand(9, 3)); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (mode(df1), mode(x1))) %!assert (isequal (mode(df1, 1), mode(x1))) %!assert (isequal (mode(df1, 2), mode(x1, 2))) stk/inst/arrays/@stk_dataframe/stk_sprintf_sizetype.m0000664000175000017500000000231412617165715022153 0ustar bectbect% STK_SPRINTF_SIZETYPE prints the size and type into a string % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_sizetype (x) [n, d] = size (x); s = sprintf ('%dx%d %s array', n, d, class (x)); end % function stk_sprintf_sizetype stk/inst/arrays/@stk_dataframe/length.m0000664000175000017500000000225512617165715017136 0ustar bectbect% LENGTH [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function N = length (x) %#ok errmsg = ['length() is not defined for objects of class ' class(x)]; stk_error (errmsg, 'MethodNotDefined'); end % function length %!error length (stk_dataframe ([1 2; 3 4; 5 6])) stk/inst/arrays/@stk_dataframe/mtimes.m0000664000175000017500000000330612617165715017151 0ustar bectbect% MTIMES [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = mtimes (x1, x2) if isa (x1, 'stk_dataframe') x1_data = x1.data; rownames = x1.rownames; else x1_data = x1; rownames = {}; end if isa (x2, 'stk_dataframe') x2_data = x2.data; colnames = x2.colnames; else x2_data = x2; colnames = {}; end y = stk_dataframe (x1_data * x2_data, colnames, rownames); end % function mtimes %!shared x, y, z, w %! %! u = [1 3 4; 2 7 6]; % 2 x 3 %! v = [6 2; 1 7; 9 4]; % 3 x 2 %! w = [45 39; 73 77]; % u * v %! %! x = stk_dataframe (u, {}, {'a'; 'b'}); %! y = stk_dataframe (v, {'c' 'd'}); %! z = x * y; %!assert (isa (z, 'stk_dataframe')); %!assert (isequal (z.data, w)); %!assert (isequal (z.rownames, x.rownames)); %!assert (isequal (z.colnames, y.colnames)); stk/inst/arrays/@stk_dataframe/stk_dataframe.m0000664000175000017500000002117412617165715020463 0ustar bectbect% STK_DATAFRAME constructs a dataframe object % % CALL: D = stk_dataframe (X) % % constructs a dataframe object from X. If X is a plain numeric array, then % D is dataframe without row or column names. If X already is an % stk_dataframe object, row names and column names are preserved when they % exist. % % CALL: D = stk_dataframe (X, COLNAMES) % % allows to specify column names for the dataframe D. Row names from X are % preserved when they exist. % % If COLNAMES is empty ([]), this is equivalent to D = stk_dataframe (X); % in particular, if X has column names, then D inherits from them. % % If COLNAMES is an empty cell({}), the resulting dataframe has no column % names. % % CALL: D = stk_dataframe (X, COLNAMES, ROWNAMES) % % allows to specify row names as well. % % If ROWNAMES is empty ([]), this is equivalent to D = stk_dataframe (X, % COLNAMES); in particular, if X has row names, then D inherits from them. % % If ROWNAMES is an empty cell({}), the resulting dataframe has no row names. % % See also: stk_factorialdesign, stk_hrect % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = stk_dataframe (x, colnames, rownames) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); elseif nargin == 0 % Default constructor x_data = zeros (0, 1); colnames = {}; rownames = {}; elseif strcmp (class (x), 'stk_dataframe') %#ok if nargin > 1, if iscell (colnames) x = set (x, 'colnames', colnames); elseif ~ isempty (colnames) stk_error (['colnames should be either a cell array ' ... 'of strings or [].'], 'InvalidArgument'); % Note: [] means "keep x.colnames" % while {} means "no column names" end if nargin > 2 if iscell (rownames) x = set (x, 'rownames', rownames); elseif ~ isempty (rownames) stk_error (['rownames should be either a cell array ' ... 'of strings or [].'], 'InvalidArgument'); % Note: [] means "keep x.rownames" % while {} means "no rownames names" end end end return % We already have an stk_dataframe object elseif isa (x, 'stk_dataframe') x_data = x.data; if nargin == 1, colnames = x.colnames; rownames = x.rownames; else % nargin > 1, if (isempty (colnames)) && (~ iscell (colnames)) colnames = x.colnames; elseif ~ iscell (colnames) stk_error (['colnames should be either a cell array ' ... 'of strings or [].'], 'InvalidArgument'); % Note: [] means "keep x.colnames" % while {} means "no column names" end if nargin == 2, rownames = x.rownames; else % nargin > 2, if (isempty (rownames)) && (~ iscell (rownames)) rownames = x.rownames; elseif ~ iscell (rownames) stk_error (['rownames should be either a cell array ' ... 'of strings or [].'], 'InvalidArgument'); % Note: [] means "keep x.rownames" % while {} means "no rownames names" end end end else % Assume x is (or can be converted to) numeric data x_data = double (x); if nargin < 3, rownames = {}; if nargin < 2, colnames = {}; end end end [n, d] = size (x_data); % Check colnames argument: must be a 1 x d cell array of strings if ~ iscell (colnames) if isempty (colnames) colnames = {}; else stk_error ('colnames should be a cell array.', 'TypeMismatch'); end elseif (~ isempty (colnames)) && (~ isequal (size (colnames), [1 d])) colnames = reshape (colnames, 1, d); end % Check rownames argument: must be a n x 1 cell array of strings if ~ iscell (rownames) if isempty (rownames) rownames = {}; else stk_error ('rownames should be a cell array.', 'TypeMismatch'); end elseif (~ isempty (rownames)) && (~ isequal (size (rownames), [n 1])) rownames = reshape (rownames, n, 1); end x = struct ('data', x_data, ... 'colnames', {colnames}, 'rownames', {rownames}, 'info', ''); x = class (x, 'stk_dataframe'); end % function @stk_dataframe.stk_dataframe %!error x = stk_dataframe (1, {}, {}, pi); %!test % default constructor %! x = stk_dataframe (); %! assert (isa (x, 'stk_dataframe') && isequal (size (x), [0 1])) %!test %! y = stk_dataframe (rand (3, 2)); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [3 2])) %!test %! y = stk_dataframe (rand (3, 2), {'x', 'y'}); %! assert (isa (y, 'stk_dataframe') && isequal (size(y), [3 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %!test %! y = stk_dataframe (rand (3, 2), {'x', 'y'}, {'a', 'b', 'c'}); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [3 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'})) %!test %! x = stk_dataframe (rand (3, 2)); %! y = stk_dataframe (x); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [3 2])) %!error %! x = stk_dataframe (rand (3, 2)); %! y = stk_dataframe (x, pi); %!error %! x = stk_dataframe (rand (3, 2)); %! y = stk_dataframe (x, {}, pi); %!test %! x = stk_dataframe (rand (3, 2)); %! y = stk_dataframe (x, {'x' 'y'}); %! assert (isa (y, 'stk_dataframe') && isequal (size(y), [3 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %!test %! x = stk_dataframe (rand (3, 2)); %! y = stk_dataframe (x, {'x' 'y'}, {'a', 'b', 'c'}); %! assert (isa (y, 'stk_dataframe') && isequal (size(y), [3 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'})) %!test %! x = stk_dataframe (rand (3, 2), {'x' 'y'}); %! y = stk_dataframe (x, [], {'a', 'b', 'c'}); %! assert (isa (y, 'stk_dataframe') && isequal (size(y), [3 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'})) %!test %! x = stk_dataframe (rand (3, 2), {'x' 'y'}); %! y = stk_dataframe (x, {}, {'a', 'b', 'c'}); %! assert (isa (y, 'stk_dataframe') && isequal (size(y), [3 2])) %! assert (isequal (y.colnames, {})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'})) %!test %! x = stk_factorialdesign ({1:3, 1:2}, {'x' 'y'}); %! y = stk_dataframe (x, [], {'a' 'b' 'c' 'd' 'e' 'f'}); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [6 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'; 'd'; 'e'; 'f'})) %!test %! x = stk_factorialdesign ({1:3, 1:2}, {}, {'a' 'b' 'c' 'd' 'e' 'f'}); %! y = stk_dataframe (x, {'x' 'y'}); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [6 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'; 'd'; 'e'; 'f'})) %!test %! x = stk_factorialdesign ({1:3, 1:2}, {}, {'a' 'b' 'c' 'd' 'e' 'f'}); %! y = stk_dataframe (x, {'x' 'y'}, []); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [6 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'; 'd'; 'e'; 'f'})) %!test %! x = stk_factorialdesign ({1:3, 1:2}, {'x' 'y'}, {'a' 'b' 'c' 'd' 'e' 'f'}); %! y = stk_dataframe (x); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [6 2])) %! assert (isequal (y.colnames, {'x' 'y'})) %! assert (isequal (y.rownames, {'a'; 'b'; 'c'; 'd'; 'e'; 'f'})) %!error %! x = stk_factorialdesign ({1:3, 1:2}); %! y = stk_dataframe (x, pi); %!error %! x = stk_factorialdesign ({1:3, 1:2}); %! y = stk_dataframe (x, {}, pi); stk/inst/arrays/@stk_dataframe/bsxfun.m0000664000175000017500000000602012617165715017154 0ustar bectbect% BSXFUN [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = bsxfun (F, x1, x2) %---- Compute ydata ----------------------------------------------------- x1data = double (x1); x2data = double (x2); try ydata = bsxfun (F, x1data, x2data); catch err = lasterror (); if strcmp (err.identifier, 'MATLAB:bsxfun:unsupportedBuiltin') % This happens in some old versions of Matlab with realpow, for % instance. Let's try without singleton expansion... ydata = feval (F, x1data, x2data); % TODO: manual bsxfun !!! else rethrow (err); end end %---- Choose column names ----------------------------------------------- if isa (x1, 'stk_dataframe'), c1 = x1.colnames; else c1 = {}; end if isa (x2, 'stk_dataframe'), c2 = x2.colnames; else c2 = {}; end if isempty (c1) colnames = c2; elseif isempty (c2) colnames = c1; else if (~ isequal (size (c1), size (c2))) || (any (~ strcmp (c1, c2))) warning ('STK:bsxfun:IncompatibleColumnNames', ... 'Incompatible column names.'); colnames = {}; else colnames = c1; end end %--- Create output ------------------------------------------------------ y = stk_dataframe (ydata, colnames); end % function bsxfun % DESIGN NOTES % % Starting from STK 2.2.0, the result of bsxfun is ALWAYS an % stk_dataframe object, and has column names iff % * either one of the two arguments doesn't have columns names % * or the columns names of both arguments agree. % % With this design choice, we ensure that if the underlying operation F % is commutative on double-precision arrays, then it stays commutative % on stk_dataframe objects. %!shared x1, x2, data1, data2 %! x1 = rand (3, 2); data1 = stk_dataframe (x1); %! x2 = rand (3, 2); data2 = stk_dataframe (x2); %!test %! z = bsxfun (@plus, data1, x2); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), x1 + x2)) %!test %! z = bsxfun (@plus, x1, data2); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), x1 + x2)) %!test %! z = bsxfun (@plus, data1, data2); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), x1 + x2)) stk/inst/arrays/@stk_dataframe/size.m0000664000175000017500000000263312617165715016627 0ustar bectbect% SIZE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = size(x, varargin) varargout = cell(1, max(nargout, 1)); [varargout{:}] = size(x.data, varargin{:}); end % function size %!shared x %! x = stk_dataframe([1 2; 3 4; 5 6]); %!assert (isequal (size(x), [3 2])) %!assert (numel(x) == 1) %!assert (ndims(x) == 2) %!test size(x); % force exploration of branch nargout == 0 % Note: numel MUST return 1 and not prod(size(x)) % http://www.mathworks.fr/support/solutions/en/data/1-19EZ0/?1-19EZ0 stk/inst/arrays/@stk_dataframe/isequal.m0000664000175000017500000000212712617165715017316 0ustar bectbect% ISEQUAL [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function b = isequal (x, y) b = strcmp (class (x), class (y)) ... && isequal (struct (x), struct (y)); end % function isequal stk/inst/arrays/@stk_dataframe/ne.m0000664000175000017500000000234712617165715016261 0ustar bectbect% NE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = ne(x1, x2) y = bsxfun(@ne, x1, x2); end % function ne %!test stk_test_dfbinaryop(@ne, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@ne, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@ne, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/ge.m0000664000175000017500000000235012617165715016244 0ustar bectbect% GE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = ge(x1, x2) y = bsxfun(@ge, x1, x2); end % function ge %!test stk_test_dfbinaryop(@ge, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@ge, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@ge, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/subsref.m0000664000175000017500000000722012617165715017323 0ustar bectbect% SUBSREF [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function t = subsref (x, idx) switch idx(1).type case '()' L = length (idx(1).subs); if L == 1, % linear indexing t = subsref (x.data, idx); elseif L == 2, % matrix-style indexing I = idx(1).subs{1}; J = idx(1).subs{2}; x.data = x.data(I, J); if ~ isempty (x.colnames), x.colnames = x.colnames(1, J); end if ~ isempty (x.rownames), x.rownames = x.rownames(I, 1); end t = x; else stk_error ('Illegal indexing.', 'IllegalIndexing'); end case '{}' errmsg = 'Indexing with curly braces is not allowed.'; stk_error (errmsg, 'IllegalIndexing'); case '.' t = get (x, idx(1).subs); end if (length (idx)) > 1, t = subsref (t, idx(2:end)); end end % function @stk_dataframe.subsref %!shared x, s, t, data %! x = stk_dataframe(rand(3, 2)); %! s = {'a'; 'b'; 'c'}; %! t = {'xx' 'yy'}; %!test %! x = set(x, 'rownames', s); %! assert (isequal (x.rownames, s)) %! assert (isequal (x.rownames{2}, 'b')) %!test %! x = set(x, 'colnames', t); %! assert (isequal (x.rownames, s)) %! assert (isequal (x.colnames, t)) %! assert (isequal (x.colnames{2}, 'yy')) %--- tests with a bivariate dataframe + column names -------------------------- %!shared u, data %! u = rand(3, 2); %! data = stk_dataframe(u, {'x1', 'x2'}); %!assert (isequal (data.x2, u(:, 2))) %!assert (data.x2(3) == u(3, 2)) %!error t = data.toto; %!error t = data(1, 1).zzz; % illegal multilevel indexing %!error t = data(1, 1, 1); % too many indices %!error t = data{1}; % curly braces not allowed %!test % legacy feature: data.a returns the 'mean' column if it exists %! data = set(data, 'colnames', {'mean', 'x2'}); %! assert(isequal(data.a, u(:, 1))); %!test % legacy feature: data.a returns the whole dataframe otherwise %! data = set(data, 'colnames', {'x1', 'x2'}); %! assert(isequal(data.a, u)); %!test % select rows and columns %! x = stk_dataframe (reshape (1:15, 5, 3), {'u' 'v' 'w'}); %! assert (isequal (x([3 5], 2), stk_dataframe ([8; 10], {'v'}))); %--- tests with a univariate dataframe ---------------------------------------- %!shared u, data %! u = rand(3, 1); data = stk_dataframe(u, {'x'}); %!assert (isequal (data.x, u)) %!assert (isequal (double (data), u)) %!assert (isequal (double (data(2)), u(2))) %!assert (isequal (double (data(3, 1)), u(3))) %!error t = data(1, 1, 1); % too many indices stk/inst/arrays/@stk_dataframe/ismember.m0000664000175000017500000000370212617165715017456 0ustar bectbect% ISMEMBER [overload base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = ismember (A, B, varargin) if ~ all (cellfun (@ischar, varargin)) stk_error ('Invalid flag (should be a string).', 'InvalidArgument'); else % At least of of the arguments (A or B) is an stk_dataframe, % therefore ismember should work on rows flags = unique ([{'rows'} varargin{:}]); end varargout = cell (1, max (nargout, 1)); if isa (A, 'stk_dataframe'), A = A.data; end if isa (B, 'stk_dataframe'), B = B.data; end [varargout{:}] = ismember (A, B, flags{:}); end % function ismember %!shared u, x, u1, x1, u2, x2 %! u = rand (10, 4); %! x = stk_dataframe (u); %! x1 = x(1, :); %! u1 = double (x1); %! u2 = - ones (1, 4); %! x2 = stk_dataframe (u2); %!assert (ismember (u1, x)) %!assert (ismember (x1, u)) %!assert (ismember (x1, x)) %!assert (~ ismember (u2, x)) %!assert (~ ismember (x2, u)) %!assert (~ ismember (x2, x)) %!test %! [b, idx] = ismember ([x2; x1; x1], x); %! assert (isequal (b, [false; true; true])); %! assert (isequal (idx, [0; 1; 1])) stk/inst/arrays/@stk_dataframe/power.m0000664000175000017500000000233012617165715017003 0ustar bectbect% POWER [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = power(x1, x2) y = bsxfun(@power, x1, x2); end % function power %!test stk_test_dfbinaryop(@power, rand(7, 2), .1 + rand(7, 2)); %!test stk_test_dfbinaryop(@power, rand(7, 2), .1); %!error stk_test_dfbinaryop(@power, rand(7, 2), .1 + rand(7, 3)); stk/inst/arrays/@stk_dataframe/abs.m0000664000175000017500000000222712617165715016421 0ustar bectbect% ABS [overload base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function ydata = abs (x) ydata = abs (x.data); end % function abs %!test %! u = rand (4, 3); x = stk_dataframe (u); v = abs (x); %! assert (strcmp (class (v), class (u)) && isequal (v, abs (u))) stk/inst/arrays/@stk_dataframe/stk_length.m0000664000175000017500000000230212617165715020010 0ustar bectbect% STK_LENGTH [overload STK function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function l = stk_length (x) l = size (x.data, 1); end % function stk_length %!test %! x = stk_dataframe ([1 2; 3 4; 5 6]); %! assert (isequal (stk_length (x), 3)); stk/inst/arrays/@stk_dataframe/ctranspose.m0000664000175000017500000000300112617165715020024 0ustar bectbect% CTRANSPOSE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = ctranspose(x) rn = get(x, 'rownames'); cn = get(x, 'colnames'); y = stk_dataframe(ctranspose(x.data), rn', cn'); end % function ctranspose % note: complex-valued dataframes are supported but, currently, % not properly displayed %!test %! u = rand(3, 2) + 1i * rand(3, 2); %! data = stk_dataframe(u, {'x' 'y'}, {'obs1'; 'obs2'; 'obs3'}); %! data = data'; %! assert (isa(data, 'stk_dataframe') && isequal(double(data), u')); %! assert (isequal(data.rownames, {'x'; 'y'})); %! assert (isequal(data.colnames, {'obs1' 'obs2' 'obs3'})); stk/inst/arrays/@stk_dataframe/stk_normalize.m0000664000175000017500000000353312617165715020536 0ustar bectbect% STK_NORMALIZE [overload STK function] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, a, b] = stk_normalize (x, box) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin < 2, box = []; end if isa (x, 'stk_dataframe') % Ensure that box is an stk_hrect object if ~ isa (box, 'stk_hrect') if isempty (box), box = stk_boundingbox (x.data); % Default: bounding box else box = stk_hrect (box); end end % Call @stk_hrect/stk_normalize [x.data, a, b] = stk_normalize (x.data, box); else % box is an stk_dataframe object % Call @stk_hrect/stk_normalize [x, a, b] = stk_normalize (x, stk_hrect (box)); end % if end % function stk_normalize %!test %! u = rand (6, 2) * 2; %! x = stk_dataframe (u); %! y = stk_normalize (x); %! assert (isa (y, 'stk_dataframe') ... %! && stk_isequal_tolabs (double (y), stk_normalize (u))) stk/inst/arrays/@stk_dataframe/stk_sprintf.m0000664000175000017500000001065312617165715020224 0ustar bectbect% DISP [overload base function] % % Example: % format short % x = [1 1e6 rand; 10 -1e10 rand; 100 1e-22 rand]; % disp (stk_dataframe (x)) % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf (x, verbosity, data_col_width) if (nargin < 2) || (isempty (verbosity)), verbosity = stk_options_get ('stk_dataframe', 'disp_format'); end if ~ ismember (verbosity, {'basic', 'verbose'}) errmsg = 'verbosity should be ''basic'' or ''verbose''.'; stk_error (errmsg, 'InvalidArgument'); end if (nargin < 3) || (isempty (data_col_width)), data_col_width = []; end s = sprintf_table_ (x.data, x.colnames, x.rownames, data_col_width); if strcmp (verbosity, 'verbose'), spstr = stk_options_get ('stk_dataframe', 'disp_spstr'); s = char (... '.info =', horzcat (spstr, stk_sprintf_info (x)), ... '.colnames =', horzcat (spstr, stk_sprintf_colnames (x)), ... '.rownames =', horzcat (spstr, stk_sprintf_rownames (x)), ... '.data =', horzcat (repmat (spstr, size (s, 1), 1), s)); end end % function stk_sprintf %#ok<*CTCH> function s = sprintf_table_ (x, colnames, rownames, data_col_width) x = double (x); [n, d] = size (x); if (n == 0) || (d == 0) s = '[] (empty)'; else if (nargin < 2) || isempty (data_col_width) try switch get (0, 'Format') case 'short' data_col_width = 8; case 'long' data_col_width = 16; otherwise % FIXME: handle other formatting modes... data_col_width = 8; end catch % Property 'Format' doesn't exist in Octave 3.2.x data_col_width = 8; end end % column names if (nargin < 3) || isempty (colnames) colnames = repmat ({''}, 1, d); end % row names if (nargin < 4) || isempty (rownames) rownames = repmat ({''}, n, 1); end b = cellfun (@isempty, rownames); rownames(b) = repmat({'*'}, sum (b), 1); rownames = fliplr (char (cellfun ... (@fliplr, rownames, 'UniformOutput', false))); nb_spaces_colsep = 2; nb_rows = n + 1; % + 1 for the header s = repmat ('', nb_rows, 1); %#ok<*AGROW> s = [s [repmat(' ', 1, size(rownames, 2)); rownames]]; % column separator between row names and the first data column s = [s repmat(' :', nb_rows, 1) ... repmat(' ', nb_rows, nb_spaces_colsep)]; for j = 1:d, xx = stk_sprintf_colvect (x(:, j), data_col_width); Lxx = size (xx, 2); vn = colnames{j}; if isempty (vn), vn = repmat('-', 1, Lxx); end L = max (length (vn), Lxx); s = [s [sprintf('% *s', L, vn); % variable name repmat(' ', n, L - Lxx) xx]]; % formatted data if j < d, % column separator s = [s repmat(' ', nb_rows, nb_spaces_colsep)]; end end % for end % if end % function sprintf_table_ %!shared x, fmt %! try % doesn't work on old Octave versions, nevermind %! fmt = get (0, 'Format'); %! catch %! fmt = nan; %! end %! x = stk_dataframe (rand (3, 2)); %!test format rat; disp (x); %!test format long; disp (x); %!test format short; disp (x); %! if ~isnan (fmt), set (0, 'Format', fmt); end %!test disp (stk_dataframe (zeros (0, 1))) %!test disp (stk_dataframe (zeros (0, 2))) stk/inst/arrays/@stk_dataframe/diff.m0000664000175000017500000000204612617165715016563 0ustar bectbect% DIFF [overload base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = diff (x, varargin) z = diff (x.data, varargin{:}); end % function diff stk/inst/arrays/@stk_dataframe/stk_sprintf_colnames.m0000664000175000017500000000263012617165715022101 0ustar bectbect% STK_SPRINTF_COLNAMES returns the column names of an array % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_colnames (x) d = size (x, 2); colnames = get (x, 'colnames'); if isempty (colnames) s = stk_sprintf_colnames (zeros (0, d)); else s = '{'; for j = 1:(d-1), s = [s sprintf('''%s'', ', x.colnames{j})]; %#ok end s = [s sprintf('''%s''}', x.colnames{end})]; end end % function stk_sprintf_colnames stk/inst/arrays/@stk_dataframe/or.m0000664000175000017500000000234712617165715016277 0ustar bectbect% OR [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = or(x1, x2) y = bsxfun(@or, x1, x2); end % function or %!test stk_test_dfbinaryop(@or, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@or, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@or, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/uplus.m0000664000175000017500000000200612617165715017017 0ustar bectbect% UPLUS [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = uplus (x) end % function uplus stk/inst/arrays/@stk_dataframe/stk_generate_samplepaths.m0000664000175000017500000001034212617165715022725 0ustar bectbect% STK_GENERATE_SAMPLEPATHS [overload STK] % % See also: stk_generate_samplepaths % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function zsim = stk_generate_samplepaths (model, varargin) if isa (model, 'stk_dataframe') stk_error (['The first input argument (model) should not be an ' ... 'stk_dataframe object'], TypeMismatch'); end switch nargin, case {0, 1}, stk_error ('Not enough input arguments.', 'NotEnoughInputArgs'); case 2, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XT) xt = varargin{1}; nb_paths = 1; conditional = false; zsim = stk_generate_samplepaths (model, double (xt)); case 3, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XT, NB_PATHS) xt = varargin{1}; nb_paths = varargin{2}; conditional = false; if isa (nb_paths, 'stk_dataframe') nb_paths = double (nb_paths); assert (isscalar (nb_paths)); end zsim = stk_generate_samplepaths (model, double (xt), nb_paths); case 4, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT) xi = varargin{1}; zi = varargin{2}; xt = varargin{3}; nb_paths = 1; conditional = true; zsim = stk_generate_samplepaths (model, double (xi), ... double (zi), double (xt)); case 5, % CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT, NB_PATHS) xi = varargin{1}; zi = varargin{2}; xt = varargin{3}; nb_paths = varargin{4}; conditional = true; if isa (nb_paths, 'stk_dataframe') nb_paths = double (nb_paths); assert (isscalar (nb_paths)); end zsim = stk_generate_samplepaths (model, double (xi), ... double (zi), double (xt), nb_paths); otherwise stk_error ('Too many input arguments.', 'TooManyInputArgs'); end %--- stk_dataframe output ----------------------------------------------------- if isa (zsim, 'stk_dataframe') % This case happens when model.response_name exists and contains a % non-empty string. if conditional && (isa (zi, 'stk_dataframe')) ... && (~ isempty (zi.colnames)) ... && (~ strcmp (model.response_name, zi.colnames)) % colnames are different: don't use any zsim.colnames = {}; end try zsim.rownames = xt.rownames; catch zsim.rownames = {}; end else % model.response name does not exist or is empty try rownames = xt.rownames; catch rownames = {}; end try response_name = zi.colnames{1}; assert (numel (zi.colnames) == 1); assert ((~ isempty (response_name)) && (ischar (response_name))); if nb_paths == 1, colnames = {response_name}; else colnames = arrayfun ( ... @(i)(sprintf ('%s_%d', response_name, i)), ... 1:nb_paths, 'UniformOutput', false); end catch colnames = {}; end zsim = stk_dataframe (zsim, colnames, rownames); end end % function stk_generate_samplepaths %#ok<*CTCH> stk/inst/arrays/@stk_dataframe/lt.m0000664000175000017500000000234712617165715016276 0ustar bectbect% LT [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = lt(x1, x2) y = bsxfun(@lt, x1, x2); end % function lt %!test stk_test_dfbinaryop(@lt, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@lt, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@lt, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/rdivide.m0000664000175000017500000000234412617165715017302 0ustar bectbect% RDIVIDE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = rdivide(x1, x2) y = bsxfun(@rdivide, x1, x2); end % function rdivide %!test stk_test_dfbinaryop(@rdivide, rand(7, 2), 1 + rand(7, 2)); %!test stk_test_dfbinaryop(@rdivide, rand(7, 2), pi); %!error stk_test_dfbinaryop(@rdivide, rand(7, 2), 1 + rand(7, 3)); stk/inst/arrays/@stk_dataframe/double.m0000664000175000017500000000275412617165715017133 0ustar bectbect% DOUBLE [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function xdata = double(x) xdata = double(x.data); end % function double %!test %! u = rand(4, 3); %! x = stk_dataframe(u); %! v = double(x); %! assert (strcmp(class(v), 'double') && isequal(v, u)) %!test %! u = (rand(4, 3) < 0.5); %! x = stk_dataframe(u); %! v = double(x); %! assert (strcmp(class(v), 'double') && isequal(v, double(u))) %!test %! u = uint8 (rand (4, 3) * 5); %! x = stk_dataframe(u); %! v = double(x); %! assert (strcmp(class(v), 'double') && isequal(v, double(u))) stk/inst/arrays/@stk_dataframe/xor.m0000664000175000017500000000241412617165715016462 0ustar bectbect% XOR [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = xor(x1, x2) y = bsxfun(@xor, x1, x2); end % function xor %!shared x, y, z %! x = floor (3 * rand (7, 2)); %! y = floor (3 * rand (7, 2)); %! z = floor (3 * rand (7, 3)); %!test stk_test_dfbinaryop ('xor', x, y); %!test stk_test_dfbinaryop ('xor', x, 1.0); %!error stk_test_dfbinaryop ('xor', x, z); stk/inst/arrays/@stk_dataframe/realpow.m0000664000175000017500000000234612617165715017327 0ustar bectbect% REALPOW [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = realpow(x1, x2) y = bsxfun(@realpow, x1, x2); end % function realpow %!test stk_test_dfbinaryop(@realpow, rand(7, 2), .1 + rand(7, 2)); %!test stk_test_dfbinaryop(@realpow, rand(7, 2), .1); %!error stk_test_dfbinaryop(@realpow, rand(7, 2), .1 + rand(7, 3)); stk/inst/arrays/@stk_dataframe/private/0000775000175000017500000000000012617165715017145 5ustar bectbectstk/inst/arrays/@stk_dataframe/private/reserved_field_names.m0000664000175000017500000000212512617165715023470 0ustar bectbect% RESERVED_FIELD_NAMES [STK internal] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function c = reserved_field_names () c = {'data', 'info', 'rownames', 'colnames'}; end % function reserved_field_names stk/inst/arrays/@stk_dataframe/private/get_column_number.m0000664000175000017500000000214312617165715023027 0ustar bectbect% GET_COLUMN_NUMBER [STK internal] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . % Do NOT remove this seemingly useless M-file, otherwise some not-so-old % versions of Octave would faild to detect the corresponding mex-file. stk/inst/arrays/@stk_dataframe/set.m0000664000175000017500000001017112617165715016444 0ustar bectbect% SET [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = set (x, propname, value) icol = __get_column_number__ (x.colnames, propname); switch icol case -4 % 'info' x.info = value; case -3 % 'rownames' if isempty (value) x.rownames = {}; else n1 = size (x.data, 1); n2 = length (value); if ~ iscell (value) stk_error (['Input argument ''value'' should be a cell' ... ' array.'], 'InvalidArgument'); elseif isequal (size (value), [n2 1]) x.rownames = value; else x.rownames = reshape (value, n2, 1); end b = cellfun (@isempty, x.rownames); nb = sum (b); if nb > 0 x.rownames(b) = repmat ({''}, nb, 1); end if n2 < n1 x.rownames = [x.rownames; repmat({''}, n1 - n2, 1)]; elseif n2 > n1 x.data = [x.data; nan(n2 - n1, size(x.data, 2))]; end end case -2 % 'colnames' if isempty (value) x.colnames = {}; else d1 = size (x.data, 2); d2 = length (value); if ~ iscell (value) stk_error (['Input argument ''value'' should be a cell' ... ' array.'], 'InvalidArgument'); elseif isequal (size (value), [1 d2]) x.colnames = value; else x.colnames = reshape (value, 1, d2); end b = cellfun (@isempty, x.colnames); nb = sum (b); if nb > 0 x.colnames(b) = repmat ({''}, 1, nb); end if d2 < d1 x.colnames = [x.colnames repmat({''}, 1, d1 - d2)]; elseif d2 > d1 x.data = [x.data nan(size(x.data, 1), d2 - d1)]; end end case - 1 % set entire array [n1, d1] = size (x.data); [n2, d2] = size (value); x.data = value; if (n1 ~= n2) && ~ isempty (x.rownames) if n2 > n1, % silently add rows without a name x.rownames = [x.rownames; repmat({''}, n2 - n1, 1)]; else % delete superfluous row names and emit a warning x.rownames = x.rownames(1:n2); warning ('Some row names have been deleted.'); end end if (d1 ~= d2) && ~ isempty (x.colnames) if d2 > d1, % silently add columns without a name x.colnames = [x.colnames; repmat({''}, 1, d2 - d1)]; else % delete superfluous column names and emit a warning x.colnames = x.colnames(1:d2); warning ('Some column names have been deleted.'); end end otherwise if isequal (size(value), [size(x.data, 1) 1]) x.data(:, icol) = value; else error ('Incorrect size'); end end end % function @stk_dataframe.set stk/inst/arrays/@stk_dataframe/stk_sprintf_info.m0000664000175000017500000000230712617165715021234 0ustar bectbect% STK_SPRINTF_INFO returns the 'info' string associated to an array % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_info (x) s = get (x, 'info'); if isempty (s) s = stk_sprintf_info ([]); end end % function stk_sprintf_info stk/inst/arrays/@stk_dataframe/stk_conditioning.m0000664000175000017500000000501212617165715021214 0ustar bectbect% STK_CONDITIONING [overload STK] % % See also stk_conditioning % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Authors: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function zsimc = stk_conditioning (lambda, zi, zsim, xi_ind, noise_sim) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end df_out = false; % stk_dataframe output ? % Read 'lambda' argument if isa (lambda, 'stk_dataframe') lambda_ = lambda.data; rownames = lambda.colnames; df_out = true; else lambda_ = lambda; rownames = {}; end % Read 'zi' argument if isa (zi, 'stk_dataframe') zi_ = zi.data; else zi_ = zi; end % Read 'zsim' argument if isa (zsim, 'stk_dataframe') zsim_ = zsim.data; colnames = zsim.colnames; if isempty (rownames), rownames = zsim.rownames; elseif ~ isequal (zsim.rownames, rownames) rownames = {}; end df_out = true; else zsim_ = zsim; colnames = {}; end if nargin < 4, zsimc = stk_conditioning (lambda_, zi_, zsim_); else % nargin >= 4 % Read 'xi_ind' argument if isa (xi_ind, 'stk_dataframe') xi_ind_ = xi_ind.data; else xi_ind_ = xi_ind; end if nargin < 5, zsimc = stk_conditioning (lambda_, zi_, zsim_, xi_ind_); else % nargin >= 5 % Read 'noise_sim' argument if isa (noise_sim, 'stk_dataframe'), noise_sim_ = noise_sim.data; else noise_sim_ = noise_sim; end zsimc = stk_conditioning (lambda_, zi_, zsim_, xi_ind_, noise_sim_); end end if df_out, zsimc = stk_dataframe (zsimc, colnames, rownames); end end % function stk_conditioning stk/inst/arrays/@stk_dataframe/std.m0000664000175000017500000000301412617165715016441 0ustar bectbect% STD [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = std(x, flag, dim) if nargin < 2, flag = 0; end % default: normalize by N-1 if nargin < 3, dim = 1; end % default: act along columns z = apply(x, dim, @std, flag); end % function std %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (std(df1), std(x1))) %!assert (isequal (std(df1, 0, 1), std(x1))) %!assert (isequal (std(df1, 0, 2), std(x1, 0, 2))) %!assert (isequal (std(df1, 1), std(x1, 1))) %!assert (isequal (std(df1, 1, 1), std(x1, 1))) %!assert (isequal (std(df1, 1, 2), std(x1, 1, 2))) stk/inst/arrays/@stk_dataframe/minus.m0000664000175000017500000000231612617165715017006 0ustar bectbect% MINUS [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = minus(x1, x2) y = bsxfun(@minus, x1, x2); end % function minus %!test stk_test_dfbinaryop(@minus, rand(7, 2), rand(7, 2)); %!test stk_test_dfbinaryop(@minus, rand(7, 2), pi); %!error stk_test_dfbinaryop(@minus, rand(7, 2), rand(7, 3)); stk/inst/arrays/@stk_dataframe/and.m0000664000175000017500000000235712617165715016422 0ustar bectbect% AND [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = and(x1, x2) y = bsxfun(@and, x1, x2); end % function and %!test stk_test_dfbinaryop(@and, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@and, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@and, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/end.m0000664000175000017500000000375112617165715016425 0ustar bectbect% END implements the the 'end' keyword for indexing % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function idx = end (x, k, nb_indices) if nb_indices == 2, % using two indices (matrix-style indexing) idx = size (x.data, k); else if nb_indices ~= 1, errmsg = 'stk_dataframe objects only support linear or matrix-style indexing.'; stk_error (errmsg, 'IllegalIndexing'); else % using linear indexing idx = numel (x.data); end end end % function end %--- tests with a univariate dataframe ---------------------------------------- %!shared x %! x = stk_dataframe ([1; 2; 3]); %!assert (isequal (double (x(2:end, :)), [2; 3])) %!assert (isequal (double (x(2:end)), [2; 3])) %!assert (isequal (double (x(2, 1:end)), 2)) %!assert (isequal (double (x(end)), 3)) %--- tests with a bivariate dataframe ----------------------------------------- %!shared x %! x = stk_dataframe ([1 2; 3 4; 5 6]); %!assert (isequal (x(2:end, :), x(2:3, :))) %!assert (isequal (x(2, 1:end), x(2, :))) %!assert (isequal (x(2:end, 2:end), x(2:3, 2))) %!error x(1:end, 1:end, 1:end) stk/inst/arrays/@stk_dataframe/eq.m0000664000175000017500000000234712617165715016264 0ustar bectbect% EQ [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = eq(x1, x2) y = bsxfun(@eq, x1, x2); end % function eq %!test stk_test_dfbinaryop(@eq, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@eq, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@eq, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/display.m0000664000175000017500000000273612617165715017326 0ustar bectbect% DISPLAY [overload base function] % % Example: % format short % x = [1 1e6 rand; 10 -1e10 rand; 100 1e-22 rand]; % stk_dataframe(x) % implicitely calls display() % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function display (x, varargin) fprintf ('\n%s = <%s>', inputname (1), stk_sprintf_sizetype (x)); if strcmp ('basic', stk_options_get ('stk_dataframe', 'disp_format')) fprintf ('\n\n'); end disp (x, varargin{:}); fprintf ('\n'); end % function display %!test display (stk_dataframe (rand (3, 2))); stk/inst/arrays/@stk_dataframe/vertcat.m0000664000175000017500000001161412617165715017324 0ustar bectbect% VERTCAT [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = vertcat (x, y, varargin) if nargin < 2, y = []; end %--- Get raw data --------------------------------------------------------- x_data = double (x); y_data = double (y); %--- Get column and row names of inputs ---------------------------------- if isa (x, 'stk_dataframe') x_colnames = get (x, 'colnames'); x_rownames = get (x, 'rownames'); else x_colnames = {}; x_rownames = {}; end if isa (y, 'stk_dataframe') y_colnames = get (y, 'colnames'); y_rownames = get (y, 'rownames'); else y_colnames = {}; y_rownames = {}; end %--- Create output column names ------------------------------------------- if isempty (x_colnames) colnames = y_colnames; elseif isempty (y_colnames) colnames = x_colnames; else if (~ isequal (size (x_colnames), size (y_colnames))) ... || (any (~ strcmp (x_colnames, y_colnames))) warning ('STK:vertcat:IncompatibleColNames', sprintf ( ... ['Incompatible column names !\nThe output of vertcat ' ... 'will have no column names.'])); colnames = {}; else colnames = x_colnames; end end %--- Create output row names ---------------------------------------------- bx = isempty(x_rownames); by = isempty(y_rownames); if bx && by, % none of the argument has row names rownames = {}; else % at least of one the arguments has row names if bx, x_rownames = repmat ({''}, size (x_data, 1), 1); end if by, y_rownames = repmat ({''}, size (y_data, 1), 1); end rownames = [x_rownames; y_rownames]; end %--- Create output -------------------------------------------------------- if strcmp (class (x), 'stk_dataframe') %#ok % Optimize for speed (no need to call constructor) x.data = [x_data; y_data]; x.colnames = colnames; x.rownames = rownames; else x = stk_dataframe ([x_data; y_data], colnames, rownames); end if ~ isempty (varargin), x = vertcat (x, varargin{:}); end end % function @stk_dataframe.vertcat % IMPORTANT NOTE: [x; y; ...] fails to give the same result as vertcat(x, y, % ...) in some releases of Octave. As a consequence, all tests must be written % using horzcat explicitely. %!shared u, v %! u = rand(3, 2); %! v = rand(3, 2); %% % Vertical concatenation of two dataframes %!test %! x = stk_dataframe(u); %! y = stk_dataframe(v); %! z = vertcat (x, y); %! assert (isa(z, 'stk_dataframe') && isequal(double(z), [u; v])); %!test % the same, with row names this time %! x = stk_dataframe(u, {}, {'a'; 'b'; 'c'}); %! y = stk_dataframe(v, {}, {'d'; 'e'; 'f'}); %! z = vertcat (x, y); %! assert (isa(z, 'stk_dataframe') && isequal(double(z), [u; v])); %! assert (all(strcmp(z.rownames, {'a'; 'b'; 'c'; 'd'; 'e'; 'f'}))); %!test % the same, with row names only for the first argument %! x = stk_dataframe(u, {}, {'a'; 'b'; 'c'}); %! y = stk_dataframe(v); %! z = vertcat (x, y); %! assert (isa(z, 'stk_dataframe') && isequal(double(z), [u; v])); %!test % incompatible variable names %! u = rand (3, 1); x = stk_dataframe (u, {'x'}); %! v = rand (3, 1); y = stk_dataframe (v, {'y'}); %! z = vertcat (x, y); %! assert (isequal (z.colnames, {})); %% % Vertical concatenation [dataframe; matrix] %!test %! x = stk_dataframe(u); %! z = vertcat (x, v); %! assert (isa(z, 'stk_dataframe') && isequal(double(z), [u; v])); %!test % the same, with row names for the first argument %! x = stk_dataframe(u, {}, {'a'; 'b'; 'c'}); %! z = vertcat (x, v); %! assert (isa(z, 'stk_dataframe') && isequal(double(z), [u; v])); %% % Vertical concatenation [matrix; dataframe] %!test %! y = stk_dataframe (v); %! z = vertcat (u, y); %! assert (isa (z, 'stk_dataframe') && (isequal (double (z), [u; v]))); %% % Vertical concatenation of more than two elements %!test %! x = stk_dataframe(u); %! y = stk_dataframe(v); %! z = vertcat (x, y, u, v); %! assert(isa(z, 'stk_dataframe') && isequal(double(z), [u; v; u; v])); stk/inst/arrays/@stk_dataframe/get.m0000664000175000017500000000255712617165715016441 0ustar bectbect% GET [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function value = get (x, propname) icol = __get_column_number__ (x.colnames, propname); switch icol case -4 % 'info' value = x.info; case -3 % 'rownames' value = x.rownames; case -2 % 'colnames' value = x.colnames; case -1 % get entire array value = x.data; otherwise value = x.data(:, icol); end end % function get stk/inst/arrays/@stk_dataframe/sum.m0000664000175000017500000000240712617165715016460 0ustar bectbect% SUM [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = sum(x, dim) if nargin < 2, dim = 1; end z = apply(x, dim, @sum); end % function sum %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (sum(df1), sum(x1))) %!assert (isequal (sum(df1, 1), sum(x1))) %!assert (isequal (sum(df1, 2), sum(x1, 2))) stk/inst/arrays/@stk_dataframe/isempty.m0000664000175000017500000000203012617165715017336 0ustar bectbect% ISEMPTY [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function b = isempty(x) b = isempty(x.data); end % function isempty stk/inst/arrays/@stk_dataframe/prod.m0000664000175000017500000000242112617165715016614 0ustar bectbect% PROD [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = prod(x, dim) if nargin < 2, dim = 1; end z = apply(x, dim, @prod); end % function prod %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (prod(df1), prod(x1))) %!assert (isequal (prod(df1, 1), prod(x1))) %!assert (isequal (prod(df1, 2), prod(x1, 2))) stk/inst/arrays/@stk_dataframe/ldivide.m0000664000175000017500000000235012617165715017271 0ustar bectbect% LDIVIDE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = ldivide(x1, x2) y = bsxfun(@ldivide, x1, x2); end % function ldivide %!test stk_test_dfbinaryop(@ldivide, 1 + rand(7, 2), rand(7, 2)); %!test stk_test_dfbinaryop(@ldivide, 1 + rand(7, 2), pi); %!error stk_test_dfbinaryop(@ldivide, 1 + rand(7, 2), rand(7, 3)); stk/inst/arrays/@stk_dataframe/median.m0000664000175000017500000000244512617165715017113 0ustar bectbect% MEDIAN [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = median(x, dim) if nargin < 2, dim = 1; end z = apply(x, dim, @median); end % function median %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (median(df1), median(x1))) %!assert (isequal (median(df1, 1), median(x1))) %!assert (isequal (median(df1, 2), median(x1, 2))) stk/inst/arrays/@stk_dataframe/fieldnames.m0000664000175000017500000000235112617165715017761 0ustar bectbect% FIELDNAMES [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function fn = fieldnames (x) fn = [x.colnames reserved_field_names()]; end % function fieldnames %!test %! x = stk_dataframe (rand (3, 2), {'u' 'v'}); %! s1 = sort (fieldnames (x)); %! s2 = {'colnames' 'data' 'info' 'rownames' 'u' 'v'}; %! assert (all (strcmp (s1, s2))); stk/inst/arrays/@stk_dataframe/stk_rescale.m0000664000175000017500000000314312617165715020151 0ustar bectbect% STK_RESCALE [overload STK function] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, a, b] = stk_rescale (x, box1, varargin) % Ensure that box1 is an stk_hrect object if ~ isa (box1, 'stk_hrect') if isempty (box1) box1 = stk_hrect (size (x, 2)); % Default: [0; 1] ^ DIM else box1 = stk_hrect (box1); end end % Rescale using @stk_hrect/stk_rescale if isa (x, 'stk_dataframe') [x.data, a, b] = stk_rescale (x.data, box1, varargin{:}); else [x, a, b] = stk_rescale (x, box1, varargin{:}); end end % function stk_rescale %!test %! u = rand(5, 1) * 2; %! x = stk_dataframe(u); %! y = stk_rescale(x, [0; 2], [0; 3]); %! assert (isa (y, 'stk_dataframe') && isequal(double(y), u * 3/2)) stk/inst/arrays/@stk_dataframe/xlim.m0000664000175000017500000000242712617165715016627 0ustar bectbect% XLIM [overloaded base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = xlim (arg1, arg2) varargout = cell (1, nargout); if nargin == 1, [varargout{:}] = xlim (double (arg1)); return end if isa (arg1, 'stk_dataframe'), arg1 = double (arg1); end if isa (arg2, 'stk_dataframe'), arg2 = double (arg2); end [varargout{:}] = xlim (arg1, arg2); end % function xlim stk/inst/arrays/@stk_dataframe/sort.m0000664000175000017500000000541612617165715016646 0ustar bectbect% SORT [overload base] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, i] = sort (x, dim, mode) if ~ isa (x, 'stk_dataframe'), % Not what we expect: dim or mode is an stk_dataframe... stk_error ('x should be an stk_dataframe object here.', 'TypeMismatch'); end if (nargin < 2) || (isempty (dim)), % Sort along the first non-singleton dimension if (size (x.data, 1) > 1) dim = 1; else dim = 2; end elseif ~ ((dim == 1) || (dim == 2)) stk_error ('dim sould be 1 or 2.', 'InvalidArgument'); end if nargin < 3, mode = 'ascend'; end if dim == 1, % Sort columns [x.data, i] = sort (x.data, 1, mode); if (size (x.data, 2) > 1) % Row names are lost when sorting a dataframe with more than one column x.rownames = {}; elseif ~ isempty (x.rownames) x.rownames = x.rownames(i); end else % Sort rows [x.data, i] = sort (x.data, 2, mode); if (size (x.data, 1) > 1) % Column names are lost when sorting a dataframe with more than one row x.colnames = {}; elseif ~ isempty (x.colnames) x.colnames = x.colnames(i); end end end % function sort %!shared x, y %! x = stk_dataframe ([3; 2; 1], {}, {'a', 'b', 'c'}); %! y = sort (x); %!assert (strcmp (class (y), 'stk_dataframe')) %!assert (isequal (y.data, [1; 2; 3])) %!assert (isequal (y.rownames, {'c'; 'b'; 'a'})) %!assert (isequal (sort (x, []), y)) %!assert (isequal (sort (x, 1), y)) %!assert (isequal (sort (x, 2), x)) %!error sort (x, 3) %!assert (isequal (sort (x, [], 'ascend'), y)) %!assert (isequal (sort (x, 1, 'ascend'), y)) %!assert (isequal (sort (x, 2, 'ascend'), x)) %!error sort (x, 3, 'ascend') %!assert (isequal (sort (x, [], 'descend'), x)) %!assert (isequal (sort (x, 1, 'descend'), x)) %!assert (isequal (sort (x, 2, 'descend'), x)) %!error sort (x, 3, 'descend') stk/inst/arrays/@stk_dataframe/subsasgn.m0000664000175000017500000003061412617165715017502 0ustar bectbect% SUBSASGN [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = subsasgn(x, idx, val) if ~ isa (x, 'stk_dataframe') if isempty (x) % this is required to support B(idx) = D if B does not exist and D is % an stk_dataframe (which, in turn, is required to make repmat work...) x_data = subsasgn ([], idx, val.data); x = stk_dataframe (x_data); else % we're assigning a dataframe (val) to something else x = subsasgn(x, idx, val.data); end return end if all (builtin ('size', x) == 0) % This happens in Octave 3.2.x when doing B(idx) = D if B does not exist and % D is an stk_dataframe. In this case, x is a 0x0 stk_dataframe object. x = stk_dataframe (); end switch idx(1).type case '()' if length(idx) ~= 1 stk_error('Illegal indexing.', 'IllegalIndexing'); else % ok, only one level of indexing [n, d] = size (x.data); % one or two indices, but not more than that L = length (idx(1).subs); if L > 2 stk_error('Illegal indexing.', 'IllegalIndexing'); end val_data = double (val); if ~ isempty (val_data) % assignment x.data = subsasgn (x.data, idx, val_data); if L == 1, % linear indexing % Linear indexing is not allowed to change the shape of a % dataframe (this happens, with numeric arrays, when % indexing beyond numel) if ~ isequal (size (x.data), [n d]) stk_error ('Illegal indexing.', 'IllegalIndexing'); end else % matrix-style indexing [n1, d1] = size (x.data); val_is_an_stkdf = isa (val, 'stk_dataframe'); % Column names if val_is_an_stkdf && (isequal (idx(1).subs{1}, ':')) cn = val.colnames; xcn = x.colnames; if isempty (xcn) if ~ isempty (cn) xcn = repmat ({''}, 1, size (n1, 2)); x.colnames = subsasgn (xcn, idx, cn); end else if isempty (cn) cn = repmat ({''}, 1, size (val, 2)); end x.colnames = subsasgn (xcn, idx, cn); end elseif (d1 > d) && (~ isempty (x.colnames)) x.colnames = horzcat (x.colnames, ... repmat ({''}, 1, d1 - d)); end % Row names if val_is_an_stkdf && (isequal (idx(1).subs{2}, ':')) rn = val.rownames; xrn = x.rownames; if isempty (xrn) if ~ isempty (rn) xrn = repmat ({''}, size (val, 1), 1); x.rownames = subsasgn (xrn, idx, rn); end else if isempty (rn) rn = repmat ({''}, size (val, 1), 1); end x.rownames = subsasgn (xrn, idx, rn); end elseif (n1 > n) && ~ isempty (x.rownames) x.rownames = vertcat (x.rownames, ... repmat ({''}, n1 - n, 1)); end end else % Assignment rhs is empty: deletion if L == 1, % Linear indexing if d == 1, % Column array => remove rows I = idx(1).subs{1}; J = 1; remove_rows = true; elseif n == 1, % Row array => remove columns I = 1; J = idx(1).subs{1}; remove_rows = false; else stk_error ('Illegal indexing.', 'IllegalIndexing'); end else % Matrix-style indexing I = idx(1).subs{1}; J = idx(1).subs{2}; remove_rows = strcmp (J, ':'); if ~ (remove_rows || (strcmp (I, ':'))) stk_error ('Illegal indexing.', 'IllegalIndexing'); end end if remove_rows % Keep column names x.data(I, :) = []; if ~ isempty (x.rownames) x.rownames(I) = []; end else % Remove columns x.data(:, J) = []; if ~ isempty (x.colnames) x.colnames(J) = []; end end end end case '{}' errmsg = 'Indexing with curly braces is not allowed.'; stk_error(errmsg, 'IllegalIndexing'); case '.' if strcmp (idx(1).subs, 'data') && length (idx) > 1, if strcmp (idx(2).type, '()') x = subsasgn (x, idx(2:end), val); else stk_error('Illegal indexing.', 'IllegalIndexing'); end else % other than 'data' if length (idx) > 1 val = subsasgn (get (x, idx(1).subs), idx(2:end), val); end x = set (x, idx(1).subs, val); end end end % function subsasgn %!shared x, s, t, data %! x = stk_dataframe(rand(3, 2)); %! s = {'a'; 'b'; 'c'}; %! t = {'xx' 'yy'}; %!test %! x.rownames = s; %! assert (isequal(get(x, 'rownames'), s)) %!test %! x.colnames = t; %! assert (isequal(get(x, 'rownames'), s)) %! assert (isequal(get(x, 'colnames'), t)) %!test %! x.rownames{2} = 'dudule'; %! assert (isequal(get(x, 'rownames'), {'a'; 'dudule'; 'c'})) %! assert (isequal(get(x, 'colnames'), t)) %!test %! x.colnames{1} = 'martha'; %! assert (isequal(get(x, 'rownames'), {'a'; 'dudule'; 'c'})) %! assert (isequal(get(x, 'colnames'), {'martha' 'yy'})) % %!error x.colnames{1} = 'yy' % %!error x.colnames = {'xx' 'xx'} %!test %! data = stk_dataframe(zeros(3, 2), {'x1' 'x2'}); %! u = rand(3, 1); data.x2 = u; %! assert (isequal(double(data), [zeros(3, 1) u])) %!test %! data = stk_dataframe(zeros(3, 2), {'x1' 'x2'}); %! data.x2(3) = 27; %! assert (isequal(double(data), [0 0; 0 0; 0 27])) %!error data.toto = rand(3, 1); %!shared x %! x = stk_dataframe(reshape(1:12, 4, 3), {'u' 'v' 'w'}); %!test %! x(:, 2) = []; %! assert (isequal (size (x), [4 2])) %! assert (isequal (double (x), [1 9; 2 10; 3 11; 4 12])) %! assert (isequal (get (x, 'colnames'), {'u' 'w'})) %! assert (isempty (get (x, 'rownames'))) %!test %! x(2, :) = []; %! assert (isequal (size (x), [3 2])) %! assert (isequal (double (x), [1 9; 3 11; 4 12])) %! assert (isempty (get (x, 'rownames'))) %!test %! x.rownames = {'a'; 'b'; 'c'}; %! x(2, :) = []; %! assert (isequal (size (x), [2 2])) %! assert (isequal (double (x), [1 9; 4 12])) %! assert (isequal (x.rownames, {'a'; 'c'})) %!test % change one value with matrix-style indexing %! x(1, 2) = 11; %! assert (isequal (size (x), [2 2])) %! assert (isequal (double (x), [1 11; 4 12])) %!test % change one value with linear indexing %! x(3) = 13; %! assert (isequal (size (x), [2 2])) %! assert (isequal (double (x), [1 13; 4 12])) %!assert (isequal (double (x(:, :)), [1 13; 4 12])); %!test % assignment to a variable that doesn't exist %! A = stk_dataframe (7.1); %! clear B; B(2) = A; %! assert (strcmp (class (B), 'stk_dataframe')) %! assert (isequal (B.data, [0 7.1])); %!test % repmat %! x = stk_dataframe (1); %! y = repmat (x, 2, 3); %! assert (isa (y, 'stk_dataframe')); %! assert (isequal (y.data, ones (2, 3))); %!test %! x(:, :) = []; %! assert (isempty (x)); %!test % Delete the only row of a one-row dataframe %! y1 = stk_dataframe ([1.2 3.33], {'mean', 'var'}); %! y1(1, :) = []; % Remove the only row of data %! assert (isequal (size (y1), [0 2])) %! assert (isequal (y1.colnames, {'mean', 'var'})) %! y11 = get (y1, 'mean'); %! assert (isempty (y11)); %!error x{1} = 2; %!error x(1, 2) = []; %!error x(1, 2).a = 3; %--- tests with a univariate dataframe ---------------------------------------- %!shared x %! x = stk_dataframe((1:5)'); % linear indexing %!test x(2) = 0; assert (isequal (double (x), [1; 0; 3; 4; 5])); %!test x(3) = []; assert (isequal (double (x), [1; 0; 4; 5])); % matrix-style indexing also %!test x(3, 1) = 0; assert (isequal(double(x), [1; 0; 0; 5])); % three indices is not allowed (even if the third is one...) %!error x(3, 1, 1) = 297; %!test % create a new row and a new column through subsasgn() %! x = stk_dataframe (rand (5, 2)); x(6, 3) = 7; %! assert(isequal(size(x), [6, 3])); %--- tests adding row/columns through row/columns names ------------------------ %!test %! x = stk_dataframe ([]); %! x.colnames{2} = 'v'; %! x.rownames{2} = 'b'; %! assert (isequal (x.rownames, {''; 'b'})); %! assert (isequal (x.colnames, {'' 'v'})); %! assert (isequalwithequalnans (x.data, nan (2))); %--- test replacing one column using ':' --------------------------------------- %!shared x %! x = stk_dataframe (reshape (1:12, 4, 3), {'u' 'v' 'w'}); %!test % change one column using ':', plain numeric argument %! y = [0; 9; 0; 9]; %! z = x; z(:, 2) = y; %! assert (isequal (z(:, 1), x(:, 1))); %! assert (isequal (z(:, 2).data, y)); %!test % change one column using ':', skt_dataframe argument %! y = stk_dataframe ([0; 9; 0; 9], {'y'}); %! z = x; z(:, 2) = y; %! assert (isequal (z(:, 1), x(:, 1))); %! assert (isequal (z(:, 2), y)); %--- test replacing one row using ':' ------------------------------------------ %!shared x %! x = stk_dataframe (reshape (1:12, 4, 3), [], {'a'; 'b'; 'c'; 'd'}); %!test % change one row using ':', plain numeric argument %! y = [7 7 7]; %! z = x; z(3, :) = y; %! assert (isequal (z(1, :), x(1, :))); %! assert (isequal (z(3, :).data, y)); %!test % change one row using ':', skt_dataframe argument %! y = stk_dataframe ([7 7 7], [], {'y'}); %! z = x; z(3, :) = y; %! assert (isequal (z(1, :), x(1, :))); %! assert (isequal (z(3, :), y)); %--- change several values at once with linear indxing ------------------------- %!shared x %! x = stk_dataframe (zeros (2), {'u' 'v'}); %!test % first column %! x(1:2) = 1; %! y = stk_dataframe ([1 0; 1 0], {'u' 'v'}); %! assert (isequal (x, y)); %!test % one more element %! x(1:3) = 2; %! y = stk_dataframe ([2 2; 2 0], {'u' 'v'}); %! assert (isequal (x, y)); %!error % too many elements %! x(1:5) = 3; stk/inst/arrays/@stk_dataframe/plot.m0000664000175000017500000001656012617165715016637 0ustar bectbect% PLOT [overload base function] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function plot (varargin) % Parse the list of input arguments [h, plot_elem, keyval_pairs] = parse_args_ (varargin{:}); % Read hold state b = ishold (); % Plot all n = length (plot_elem); for i = 1:n p = plot_elem(i); plot_ (h, p.x, p.z, p.S, keyval_pairs{:}); if (i == 1) && (n > 1), hold on; end end % Restore hold state if (~ b) && (n > 1), hold off; end end % function plot function plot_ (h, x, z, S, varargin) %--- Handle stk_dataframe inputs ------------------------------------------ if isa (x, 'stk_dataframe'), xlab = x.colnames; x = double (x); else xlab = {}; end if isa (z, 'stk_dataframe'), zlab = z.colnames; z = double (z); else zlab = {}; end %--- Deal with various forms for x and z ---------------------------------- if isempty (x) % Special: x not provided % Tolerate row vector for z if isrow (z), z = z'; end % Create a default x x = (1:(size (z, 1)))'; else % General case % Tolerate row vector for x if isrow (x), x = x'; end % Number of points n = size (x, 1); % Tolerate row vector for z if isequal (size (z), [1 n]), z = z'; end end %--- Plot and set labels -------------------------------------------------- if isempty (S) plot (h, x, z, varargin{:}); else plot (h, x, z, S, varargin{:}); end if ~ isempty (xlab), if size (x, 2) == 1 stk_xlabel (xlab{1}); end % Note: in the case where x has several columns (and z also) we could % create more elaborate legends, e.g., "Zj versus Xj". Another time. end if ~ isempty (zlab) if size (z, 2) == 1, stk_ylabel (zlab{1}); else legend (zlab{:}); end end end % function plot_ %#ok<*SPWRN,*TRYNC> function [h, plot_elem, keyval_pairs] = parse_args_ (arg1, varargin) % Plot is highly polymorphic, making the task of parsing input arguments a % rather lengthy and painful one... %--- Formal grammar for the list of arguments ----------------------------- % % Terminal symbols % % h = a handle to an axes object % x = abscissa argument % z = ordinate argument % S = symbol/color/line string argument % k = key in a key-val pair % v = value in a key-val pair % % Derivation rules % % ::= | h % ::= % ::= k v | k v % ::= | % ::= | % ::= | % ::= x z | x z S % ::= z | z S % First, the easy bit: if the first argument can be interpreted as a handle, % then it always is. arg1_handle = false; if isscalar (arg1) && isa (arg1, 'double'), try arg1_handle = strcmp (get (arg1, 'Type'), 'axes'); end end if arg1_handle, h = arg1; if nargin == 1, stk_error ('Not enough input arguments.', 'NotEnoughInputArgs'); else arg1 = varargin{1}; varargin(1) = []; end else h = gca; end % Then, arg1 *must* be a "numeric" argument if ischar (arg1) stk_error ('Syntax error. Unexpected string argument.', 'TypeMismatch'); end % Then, process remaining arguments recursively if isempty (varargin) % Special case: x has been omitted, and there are no additional args plot_elem = struct ('x', [], 'z', {arg1}, 'S', []); keyval_pairs = {}; elseif ischar (varargin{1}) % Special case: x has been omitted, and there *are* additional args if mod (length (varargin), 2) S = []; keyval_pairs = parse_keyval_ (varargin); else S = varargin{1}; keyval_pairs = parse_keyval_ (varargin{2:end}); end plot_elem = struct ('x', [], 'z', {arg1}, 'S', {S}); else % General case [plot_elem, keyval_pairs] = parse_args__ (arg1, varargin{:}); end end % function parse_args_ function [plot_elem, keyval_pairs] = parse_args__ (x, z, varargin) if ischar (x) || ischar (z) display (x); display (z); stk_error (['Syntax error. At this point, we were expecting ' ... 'another numeric (x, z) pair.'], 'SyntaxError'); end if isempty (varargin) plot_elem = struct ('x', {x}, 'z', {z}, 'S', []); keyval_pairs = {}; elseif ~ ischar (varargin{1}) % expect another (x, z) pair after this one plot_elem = struct ('x', {x}, 'z', {z}, 'S', []); [plot_elem_, keyval_pairs] = parse_args__ (varargin{:}); plot_elem = [plot_elem plot_elem_]; elseif length (varargin) == 1 % S plot_elem = struct ('x', {x}, 'z', {z}, 'S', varargin(1)); keyval_pairs = {}; elseif ischar (varargin{2}) % S, key, val, ... plot_elem = struct ('x', {x}, 'z', {z}, 'S', varargin(1)); keyval_pairs = parse_keyval_ (varargin{2:end}); elseif length (varargin) == 2 % key, val plot_elem = struct ('x', {x}, 'z', {z}, 'S', []); keyval_pairs = varargin; elseif ~ ischar (varargin{3}) % S, x, z, ... plot_elem = struct ('x', {x}, 'z', {z}, 'S', varargin(1)); [plot_elem_, keyval_pairs] = parse_args__ (varargin{2:end}); plot_elem = [plot_elem plot_elem_]; else % key, val, key, val, ... plot_elem = struct ('x', {x}, 'z', {z}, 'S', []); keyval_pairs = parse_keyval_ (varargin{:}); end end % function parse_args__ function keyval_pairs = parse_keyval_ (key, val, varargin) if nargin == 0, keyval_pairs = {}; elseif nargin == 1, errmsg = 'Syntax error. Incomplete key-value pair'; stk_error (errmsg, 'NotEnoughInputArgs'); elseif ~ ischar (key) display (key); stk_error (['Syntax error. At his point, we were expecting a ' ... 'key-value pair, but key is not a string.'], 'TypeMismatch'); else keyval_pairs = [{key, val} parse_keyval_(varargin{:})]; end end % function parse_keyval_ %!test % plot with x as a vector and z as a (univariate) dataframe %! x = linspace(0, 2*pi, 30)'; %! z = stk_dataframe(sin(x)); %! figure; plot(x, z); close(gcf); %!test % plot with x as a vector and z as a (multivariate) dataframe %! x = linspace(0, 2*pi, 30)'; %! z = stk_dataframe([sin(x) cos(x)], {'sin' 'cos'}); %! figure; plot(x, z); close(gcf); %!test % plot with x as a dataframe and z as a vector %! x = stk_dataframe(linspace(0, 2*pi, 30)'); %! z = sin(double(x)); %! figure; plot(x, z); close(gcf); stk/inst/arrays/@stk_dataframe/plus.m0000664000175000017500000000231012617165715016630 0ustar bectbect% PLUS [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = plus(x1, x2) y = bsxfun(@plus, x1, x2); end % function plus %!test stk_test_dfbinaryop(@plus, rand(7, 2), rand(7, 2)); %!test stk_test_dfbinaryop(@plus, rand(7, 2), pi); %!error stk_test_dfbinaryop(@plus, rand(7, 2), rand(7, 3)); stk/inst/arrays/@stk_dataframe/uminus.m0000664000175000017500000000203512617165715017171 0ustar bectbect% UMINUS [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = uminus (x) x.data = - x.data; end % function uminus stk/inst/arrays/@stk_dataframe/min.m0000664000175000017500000000413012617165715016432 0ustar bectbect% MIN [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = min (x, y, dim) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end varargout = cell (1, max (1, nargout)); if (nargin < 2) || (isempty (y)), % Act on rows or columns if nargin < 3, dim = 1; end [varargout{:}] = apply (x, dim, @min, []); else % Apply 'min' elementwise if nargin > 2, errmsg = 'Too many input arguments (elementwise min assumed)'; stk_error (errmsg, 'TooManyInputArgs'); else [varargout{:}] = bsxfun (@min, x, y); end end % if end % function min %!test stk_test_dfbinaryop ('min', rand(7, 2), rand(7, 2)); %!test stk_test_dfbinaryop ('min', rand(7, 2), pi); %!error stk_test_dfbinaryop ('min', rand(7, 2), rand(7, 3)); %!shared x1, df1 %! x1 = rand(9, 3); %! df1 = stk_dataframe(x1, {'a', 'b', 'c'}); %!assert (isequal (min(df1), min(x1))) %!assert (isequal (min(df1, [], 1), min(x1))) %!assert (isequal (min(df1, [], 2), min(x1, [], 2))) %!error (min(df1, df1, 2)) %!test %! x = stk_dataframe ([5; 2; 4]); %! [M, k] = min (x); %! assert ((M == 2) && (k == 2)); stk/inst/arrays/@stk_dataframe/stk_sprintf_rownames.m0000664000175000017500000000262512617165715022137 0ustar bectbect% STK_SPRINTF_ROWNAMES returns the row names of an array % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_rownames (x) n = size (x, 1); rownames = get (x, 'rownames'); if isempty (rownames) s = stk_sprintf_rownames (zeros (n, 0)); else s = '{'; for j = 1:(n-1), s = [s sprintf('''%s''; ', x.rownames{j})]; %#ok end s = [s sprintf('''%s''}', x.rownames{end})]; end end % function stk_sprintf_rownames stk/inst/arrays/@stk_dataframe/gt.m0000664000175000017500000000235012617165715016263 0ustar bectbect% GT [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = gt(x1, x2) y = bsxfun(@gt, x1, x2); end % function gt %!test stk_test_dfbinaryop(@gt, floor(3*rand(7, 2)), floor(3*rand(7, 2))); %!test stk_test_dfbinaryop(@gt, floor(3*rand(7, 2)), 1.0); %!error stk_test_dfbinaryop(@gt, floor(3*rand(7, 2)), floor(3*rand(7, 3))); stk/inst/arrays/@stk_dataframe/reshape.m0000664000175000017500000000267212617165715017307 0ustar bectbect% RESHAPE [overload base function] % % Note : the result of reshaping a dataframe is again a dataframe, but all row % and columns names are lost in the process. % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = reshape (x, varargin) % Silently assume that x is a dataframe % (this can go wrong if a dataframe is hidden in varargin, but hey...) y = stk_dataframe (reshape (x.data, varargin{:})); end % function reshape %!test %! x = stk_dataframe (randn (10, 3)); %! y = reshape (x, 5, 6); %! assert (isa (y, 'stk_dataframe') && isequal (size (y), [5 6])) stk/inst/arrays/@stk_dataframe/horzcat.m0000664000175000017500000001156112617165715017327 0ustar bectbect% HORZCAT [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = horzcat (x, y, varargin) if nargin < 2, y = []; end %--- Get raw data --------------------------------------------------------- x_data = double (x); y_data = double (y); %--- Get column and row names of inputs ----------------------------------- if isa (x, 'stk_dataframe') x_colnames = get (x, 'colnames'); x_rownames = get (x, 'rownames'); else x_colnames = {}; x_rownames = {}; end if isa (y, 'stk_dataframe') y_colnames = get (y, 'colnames'); y_rownames = get (y, 'rownames'); else y_colnames = {}; y_rownames = {}; end %--- Create output row names ---------------------------------------------- if isempty (x_rownames) rownames = y_rownames; elseif isempty (y_rownames) rownames = x_rownames; else if (~ isequal (size (x_rownames), size (y_rownames))) ... || (any (~ strcmp (x_rownames, y_rownames))) warning ('STK:horzcat:IncompatibleRowNames', sprintf ( ... ['Incompatible row names !\nThe output of horzcat will ' ... 'have no row names.'])); rownames = {}; else rownames = x_rownames; end end %--- Create output column names ------------------------------------------- bx = isempty (x_colnames); by = isempty (y_colnames); if bx && by, % none of the argument has row names colnames = {}; else % at least of one the arguments has column names if bx, x_colnames = repmat ({''}, 1, size (x_data, 2)); end if by, y_colnames = repmat ({''}, 1, size (y_data, 2)); end colnames = [x_colnames y_colnames]; end %--- Create output -------------------------------------------------------- if strcmp (class (x), 'stk_dataframe') %#ok % Optimize for speed (no need to call constructor) x.data = [x_data y_data]; x.colnames = colnames; x.rownames = rownames; else x = stk_dataframe ([x_data y_data], colnames, rownames); end if ~ isempty (varargin), x = horzcat (x, varargin{:}); end end % function @stk_dataframe.horzcat % IMPORTANT NOTE: [x y ...] fails to give the same result as horzcat (x, y, % ...) in some releases of Octave. As a consequence, all tests must be % written using horzcat explicitely. %!shared u, v %! u = rand(3, 2); %! v = rand(3, 2); %% % Horizontal concatenation of two dataframes %!test %! x = stk_dataframe(u, {'x1' 'x2'}); %! y = stk_dataframe(v, {'y1' 'y2'}); %! z = horzcat (x, y); %! assert(isa(z, 'stk_dataframe') && isequal(double(z), [u v])); %! assert(all(strcmp(z.colnames, {'x1' 'x2' 'y1' 'y2'}))); %!test %! x = stk_dataframe(u, {'x1' 'x2'}, {'a'; 'b'; 'c'}); %! y = stk_dataframe(v, {'y1' 'y2'}); %! z = horzcat (x, y); %! assert(isa(z, 'stk_dataframe') && isequal(double(z), [u v])); %! assert(all(strcmp(z.colnames, {'x1' 'x2' 'y1' 'y2'}))); %! assert(all(strcmp(z.rownames, {'a'; 'b'; 'c'}))); %!test %! x = stk_dataframe(u, {'x1' 'x2'}); %! y = stk_dataframe(v, {'y1' 'y2'}, {'a'; 'b'; 'c'}); %! z = horzcat (x, y); %! assert(isa(z, 'stk_dataframe') && isequal(double(z), [u v])); %! assert(all(strcmp(z.colnames, {'x1' 'x2' 'y1' 'y2'}))); %! assert(all(strcmp(z.rownames, {'a'; 'b'; 'c'}))); %!test % incompatible row names %! x = stk_dataframe (u, {'x1' 'x2'}, {'a'; 'b'; 'c'}); %! y = stk_dataframe (v, {'y1' 'y2'}, {'a'; 'b'; 'd'}); %! z = horzcat (x, y); %! assert (isequal (z.rownames, {})); %% % Horizontal concatenation [dataframe matrix] or [matrix dataframe] %!test %! x = stk_dataframe (u); %! z = horzcat (x, v); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), [u v])); %!test %! y = stk_dataframe (v); %! z = horzcat (u, y); %! assert (isa (z, 'stk_dataframe') && isequal (double (z), [u v])); %% % Horizontal concatenation of more than two elements %!test %! x = stk_dataframe(u, {'x1' 'x2'}); %! y = stk_dataframe(v, {'y1' 'y2'}); %! z = horzcat (x, y, u, v); %! assert(isa(z, 'stk_dataframe') && isequal(double(z), [u v u v])); stk/inst/arrays/@stk_dataframe/disp.m0000664000175000017500000000371212617165715016613 0ustar bectbect% DISP [overload base function] % % Example: % format short % x = [1 1e6 rand; 10 -1e10 rand; 100 1e-22 rand]; % disp (stk_dataframe (x)) % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function disp (x, verbosity, prefix, data_col_width) if (nargin < 2) || (isempty (verbosity)), verbosity = stk_options_get ('stk_dataframe', 'disp_format'); end if (nargin < 3) || (isempty (prefix)) prefix = ' '; end if (nargin < 4) || (isempty (data_col_width)), data_col_width = []; end s = stk_sprintf (x, verbosity, data_col_width); disp ([repmat(prefix, size(s, 1), 1) s]); end % function disp %!shared x, fmt %! try % doesn't work on old Octave versions, nevermind %! fmt = get (0, 'Format'); %! catch %! fmt = nan; %! end %! x = stk_dataframe (rand (3, 2)); %!test format rat; disp (x); %!test format long; disp (x); %!test format short; disp (x); %! if ~isnan (fmt), set (0, 'Format', fmt); end %!test disp (stk_dataframe (zeros (0, 1))) %!test disp (stk_dataframe (zeros (0, 2))) stk/inst/arrays/@stk_dataframe/times.m0000664000175000017500000000231612617165715016774 0ustar bectbect% TIMES [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = times(x1, x2) y = bsxfun(@times, x1, x2); end % function times %!test stk_test_dfbinaryop(@times, rand(7, 2), rand(7, 2)); %!test stk_test_dfbinaryop(@times, rand(7, 2), pi); %!error stk_test_dfbinaryop(@times, rand(7, 2), rand(7, 3)); stk/inst/arrays/@stk_dataframe/cat.m0000664000175000017500000000352112617165715016421 0ustar bectbect% CAT [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = cat(dim, varargin) if dim == 1 % concatenate along dimension 1, i.e., vertically z = vertcat(varargin{:}); else if dim ~= 2 errmsg = 'Dataframes can only be concatenated along dimension 1 or 2.'; stk_error(errmsg, 'IncorrectArgument'); else % concatenate along dimension 2, i.e., horizontally z = horzcat(varargin{:}); end end % if end % function cat %!shared u, v, x, y %! u = rand(3, 2); %! v = rand(3, 2); %! x = stk_dataframe(u); %! y = stk_dataframe(v); %!test % vertical %! z = cat(1, x, y); %! assert(isa(z, 'stk_dataframe')); %! assert(isequal(double(z), [u; v])); %!error z = cat(3, x, y); %!test % horizontal %! y = stk_dataframe(v, {'y1' 'y2'}); %! z = cat(2, x, y); %! assert(isa(z, 'stk_dataframe')); %! assert(isequal(double(z), [u v])); %! assert(all(strcmp(z.colnames, {'' '' 'y1' 'y2'}))); stk/inst/arrays/@stk_dataframe/ylim.m0000664000175000017500000000243012617165715016622 0ustar bectbect% YLIM [overloaded base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = ylim (arg1, arg2) varargout = cell (1, nargout); if nargin == 1, [varargout{:}] = ylim (double (arg1)); return end if isa (arg1, 'stk_dataframe'), arg1 = double (arg1); end if isa (arg2, 'stk_dataframe'), arg2 = double (arg2); end [varargout{:}] = ylim (arg1, arg2); end % function ylim stk/inst/arrays/@stk_dataframe/quantile.m0000664000175000017500000000255612617165715017503 0ustar bectbect% QUANTILE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = quantile (x, p, dim) if nargin < 3, dim = 1; end z = apply (x, dim, @quantile, p); end % function quantile %!shared x1, df1, p %! x1 = rand (9, 3); %! df1 = stk_dataframe (x1, {'a', 'b', 'c'}); %! p = 0.95; %!assert (isequal (quantile (df1, p), quantile (x1, p))) %!assert (isequal (quantile (df1, p, 1), quantile (x1, p))) %!assert (isequal (quantile (df1, p, 2), quantile (x1, p, 2))) stk/inst/arrays/@cell/0000775000175000017500000000000012617165714013604 5ustar bectbectstk/inst/arrays/@cell/stk_sprintf_sizetype.m0000664000175000017500000000244512617165714020271 0ustar bectbect% STK_SPRINTF_SIZETYPE prints the size and type into a string % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_sizetype (x) t = size (x); s = ''; for i = 1:(length(t) - 1), s = [s sprintf('%dx', t(i))]; %#ok end s = [s sprintf('%d %s array', t(end), class (x))]; end % function stk_sprintf_sizetype stk/inst/arrays/generic/0000775000175000017500000000000012617165716014203 5ustar bectbectstk/inst/arrays/generic/stk_boundingbox.m0000664000175000017500000000341112617165716017557 0ustar bectbect% STK_BOUNDINGBOX constructs the bounding box for a set of points % % CALL: B = stk_boundingbox (X) % % returns the bounding box of X, defined as: % % B = [min(X); max(X)]. % % The result is an stk_hrect object. % % See also: stk_hrect % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function box = stk_boundingbox (x) if nargin > 1, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if (~ ismatrix (x)) stk_error (['Arrays with more than two dimensions are not ' ... 'supported.'], 'IncorrectSize'); end xmin = min (x, [], 1); xmax = max (x, [], 1); box = stk_hrect ([xmin; xmax]); end % function stk_boundingbox %!shared x, y, cn %! cn = {'a', 'b', 'c'}; %! x = [0 3 2; 1 4 1; 7 0 2]; %!error y = stk_boundingbox (); %!test y = stk_boundingbox (x); %!error y = stk_boundingbox (x, 1); %!assert (isequal (y.data, [0 0 1; 7 4 2])); stk/inst/arrays/generic/stk_commonsize.m0000664000175000017500000000406012617165716017425 0ustar bectbect% STK_COMMONSIZE ... % % TODO: describe differences with Octave's common_size function. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = stk_commonsize (varargin) n = length (varargin); if n == 0, varargout = {}; else if n == 1 % varargin{1} is expected to be a cell array in this case C = varargin{1}; n = length (C); else C = varargin; end d = cellfun (@ndims, C); s = ones (n, max (d)); for i = 1:n, s(i, 1:d(i)) = size (C{i}); end smax = max (s); % Take care of empty dimensions, if any b = (smax > 0); smax = smax (b); s = s(:, b); nrep = ones (size (smax)); for i = 1:n, nrep(b) = smax ./ s(i, :); nrep_one = (nrep == 1); if ~ all ((s(i, :) == 1) | nrep_one) error ('Input arguments cannot be brought to a common size.'); elseif ~ all (nrep_one) C{i} = repmat (C{i}, nrep); end end if nargout > 1, varargout = C(1:nargout); else varargout = {C}; end end end % function stk_commonsize stk/inst/arrays/generic/stk_isdominated.m0000664000175000017500000000604112617165716017543 0ustar bectbect% STK_ISDOMINATED returns true for dominated rows % % CALL: ISDOM = stk_isdominated (A, B) % % returns a vector ISDOM of logicals, where ISDOM(i) is true if A(i, :) % is dominated by one of the rows of B. A row B(j, :) is said to % dominate A(i, :) if % % B(j, k) <= A(i, k) for all k in {1, 2, ..., d} % % and % % B(j, k) < A(i, k) for at least one such k, % % where d is the number of columns. In other words: smaller is better. % % CALL: ISDOM = stk_isdominated (A, B, DO_SORTROWS) % % does the same but, if DO_SORTROWS == false, assumes that the rows of % B are already sorted in ascending lexical order. % % CALL: [ISDOM, DPOS] = stk_isdominated (A, B, DO_SORTROWS) % % also returns a vector DPOS such that DPOS(i) = 0 if A(i, :) is non- % dominated, and DPOS(i) gives the index of a row in B that dominates % A(i, :) otherwise. % % See also: sortrows, stk_paretofind % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [isdom, dpos, Bsnd] = stk_isdominated (A, B, do_sortrows) A = double (A); B = double (B); if nargin < 3, do_sortrows = true; end if do_sortrows, ndpos = stk_paretofind (B); Bsnd = B(ndpos, :); end if nargout < 2 isdom = __stk_isdominated_mex__ (A, Bsnd); else [isdom, drank] = __stk_isdominated_mex__ (A, Bsnd); if do_sortrows, dpos = zeros (size (drank)); dpos(isdom) = ndpos(drank(isdom)); end end end % function stk_isdominated %!test %! A = [1 3 2]; %! B = [0 0 0]; %! [isdom, dpos] = stk_isdominated (A, B); %! assert (isdom == 1); %! assert (dpos == 1); %!test %! A = [1 3 2]; %! B = [0 0 3]; %! [isdom, dpos] = stk_isdominated (A, B); %! assert (isdom == 0); %! assert (dpos == 0); %!test %! A = [1 3 2]; %! B = [0 0 0; 0 0 3]; %! [isdom, dpos] = stk_isdominated (A, B); %! assert (isdom == 1); %! assert (dpos == 1); %!test %! A = [1 3 2]; %! B = [0 0 3; 0 0 0]; %! [isdom, dpos] = stk_isdominated (A, B); %! assert (isdom == 1); %! assert (dpos == 2); %!test %! A = [1 3 2; 1 0 1; -1 0 0; 1 3 2]; %! B = [1 0 0; 0 0 3; 0 0 0]; %! [isdom, dpos] = stk_isdominated (A, B); %! assert (isequal (isdom, logical ([1; 1; 0; 1]))); %! assert (isequal (dpos, [3; 3; 0; 3])); stk/inst/arrays/generic/stk_sprintf_sizetype.m0000664000175000017500000000272412617165716020670 0ustar bectbect% STK_SPRINTF_SIZETYPE prints the size and type into a string % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_sizetype (x) if ~ isnumeric (x) errmsg = sprintf ('Incorrect argument type: %s', class (x)); stk_error (errmsg, 'IncorrectType'); else t = size (x); s = ''; for i = 1:(length(t) - 1), s = [s sprintf('%dx', t(i))]; %#ok end s = [s sprintf('%d %s array', t(end), class (x))]; end end % function stk_sprintf_sizetype stk/inst/arrays/generic/stk_paretofind.m0000664000175000017500000000534512617165716017404 0ustar bectbect% STK_PARETOFIND finds non-dominated rows in an array % % CALL: [NDPOS, DRANK] = stk_paretofind (X) % % returns the indices NDPOS such that X(NDPOS, :) contains all non- % dominated rows of X, sorted in (ascending) lexical order. A row % X(i, :) is said to dominate another row X(j, :) if % % X(i, k) <= X(j, k) for all k in {1, 2, ..., d} % % and % % X(i, k) < X(j, k) for at least one such k, % % where d is the number of columns. In other words: smaller is better. % For each row X(i, :), DRANK(i) is equal to zero if the row is non- % dominated, and equal to the smallest j such that X(i, :) is dominated % by X(NDPOS(j), :) otherwise. % % See also: sortrows, stk_isdominated % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = stk_paretofind (x) varargout = cell (1, max (1, nargout)); [varargout{:}] = __stk_paretofind_mex__ (double (x)); end % function stk_paretofind %!shared x, ndpos, drank %! x = [ ... %! 0 2; ... %! 2 2; ... %! ]; %!test [ndpos, drank] = stk_paretofind (x); %!assert (isequal (ndpos, 1)); %!assert (isequal (drank, [0; 1])); %!shared x, ndpos, drank %! x = [ ... %! 3 2; ... %! 2 2; ... %! ]; %!test [ndpos, drank] = stk_paretofind (x); %!assert (isequal (ndpos, 2)); %!assert (isequal (drank, [1; 0])); %!shared x, ndpos, drank %! x = [ ... %! 1 0; ... %! 2 0; ... %! 0 2; ... %! 2 2; ... %! -1 3 ]; %!test [ndpos, drank] = stk_paretofind (x); %!assert (isequal (ndpos, [5; 3; 1])); %!assert (isequal (drank, [0; 3; 0; 2; 0])); %!shared x, ndpos, drank %! x = [ ... %! 1 0; ... %! 2 0; ... %! 0 2; ... %! 2 2; ... %! -1 3; ... %! -1 4; ... %! 2 2 ]; %!test [ndpos, drank] = stk_paretofind (x); %!assert (isequal (ndpos, [5; 3; 1])); %!assert (isequal (drank, [0; 3; 0; 2; 0; 1; 2])); stk/inst/arrays/generic/stk_length.m0000664000175000017500000000272412617165716016530 0ustar bectbect% STK_LENGTH return the "length" of an array % % CALL: L = stk_length (X) % % returns the "length" of the data array X. % % NOTE: % % Currently, the length of a data array (numeric array or stk_dataframe % object) is defined as SIZE (X, 1) but this might change in future % versions of STK. Note that this is not the same as length (X). % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function l = stk_length (x) l = size (x, 1); end % function stk_length %!assert (isequal (stk_length ([1 2; 3 4; 5 6]), 3)); stk/inst/arrays/generic/stk_normalize.m0000664000175000017500000000334012617165716017242 0ustar bectbect% STK_NORMALIZE normalizes a dataset to [0; 1] ^ DIM % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, a, b] = stk_normalize (x, box, varargin) if nargin < 2, box = []; end % Ensure that box is an stk_hrect object if ~ isa (box, 'stk_hrect') if isempty (box), box = stk_boundingbox (x); else box = stk_hrect (box); end end % Call @stk_hrect/stk_normalize [x, a, b] = stk_normalize (x, box, varargin{:}); end % function stk_normalize %!shared x, box, y1, y2, y3, y4 %! n = 5; box = [2; 3]; x = box(1) + diff (box) * rand (n, 1); %!error y1 = stk_normalize (); %!test y2 = stk_normalize (x); %!test y3 = stk_normalize (x, box); %!error y4 = stk_normalize (x, box, log (2)); %!test assert (~ any ((y2 < -10 * eps) | (y2 > 1 + 10 * eps))); %!test assert (~ any ((y3 < -10 * eps) | (y3 > 1 + 10 * eps))); stk/inst/arrays/generic/stk_sprintf.m0000664000175000017500000000506312617165716016733 0ustar bectbect% STK_SPRINTF_DATA prints the content of an array into a string % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf (x, verbosity, data_col_width) % verbosity will be ignored, but let's check that it's a legal value anyway if (nargin > 1) && (~ ismember (verbosity, {'basic', 'verbose'})) errmsg = 'verbosity should be ''basic'' or ''verbose''.'; stk_error (errmsg, 'InvalidArgument'); end % Only the case of numeric array is handled here if ~ isnumeric (x) errmsg = sprintf ('Incorrect argument type: %s', class (x)); stk_error (errmsg, 'IncorrectType'); end x = double (x); [n, d] = size (x); if (n == 0) || (d == 0) s = '[] (empty)'; else if (nargin < 2) || isempty (data_col_width) try switch get (0, 'Format') case 'short' data_col_width = 6; case 'long' data_col_width = 16; otherwise % FIXME: handle other formatting modes... data_col_width = 10; end catch % Property 'Format' doesn't exist in Octave 3.2.x data_col_width = 6; end end nb_spaces_colsep = 2; s = repmat ('', n, 1); %#ok<*AGROW> for j = 1:d, xx = stk_sprintf_colvect (x(:, j), data_col_width); s = [s xx]; % formatted data if j < d, % column separator s = [s repmat(' ', n, nb_spaces_colsep)]; end end % for end % if end % function stk_sprintf %#ok<*CTCH> stk/inst/arrays/generic/stk_sprintf_colnames.m0000664000175000017500000000265012617165716020613 0ustar bectbect% STK_SPRINTF_COLNAMES returns the column names of an array % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_colnames (x) if ~ isnumeric (x) errmsg = sprintf ('Incorrect argument type: %s', class (x)); stk_error (errmsg, 'IncorrectType'); else n = size (x, 1); if n == 1 s = sprintf ('{} (unnamed column)'); else s = sprintf ('{} (unnamed columns)'); end end end % function stk_sprintf_colnames stk/inst/arrays/generic/stk_feval.m0000664000175000017500000002725012617165716016345 0ustar bectbect% STK_FEVAL evaluates a function at given evaluation points % % CALL: Z = stk_feval (F, X) % % evaluates the function F on the evaluation points X, where % % * F can be either a function handle or a function name (string), % or a cell-array of function handles or names, and % * X can be either a numerical array or an stk_dataframe object. % % The output Z contains the evaluation results. The number of rows of Z is % the same as the number of rows of X. % % * If F is a single function (name of handle) that returns row vectors with % J elements, then Z has J columns and Z(i, :) is equal to F(X(i, :)). % * If F is a cell-array of functions (names or handles), where F{k} returns % row vectors J_k elements, then Z has J = J_1 + ... + J_K elements, and % Z(i, :) is equal to [F{1}(X(i, :)) ... F{K}(X(i, :))]. % % This two-argument form assumes that F supports vectorized evaluations. % % EXAMPLE: % % f = {@sin @cos}; % x = stk_sampling_regulargrid (100, 1, [0; 2*pi]); % x.colnames = {'x'}; % y = stk_feval (f, x); % plot (x, y); % % CALL: Z = stk_feval (F, X, DISPLAY_PROGRESS) % % displays progress messages if DISPLAY_PROGRESS is true, and does the same % as the previous form otherwise. Displaying a progress message is useful if % each evaluation of F requires a significant computation time. % % This three-argument form assumes that F supports vectorized evaluations if % DISPLAY_PROGRESS is false, and performs evaluations one by one otherwise. % % NOTE: output type % % The output of stk_feval is an stk_dataframe object if X is, with the same % row names and with column names determined automatically. Otherwise, the % type of the output of stk_feval is determined by the type of the output of % each function that is evaluated (together with the usual rules for concate- % nating arrays of different types, if necessary). % % CALL: Z = stk_feval (F, X, DISPLAY_PROGRESS, DF_OUT) % % returns an stk_dataframe output if DF_OUT is true (even if X is not an % stk_dataframe object itself), and let the usual concatenation rules % determine the output type otherwise (even if X is an stk_dataframe). % % CALL: Z = stk_feval (F, X, DISPLAY_PROGRESS, DF_OUT, VECTORIZED) % % controls whether function evaluations are performed in a "vectorized" manner % (i.e., all rows at once) or one row after the other. This form can be used % to override the default rules explained above. Vectorized evaluations are % usually faster but some functions do not support them. % % See also feval % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = stk_feval (f, x, progress_msg, df_out, vectorized) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Check 'progress_msg' argument if (nargin < 3) || (isempty (progress_msg)), progress_msg = false; else progress_msg = logical (progress_msg); end % Check 'df_out' argument if (nargin < 4) || (isempty (df_out)), % Default: type stability df_out = isa (x, 'stk_dataframe'); else df_out = logical (df_out); end % Check 'vectorized' argument if (nargin < 5) || (isempty (vectorized)), % Default: use vectorized evaluations, unless progress_msg is true vectorized = ~ progress_msg; else vectorized = logical (vectorized); end % Turn f into a cell (if it isn't already one) if ~ iscell (f), f = {f}; end % Number of functions numfcs = numel (f); % Check f and extract function names if df_out fname = cell (size (f)); truncated_fname = false (size (f)); for k = 1:numfcs, if ischar (f{k}), fname{k} = f{k}; else try fname{k} = func2str (f{k}); catch fname{k} = sprintf ('F%d', k); end end % Truncate long function names if (length (fname{k})) > 15 fname{k} = sprintf ('F%d', k); truncated_fname(k) = true; end end end % Extract numeric data xdata = double (x); % Zero-dimensional inputs are not allowed [n, d] = size (xdata); if d == 0, error ('zero-dimensional inputs are not allowed.'); end % Each function can have several outputs => we will try to recover meaningful % column names by looking at these outputs and store them in: if df_out fcolnames = cell (1, numfcs); end if n == 0, % no input => no output z = zeros (0, numfcs); else % at least one input point output_dim = zeros (1, numfcs); if vectorized %--- Vectorized calls ---------------------------------------- z = cell (1, numfcs); for k = 1:numfcs z{k} = feval (f{k}, xdata); % Check output size if (size (z{k}, 1) ~= size (xdata, 1)) stk_error (['The size of the output is incorrect. Perhaps ' ... 'the function does not support vectorized ' ... 'evaluations.'], 'IncorrectSize'); end % Guess output dimension output_dim(k) = size (z{k}, 2); % Guess column names if df_out && (isa (z{k}, 'stk_dataframe')) fcolnames{k} = z{k}.colnames; end end else %--- Unvectorized calls: n == 1 -------------------------------------- % First evaluation: figure out the dimension of the output if progress_msg, stk_disp_progress ('feval %d/%d... ', 1, n); end z1 = []; for k = 1:numfcs % Get the evaluation result % (at this point, we don't know the size or type of zdata{k}) z1_k = feval (f{k}, xdata(1, :)); % Guess output dimension output_dim(k) = size (z1_k, 2); % Concatenate try z1 = [z1 double(z1_k)]; %#ok catch if ~ isequal (size (z1_k), [1 output_dim(k)]) stk_error (['The output of F{j} should be a scalar or ' ... 'a row vector'], 'IncorrectSize'); else rethrow (lasterror); end end % Guess column names if df_out && (isa (z1_k, 'stk_dataframe')) fcolnames{k} = z1_k.colnames; end end end % if vectorized % Begin/end indices for each block of columns j_end = cumsum (output_dim); j_beg = 1 + [0 j_end(1:end-1)]; if vectorized %--- Vectorized calls ---------------------------------------- % Concatenate function outputs z = horzcat (z{:}); else %--- Unvectorized calls: n > 1 --------------------------------------- % Prepare for subsequent evaluations z = zeros (n, j_end(end)); z(1, :) = z1; if n > 1, % Subsequent evaluations for i = 2:n, if progress_msg, stk_disp_progress ('feval %d/%d... ', i, n); end for k = 1:numfcs z(i, (j_beg(k):j_end(k))) = feval (f{k}, xdata(i, :)); end end end % if n > 1 end % if vectorized end % if n == 0 %--- Create column names ------------------------------------------------------- if df_out colnames = cell (1, size (z, 2)); for k = 1:numfcs if ~ isempty (fcolnames{k}) % We have column names, let's use them % Special case: only one function, % without a nice short displayable name if (numfcs == 1) && truncated_fname(1) prefix = ''; else prefix = [fname{1} '_']; end colnames(j_beg(k):j_end(k)) = cellfun (... @(u)(sprintf ('%s%s', prefix, u)), fcolnames{k}, ... 'UniformOutput', false); elseif output_dim(k) == 1 % Only one column and no column names colnames{j_beg(k)} = fname{k}; else % General case: several columns but no column names colnames(j_beg(k):j_end(k)) = arrayfun (... @(u)(sprintf ('%s_%d', fname{k}, u)), 1:output_dim(k), ... 'UniformOutput', false); end end end %--- Create output stk_dataframe object ---------------------------------------- if df_out if isa (x, 'stk_dataframe'), rownames = x.rownames; else rownames = {}; end z = stk_dataframe (z, colnames, rownames); end end % function stk_feval %#ok<*CTCH,*LERR> %!shared f, xt %! f = @(x)(- (0.7 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); %! xt = stk_sampling_regulargrid (20, 1, [0; 1]); %!error yt = stk_feval (); %!error yt = stk_feval (f); %!test yt = stk_feval (f, xt); %!test yt = stk_feval (f, xt, false); %!test yt = stk_feval (f, xt, false, false); %!test yt = stk_feval (f, xt, false, false, false); %!error yt = stk_feval (f, xt, false, false, false, pi^2); %!test %! N = 15; %! xt = stk_sampling_regulargrid (N, 1, [0; 1]); %! yt = stk_feval (f, xt); %! assert (isequal (size (yt), [N 1])); %!test %! x = stk_dataframe ([1; 2; 3], {'x'}, {'a'; 'b'; 'c'}); %! y = stk_feval (@(u)(2 * u), x); %! assert (isequal (y.data, [2; 4; 6])); %! assert (isequal (y.rownames, {'a'; 'b'; 'c'})); %!shared t, z_ref, n %! n = 20; %! t = stk_sampling_regulargrid (n, 1, [0; 2*pi]); %! z_ref = [sin(t.data) cos(t.data)]; %!test %! t.colnames = {'time'}; %! z = stk_feval ({@sin @cos}, t); %! assert (isa (z, 'stk_dataframe')); %! assert (isequal (z.data, z_ref)); %!test %! F = @(x)([sin(x) cos(x)]); %! z = stk_feval (F, t); %! assert (isequal (z.data, z_ref)); %!test %! t = stk_sampling_regulargrid (n, 1, [0; 2*pi]); %! F = {'sin' 'cos'}; %! z = stk_feval (F, t); %! assert (isequal (z.data, [sin(t.data) cos(t.data)])); %! assert (isequal (z.colnames, {'sin' 'cos'})); %!test % vectorized %! F = @(t)([sin(t) cos(t)]); %! G = @(t)(0.365 * t.^2 + (cos ((t - 1).*(t - 2) + 0.579033))); %! z = stk_feval ({@sin @cos G F 'tan'}, t); %! assert (isequal (z.colnames, {'sin' 'cos' 'F3' 'F4_1' 'F4_2' 'tan'})); %!test % not vectorized %! F = @(t)([sin(t) cos(t)]); %! G = @(t)(0.365 * t^2 + (cos ((t - 1)*(t - 2) + 0.579033))); %! z = stk_feval ({@sin @cos G F 'tan'}, t, [], [], false); %! assert (isequal (z.colnames, {'sin' 'cos' 'F3' 'F4_1' 'F4_2' 'tan'})); %!test % backward compatibility with old-style STK structures %! n = 15; %! x = struct ('a', (linspace (0, pi, n))'); %! y = stk_feval (@sin, x); %! assert (isequal (size (y), [n 1])); stk/inst/arrays/generic/stk_sprintf_info.m0000664000175000017500000000253612617165716017750 0ustar bectbect% STK_SPRINTF_INFO returns the 'info' string associated to an array % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_info (x) if ~ isnumeric (x) errmsg = sprintf ('Incorrect argument type: %s', class (x)); stk_error (errmsg, 'IncorrectType'); else % no info string for plain numeric arrays s = ''''' (none)'; end end % function stk_sprintf_info stk/inst/arrays/generic/stk_rescale.m0000664000175000017500000000353212617165716016663 0ustar bectbect% STK_RESCALE rescales a dataset from one box to another % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, a, b] = stk_rescale (x, box1, varargin) % Convert box1 to an stk_hrect object % (we know that box1 is not an stk_hrect object, otherwise % we wouldn't have ended up here) if isempty (box1) box1 = stk_hrect (size (x, 2)); % Default: [0; 1] ^ DIM else box1 = stk_hrect (box1); end % Call @stk_hrect/stk_rescale [x, a, b] = stk_rescale (x, box1, varargin{:}); end % function stk_rescale %!shared x %! x = rand (10, 4); %! y = stk_rescale (x, [], []); %! assert (stk_isequal_tolabs (x, y)); %!test %! y = stk_rescale(0.5, [], [0; 2]); %! assert (stk_isequal_tolabs (y, 1.0)); %!test %! y = stk_rescale (0.5, [0; 1], [0; 2]); %! assert (stk_isequal_tolabs (y, 1.0)); %!test %! y = stk_rescale (0.5, [0; 2], []); %! assert (stk_isequal_tolabs (y, 0.25)); %!test %! y = stk_rescale (0.5, [0; 2], [0; 1]); %! assert (stk_isequal_tolabs (y, 0.25)); stk/inst/arrays/generic/stk_sprintf_rownames.m0000664000175000017500000000263712617165716020652 0ustar bectbect% STK_SPRINTF_ROWNAMES returns the row names of an array % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_rownames (x) if ~ isnumeric (x) errmsg = sprintf ('Incorrect argument type: %s', class (x)); stk_error (errmsg, 'IncorrectType'); else n = size (x, 1); if n == 1 s = sprintf ('{} (unnamed row)'); else s = sprintf ('{} (unnamed rows)'); end end end % function stk_sprintf_rownames stk/inst/arrays/@stk_hrect/0000775000175000017500000000000012617165716014655 5ustar bectbectstk/inst/arrays/@stk_hrect/stk_boundingbox.m0000664000175000017500000000270412617165716020235 0ustar bectbect% STK_BOUNDINGBOX [overload STK function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function box = stk_boundingbox (x) if nargin > 1, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % An stk_hrect object is its own bounding box box = x; end % function @stk_hrect.stk_boundingbox %!shared x, y %! lb = rand (1, 5); %! ub = lb + 1; %! cn = {'a', 'b', 'c', 'd', 'e'}; %! x = stk_hrect ([lb; ub], cn); %!error y = stk_boundingbox (); %!test y = stk_boundingbox (x); %!error y = stk_boundingbox (x, 1); %!assert (isequal (y, x)); stk/inst/arrays/@stk_hrect/subsref.m0000664000175000017500000000362712617165716016514 0ustar bectbect% SUBSREF [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function t = subsref (x, idx) switch idx(1).type case '()' t = subsref (x.stk_dataframe, idx); if size (t, 1) == 2 x.stk_dataframe = t; t = x; end case '{}' % Currently {}-indexing is not supported for % stk_dataframe objects, but who knows... t = subsref (x.stk_dataframe, idx); case '.' t = get (x, idx(1).subs); if length (idx) > 1, t = subsref (t, idx(2:end)); end end end % function subsref %!test %! B = stk_hrect ([0 0 0 0; 1 2 3 4]); %! B = B(:, [1 3 4]); %! assert (strcmp (class (B), 'stk_hrect')); %! assert (isequal (double (B), [0 0 0; 1 3 4])); %!test %! B = stk_hrect ([0 0 0 0; 1 2 3 4]); %! B = B(1, :); %! assert (strcmp (class (B), 'stk_dataframe')); %! assert (isequal (double (B), [0 0 0 0])); stk/inst/arrays/@stk_hrect/ismember.m0000664000175000017500000000457512617165716016651 0ustar bectbect% ISMEMBER [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = ismember (A, B, varargin) if ~ all (cellfun (@ischar, varargin)) stk_error ('Invalid flag (should be a string).', 'InvalidArgument'); else % At least of of the arguments (A or B) is an stk_hrect, % therefore ismember should work on rows flags = unique ([{'rows'} varargin{:}]); end varargout = cell (1, max (nargout, 1)); if isa (B, 'stk_hrect'), % If B is an stk_hrect, ismember tests whether A (or the points in A) % belong to the hyper-rectangle B if nargout > 1, stk_error (['Cannot return member indices when testing for ' ... 'membership to an hyper-rectangle.'], 'TooManyOutputArgs'); end A = double (A); b1 = bsxfun (@ge, A, B.stk_dataframe.data(1, :)); b2 = bsxfun (@le, A, B.stk_dataframe.data(2, :)); varargout{1} = all (b1 & b2, 2); else % A is an stk_hrect, treat it as any other stk_dataframe would be treated [varargout{:}] = ismember (A.stk_dataframe, B, flags{:}); end end % function ismember %!shared n, box %! n = 5; %! box = stk_hrect (n); %!assert (ismember (box(1, :), box)) %!assert (ismember (box(2, :), box)) %!assert (ismember (.5 * ones (1, 5), box)) %!assert (~ ismember (box(1, :) - 1, box)) %!assert (~ ismember (box(2, :) + 1, box)) %!test %! y = double (box); y = [y; y + 2]; %! assert (isequal (ismember (y, box), [1; 1; 0; 0])) stk/inst/arrays/@stk_hrect/stk_normalize.m0000664000175000017500000000433212617165716017716 0ustar bectbect% STK_NORMALIZE normalizes a dataset to [0; 1] ^ DIM % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, a, b] = stk_normalize (x, box) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin < 2, box = []; end % Read argument x x_data = double (x); d = size (x_data, 2); % Ensure that box is an stk_hrect object if ~ isa (box, 'stk_hrect') if isempty (box) box = stk_boundingbox (x_data); % Default: bounding box else box = stk_hrect (box); end end % Read argument box box_data = double (box.stk_dataframe); if ~ isequal (size (box_data), [2 d]) errmsg = sprintf ('box should have size [2 d], with d=%d.', d); stk_error (errmsg, 'IncorrectSize'); end xmin = box_data(1, :); % lower_bounds xmax = box_data(2, :); % upper_bounds b = 1 ./ (xmax - xmin); a = - xmin .* b; x(:) = bsxfun (@plus, a, x_data * diag (b)); end % function stk_normalize %!shared x, box, y1, y2, y3, y4 %! n = 5; box = stk_hrect ([2; 3]); %! x = 2 + rand (n, 1); %!error y1 = stk_normalize (); %!test y2 = stk_normalize (x); %!test y3 = stk_normalize (x, box); %!error y4 = stk_normalize (x, box, log (2)); %!test assert (~ any ((y2 < -10 * eps) | (y2 > 1 + 10 * eps))); %!test assert (~ any ((y3 < -10 * eps) | (y3 > 1 + 10 * eps))); stk/inst/arrays/@stk_hrect/display.m0000664000175000017500000000224512617165716016503 0ustar bectbect% DISPLAY [overloaded base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function display (x) fprintf ( ... '\n%s = %d-dimensional hyper-rectangle (stk_hrect object):\n\n', ... inputname (1), size (x.stk_dataframe, 2)); disp (x); fprintf ('\n'); end % function display stk/inst/arrays/@stk_hrect/vertcat.m0000664000175000017500000000312312617165716016502 0ustar bectbect% VERTCAT [overload base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function result = vertcat (varargin) for i = 1:nargin, if isa (varargin{i}, 'stk_hrect') varargin{i} = varargin{i}.stk_dataframe; end end result = vertcat (varargin{:}); end % function vertcat %!shared d, x, y %! d = 10; %! x = stk_hrect (d); %! y = double (x); %!test %! z = vertcat (x, x); %! assert (isequal (size (z), [4 d])); %! assert (strcmp (class (z), 'stk_dataframe')); %!test %! z = vertcat (x, y); %! assert (isequal (size (z), [4 d])); %! assert (strcmp (class (z), 'stk_dataframe')); %!test %! z = vertcat (y, x); %! assert (isequal (size (z), [4 d])); %! assert (strcmp (class (z), 'stk_dataframe')); stk/inst/arrays/@stk_hrect/get.m0000664000175000017500000000301512617165716015611 0ustar bectbect% GET [overload base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function value = get (x, propname) switch propname case 'lower_bounds' value = x.stk_dataframe.data(1, :); case 'upper_bounds' value = x.stk_dataframe.data(2, :); case 'stk_dataframe' % Read-only access to the underlying df value = x.stk_dataframe; otherwise try value = get (x.stk_dataframe, propname); catch stk_error (sprintf ('There is no field named %s', propname), ... 'InvalidArgument'); end end end % function get %#ok<*CTCH> stk/inst/arrays/@stk_hrect/stk_rescale.m0000664000175000017500000000547212617165716017342 0ustar bectbect% STK_RESCALE rescales a dataset from one box to another % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [x, a, b] = stk_rescale (x, box1, box2) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % Read argument x x_data = double (x); d = size (x_data, 2); % Ensure that box1 is an stk_hrect object if ~ isa (box1, 'stk_hrect') if isempty (box1) box1 = stk_hrect (d); % Default: [0; 1] ^ DIM else box1 = stk_hrect (box1); end end % Extract lower/upper bounds for box1 box1_data = double (box1.stk_dataframe); if ~ isequal (size (box1_data), [2 d]) errmsg = sprintf ('box1 should have size [2 d], with d=%d.', d); stk_error (errmsg, 'IncorrectSize'); end % Ensure that box2 is an stk_hrect object if ~ isa (box2, 'stk_hrect') if isempty (box2) box2 = stk_hrect (d); % [0; 1] ^ d else box2 = stk_hrect (box2); end end % Extract lower/upper bounds for box2 box2_data = double (box2.stk_dataframe); if ~ isequal (size (box2_data), [2 d]) errmsg = sprintf ('box2 should have size [2 d], with d=%d.', d); stk_error (errmsg, 'IncorrectSize'); end % Scale to [0; 1] (xx --> zz) xmin = box1_data(1, :); xmax = box1_data(2, :); b1 = 1 ./ (xmax - xmin); a1 = - xmin .* b1; % scale to box2 (zz --> yy) ymin = box2_data(1, :); ymax = box2_data(2, :); b2 = ymax - ymin; a2 = ymin; b = b2 .* b1; a = a2 + a1 .* b2; x(:) = bsxfun (@plus, a, x_data * diag (b)); end % function stk_rescale %#ok<*CTCH> %!shared x %! x = rand (10, 4); %! y = stk_rescale (x, [], []); %! assert (stk_isequal_tolabs (x, y)); %!test %! y = stk_rescale(0.5, [], [0; 2]); %! assert (stk_isequal_tolabs (y, 1.0)); %!test %! y = stk_rescale (0.5, [0; 1], [0; 2]); %! assert (stk_isequal_tolabs (y, 1.0)); %!test %! y = stk_rescale (0.5, [0; 2], []); %! assert (stk_isequal_tolabs (y, 0.25)); %!test %! y = stk_rescale (0.5, [0; 2], [0; 1]); %! assert (stk_isequal_tolabs (y, 0.25)); stk/inst/arrays/@stk_hrect/subsasgn.m0000664000175000017500000000263412617165716016665 0ustar bectbect% SUBSASGN [overloaded base function] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function x = subsasgn (x, idx, value) if isa (x, 'stk_hrect') x.stk_dataframe = subsasgn (x.stk_dataframe, idx, value); data = x.stk_dataframe.data; if any (data(1, :) > data(2, :)) stk_error ('Lower bounds cannot be larger than upperbounds', ... 'IllegalAssigment'); end else % value must be an stk_hrect object x = subsasgn (x, idx, x.stk_dataframe); end end % function subsasgn stk/inst/arrays/@stk_hrect/stk_hrect.m0000664000175000017500000000600412617165716017021 0ustar bectbect% STK_HRECT creates an hyper-rectangle object % % CALL: B = stk_hrect (D) % CALL: B = stk_hrect (D, COLNAMES) % % creates an object representing a D-dimensional unit hypercube, [0; 1] ^ D. % % The second (optional) argument can be used to provide variable names. % % CALL: B = stk_hrect (X) % CALL: B = stk_hrect (X, COLNAMES) % % creates an object representing a D-dimensional hyperrectangle with lower % bounds X(1, :) and upper bounds X(2, :). The input X must be a 2xD % numerical array. % % NOTE: class hierarchy % % An stk_hrect object is two-row stk_dataframe object, with row names % 'lower_bounds' and 'upper_bounds'. % % See also: stk_dataframe, stk_boundingbox % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_hrect (arg1, colnames) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); elseif nargin == 0 % Default constructor df = stk_dataframe (); s = class (struct (), 'stk_hrect', df); return elseif isa (arg1, 'stk_hrect') % arg1 is already an stk_hrect object: copy s = arg1; else % create a new stk_hrect object % NOTE: the following test uses (prod (size (arg1)) == 1) instead of % isscalar because isscalar (x) means (numel (x) == 1) in Octave 3.8.2 % and therefore always returns true for stk_dataframe objects. if (prod (size (arg1)) == 1) % arg1 is the dimension of the input space % => create a default hyper-rectangle [0; 1]^d, with d = arg1 d = arg1; box_data = repmat ([0; 1], 1, d); else box_data = double (arg1); d = size (box_data, 2); if (~ isequal (size (box_data), [2 d])) stk_error ('Invalid size: should be 2 x dim.', 'IncorrectSize'); end end if (~ all (box_data(1, :) <= box_data(2, :))) stk_error ('Invalid bounds', 'InvalidBounds'); end df = stk_dataframe (box_data, {}, {'lower_bounds', 'upper_bounds'}); s = class (struct (), 'stk_hrect', df); end % column names if nargin > 1, s.stk_dataframe.colnames = colnames; end end % function stk_hrect stk/inst/arrays/@stk_hrect/horzcat.m0000664000175000017500000000447212617165716016514 0ustar bectbect% HORZCAT [overload base function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = horzcat (x, y, varargin) if nargin < 2, z = x; return end if isa (x, 'stk_hrect'), x = x.stk_dataframe; end if isa (y, 'stk_hrect'), y = y.stk_dataframe; end z = horzcat (x, y); try z = stk_hrect (z); catch err = lasterror (); if strcmp (err.identifier, 'STK:stk_hrect:InvalidBounds') warning ('STK:stk_hrect:horzcat:IllegalBounds', ... 'Illegal bounds, the result is not an stk_hrect object.'); else rethrow (err); end end if nargin > 2, z = horzcat (z, varargin{:}); end end % function horzcat %#ok<*LERR,*CTCH> %!shared d, x1, x2, x3 %! d = 10; %! x1 = stk_hrect (d); %! x2 = double (x1); %! x3 = [1:d; 0:(d-1)]; % illegal bounds %!test %! y1 = horzcat (x1, x1); %! assert (isequal (size (y1), [2 2*d])); %! assert (strcmp (class (y1), 'stk_hrect')); %!test %! y2 = horzcat (x1, x2); %! assert (isequal (size (y2), [2 2*d])); %! assert (strcmp (class (y2), 'stk_hrect')); %!test %! y3 = horzcat (x2, x1); %! assert (isequal (size (y3), [2 2*d])); %! assert (strcmp (class (y3), 'stk_hrect')); %!test %! lastwarn ('') %! y4 = horzcat (x1, x3); %! assert (isequal (size (y4), [2 2*d])); %! assert (strcmp (class (y4), 'stk_dataframe')); %! [warn_msg, warn_id] = lastwarn (); %! assert (strcmp (warn_id, 'STK:stk_hrect:horzcat:IllegalBounds')) stk/inst/arrays/@stk_hrect/disp.m0000664000175000017500000000202412617165716015770 0ustar bectbect% DISP [overloaded base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function disp (hr) disp (hr.stk_dataframe); end % function disp stk/inst/arrays/@stk_hrect/axis.m0000664000175000017500000000362012617165716016000 0ustar bectbect% AXIS [overloaded base function] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function varargout = axis (varargin) [h, varargin, nargin] = stk_get_axis_arg (varargin{:}); varargout = cell (1, nargout); labels = {}; for i = 1:nargin, a = varargin{i}; if isa (a, 'stk_hrect') df = a.stk_dataframe; % Check number of columns d = size (df, 2); if (d < 2) || (d > 4) stk_error ('axis support 2, 3 or 4 columns only.', 'IncorrectSize'); end % Convert to vector: [XMIN XMAX YMIN YMAX ...] varargin{i} = reshape (double (df), 1, 2 * d); % Get labels tmp = get (df, 'colnames'); if ~ isempty (tmp) labels = tmp(1:(min (3, d))); end end end [varargout{:}] = axis (h, varargin{:}); % Add labels if available if (~ isempty (labels)) stk_xlabel (h, labels{1}); stk_ylabel (h, labels{2}); if (length (labels) > 2) stk_zlabel (h, labels{3}); end end end % function axis stk/inst/arrays/@struct/0000775000175000017500000000000012617165716014213 5ustar bectbectstk/inst/arrays/@struct/stk_boundingbox.m0000664000175000017500000000322012617165716017565 0ustar bectbect% STK_BOUNDINGBOX [overload STK function] % % CALL: % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function box = stk_boundingbox (x) if nargin > 1, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if ~ isfield (x, 'a') % The "modern STK" answer is: stk_error (['stk_boundingbox (x) is not defined for structure ' ... 'arguments.'], 'TypeMismatch'); else % But for backward compatibility we still support: box = stk_boundingbox (x.a); end end % function @struct.stk_boundingbox %!shared x, y, cn %! cn = {'a', 'b', 'c'}; %! x = struct ('a', [0 3 2; 1 4 1; 7 0 2]); %!error y = stk_boundingbox (); %!test y = stk_boundingbox (x); %!error y = stk_boundingbox (x, 1); %!assert (isequal (y.data, [0 0 1; 7 4 2])); stk/inst/arrays/@struct/stk_length.m0000664000175000017500000000217012617165716016533 0ustar bectbect% STK_LENGTH [overload STK function] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function l = stk_length (x) l = size (x.a, 1); end % function stk_length %!test %! x = struct ('a', [5; 2]); %! assert (isequal (stk_length (x), 2)); stk/inst/arrays/@struct/double.m0000664000175000017500000000202212617165716015637 0ustar bectbect% DOUBLE [overload base function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function xdata = double (x) xdata = x.a; end % function double stk/inst/misc/0000775000175000017500000000000012617165721012215 5ustar bectbectstk/inst/misc/specfun/0000775000175000017500000000000012617165720013657 5ustar bectbectstk/inst/misc/specfun/stk_sf_gausscorr.m0000664000175000017500000000503412617165720017420 0ustar bectbect% STK_SF_GAUSSCORR computes the Gaussian correlation function % % CALL: K = stk_sf_gausscorr (H) % % computes the value of the Gaussian correlation function at distance H. % % CALL: K = stk_sf_gausscorr (H, DIFF) % % computes the derivative of the Gaussian correlation function with respect % to the distance H if DIFF is equal to 1. If DIFF is equal to -1, this is % the same as K = stk_sf_gausscorr (H). % % NOTES: % % * This correlation function is also known as the "squared exponential" corre- % lation function, or the "Gaussian RBF" (Radial Basis Function). % % * The Gaussian correlation function is a valid correlation function for all % dimensions. % % * The Gaussian correlation function is the limit of the Matern correlation % function when the regularity parameters tends to infinity. % % See also: stk_sf_matern, stk_sf_matern52 % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_sf_gausscorr (h, diff) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % default: compute the value (not a derivative) if nargin < 2, diff = -1; end if diff <= 0, % value of the covariance function k = exp (- h .^ 2); elseif diff == 1, % derivative wrt h k = - 2 * h .* exp (- h .^ 2); else error ('incorrect value for diff.'); end end % function stk_sf_gausscorr %!shared h, diff %! h = 1.0; diff = -1; %!error stk_sf_gausscorr (); %!test stk_sf_gausscorr (h); %!test stk_sf_gausscorr (h, diff); %!error stk_sf_gausscorr (h, diff, pi); %!test % h = 0.0 => correlation = 1.0 %! x = stk_sf_gausscorr (0.0); %! assert (stk_isequal_tolrel (x, 1.0, 1e-8)); stk/inst/misc/specfun/stk_sf_matern32.m0000664000175000017500000000544312617165720017047 0ustar bectbect% STK_SF_MATERN32 computes the Matern correlation function of order 3/2. % % CALL: K = stk_sf_matern32 (H) % % computes the value of the Matern correlation function of order 3/2 at % distance H. Note that the Matern correlation function is a valid % correlation function for all dimensions. % % CALL: K = stk_sf_matern32 (H, DIFF) % % computes the derivative of the Matern correlation function of order 3/2, at % distance H, with respect the distance H if DIFF is equal to 1. (If DIFF is % equal to -1, this is the same as K = stk_sf_matern32(H).) % % See also: stk_sf_matern, stk_sf_matern52 % Copyright Notice % % Copyright (C) 2011, 2012 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_sf_matern32 (h, diff) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % default: compute the value (not a derivative) if nargin < 2, diff = -1; end Nu = 3/2; C = 2 * sqrt (Nu); % dt/dh t = C * abs (h); if diff <= 0, % value of the covariance function k = (1 + t) .* exp (-t); elseif diff == 1, % derivative wrt h k = - C * t .* exp (-t); else error ('incorrect value for diff.'); end end % function stk_sf_matern32 %!shared h, diff %! h = 1.0; diff = -1; %!error stk_sf_matern32 (); %!test stk_sf_matern32 (h); %!test stk_sf_matern32 (h, diff); %!error stk_sf_matern32 (h, diff, pi); %!test %% h = 0.0 => correlation = 1.0 %! x = stk_sf_matern32 (0.0); %! assert (stk_isequal_tolrel (x, 1.0, 1e-8)); %!test %% consistency with stk_sf_matern: function values %! for h = 0.1:0.1:2.0, %! x = stk_sf_matern (3/2, h); %! y = stk_sf_matern32 (h); %! assert (stk_isequal_tolrel (x, y, 1e-8)); %! end %!test %% consistency with stk_sf_matern: derivatives %! for h = 0.1:0.1:2.0, %! x = stk_sf_matern (3/2, h, 2); %! y = stk_sf_matern32 (h, 1); %! assert (stk_isequal_tolrel (x, y, 1e-8)); %! end stk/inst/misc/specfun/stk_sf_matern52.m0000664000175000017500000000546712617165720017057 0ustar bectbect% STK_SF_MATERN52 computes the Matern correlation function of order 5/2. % % CALL: K = stk_sf_matern52 (H) % % computes the value of the Matern correlation function of order 5/2 at % distance H. Note that the Matern correlation function is a valid % correlation function for all dimensions. % % CALL: K = stk_sf_matern52 (H, DIFF) % % computes the derivative of the Matern correlation function of order 5/2, at % distance H, with respect the distance H if DIFF is equal to 1. (If DIFF is % equal to -1, this is the same as K = stk_sf_matern52(H).) % % See also: stk_sf_matern, stk_sf_matern32 % Copyright Notice % % Copyright (C) 2011, 2012 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_sf_matern52 (h, diff) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % default: compute the value (not a derivative) if nargin < 2, diff = -1; end Nu = 5/2; C = 2 * sqrt (Nu); % dt/dh t = C * abs (h); if diff <= 0, % value of the covariance function k = (1 + t + t.^2/3) .* exp (-t); elseif diff == 1, % derivative wrt h k = C * -t/3 .* (1 + t) .* exp (-t); else error ('incorrect value for diff.'); end end % function stk_sf_matern52 %!shared h, diff %! h = 1.0; diff = -1; %!error stk_sf_matern52 (); %!test stk_sf_matern52 (h); %!test stk_sf_matern52 (h, diff); %!error stk_sf_matern52 (h, diff, pi); %!test %% h = 0.0 => correlation = 1.0 %! x = stk_sf_matern52 (0.0); %! assert (stk_isequal_tolrel (x, 1.0, 1e-8)); %!test %% consistency with stk_sf_matern: function values %! for h = 0.1:0.1:2.0, %! x = stk_sf_matern (5/2, h); %! y = stk_sf_matern52 (h); %! assert (stk_isequal_tolrel (x, y, 1e-8)); %! end %!test %% consistency with stk_sf_matern: derivatives %! for h = 0.1:0.1:2.0, %! x = stk_sf_matern (5/2, h, 2); %! y = stk_sf_matern52 (h, 1); %! assert (stk_isequal_tolrel (x, y, 1e-8)); %! end stk/inst/misc/specfun/stk_sf_matern.m0000664000175000017500000001122012617165720016670 0ustar bectbect% STK_SF_MATERN computes the Matern correlation function. % % CALL: K = stk_sf_matern (NU, H) % % computes the value of the Matern correlation function of order NU at % distance H. Note that the Matern correlation function is a valid % correlation function for all dimensions. % % CALL: K = stk_sf_matern (NU, H, DIFF) % % computes the derivative of the Matern correlation function of order NU, at % distance H, with respect to the order NU if DIFF is equal to 1, or with % respect the distance H if DIFF is equal to 2. (If DIFF is equal to -1, % this is the same as K = stk_sf_matern(NU, H).) % % See also: stk_sf_matern32, stk_sf_matern52 % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_sf_matern (nu, h, diff) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % default: compute the value (not a derivative) if nargin < 3, diff = -1; end if ~ ((isscalar (nu)) && (nu > 0)) stk_error ('nu should be a positive scalar.', 'IncorrectSize'); end % Handle the case of VERY large nu if nu > 1e305, % nu = 1e306 is so large thatn even gammaln (nu) is not defined ! if diff <= 0, k = stk_sf_gausscorr (h); return; else % Cannot compute or approximate the derivative for such a large nu k = nan (size (h)); return; end end % Tolerance for the detection of half-integer values of nu TOL = 10 * eps; % We have no analytical expression for the derivative with respect to nu, % even if nu is 3/2, 5/2 or +Inf if diff ~= 1, if abs (nu - 1.5) < TOL, k = stk_sf_matern32 (h, diff - 1); return; elseif abs (nu - 2.5) < TOL, k = stk_sf_matern52 (h, diff - 1); return; end end [N, M] = size (h); hp = abs (reshape (h, N * M, 1)); t = 2 * sqrt (nu) * hp; z = 0.5 * exp (gammaln (nu) - nu * log (0.5 * t)); I = ~ isinf (z); if diff <= 0 k = zeros (N * M, 1); % When z < +Inf, compute using the modified Bessel function of the second kind k(I) = 1 ./ z(I) .* besselk_ (nu, t(I)); % When z == +Inf, it means nu is large and/or t is close to zero. % We approximate the result with the upper bound provided by the Gaussian case. k(~I) = stk_sf_gausscorr (h(~I)); elseif diff == 1 % numerical derivative wrt Nu itermax = 2; delta = 1e-4; dk = zeros (N * M, itermax); for l= 1:itermax Nu_p = nu + 2 ^ (l - 1) * delta; Nu_m = nu - 2 ^ (l - 1) * delta; t_p = 2 * sqrt (Nu_p) * hp; t_m = 2 * sqrt (Nu_m) * hp; k_p = 1 / (2 ^ (Nu_p - 1) * gamma (Nu_p)) .* t_p(I) .^ Nu_p .* ... besselk_ (Nu_p, t_p(I)); k_m = 1 / (2 ^ (Nu_m - 1) * gamma (Nu_m)) .* t_m(I) .^ Nu_m .* ... besselk_ (Nu_m, t_m(I)); dk(I, l) = k_p - k_m; end k = 1 / (12 * delta)* (- dk(:, 2) + 8 * dk(:, 1)); elseif diff == 2 % deriv. wrt h k = zeros (N * M, 1); dtdh = 2 * sqrt (nu); k(I) = - dtdh ./ z(I) .* besselk_ (nu - 1, t(I)); end k = reshape (k, N, M); end % function stk_sf_matern function y = besselk_ (nu, x) opts = stk_options_get('stk_sf_matern'); if size(x, 1) < opts.min_size_for_parallelization, y = besselk(nu, x); else y = stk_parallel_feval(@(t)(besselk(nu, t)), x, true, opts.min_block_size); end end % function besselk_ %!shared nu, h, diff %! nu = 1.0; h = 1.0; diff = -1; %!error stk_sf_matern (); %!error stk_sf_matern (nu); %!test stk_sf_matern (nu, h); %!test stk_sf_matern (nu, h, diff); %!error stk_sf_matern (nu, h, diff, pi); %!test %% h = 0.0 => correlation = 1.0 %! for nu = 0.1:0.2:5.0, %! x = stk_sf_matern (nu, 0.0); %! assert (stk_isequal_tolrel (x, 1.0, 1e-8)); %! end stk/inst/misc/plot/0000775000175000017500000000000012617165720013172 5ustar bectbectstk/inst/misc/plot/stk_get_axis_arg.m0000664000175000017500000000250112617165720016663 0ustar bectbect% STK_GET_AXIS_ARG [STK internal] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [h, argin, n_argin] = stk_get_axis_arg (varargin) if isempty (varargin) h = []; argin = {}; else h = varargin{1}; if (all (ishghandle (h))) && (all (strcmp (get (h, 'type'), 'axes'))) argin = varargin(2:end); else h = gca; argin = varargin; end end n_argin = length (argin); end % function stk_get_axis_arg stk/inst/misc/plot/stk_title.m0000664000175000017500000000275212617165720015360 0ustar bectbect% STK_TITLE is a replacement for 'title' for use in STK's examples % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function h = stk_title (varargin) if ischar (varargin{1}) args = varargin(1); % title user_options = varargin(2:end); else args = varargin(1:2); % axes handle + title user_options = varargin(3:end); end % Get global STK options stk_options = stk_options_get ('stk_title', 'properties'); % Display title with STK options h = title (args{:}, stk_options{:}); % Apply user-provided options if ~ isempty (user_options) set (h, user_options{:}); end end % function stk_title stk/inst/misc/plot/stk_figure.m0000664000175000017500000000303412617165720015512 0ustar bectbect% STK_FIGURE is a replacement for 'figure' for use in STK's examples % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function h = stk_figure (varargin) if mod (length (varargin), 2) ~= 0 figname = varargin{1}; user_options = varargin(2:end); else figname = ''; user_options = varargin; end % Get global STK options options = stk_options_get ('stk_figure', 'properties'); % Create figure h = figure (options{:}); % Create axes stk_axes; % Apply user-provided options if ~ isempty (user_options) set (h, user_options{:}); end % Set figure name and title if ~ isempty (figname) set (h, 'Name', figname); end end % function stk_figure stk/inst/misc/plot/stk_zlabel.m0000664000175000017500000000275512617165720015513 0ustar bectbect% STK_ZLABEL is a replacement for 'zlabel' for use in STK's examples % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function h = stk_zlabel (varargin) [h, varargin] = stk_get_axis_arg (varargin{:}); zlab = varargin{1}; % Get global STK options stk_options = stk_options_get ('stk_zlabel', 'properties'); user_options = varargin(2:end); % Apply to all axes for i = 1:(length (h)) % Set y-label and apply STK options zlabel (h(i), zlab, stk_options{:}); % Apply user-provided options if ~ isempty (user_options) set (h(i), user_options{:}); end end end % function stk_zlabel stk/inst/misc/plot/stk_plot_shadedci.m0000664000175000017500000000276312617165720017043 0ustar bectbect% STK_PLOT_SHADEDCI represents pointwise confidence itervals using a shaded area % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_plot_shadedci (x, z) x = double (x); delta = 1.96 * sqrt (abs (z.var)); h = area (x, [z.mean - delta, 2 * delta]); set (h(1), 'FaceColor', 'none'); set (h(2), 'FaceColor', [0.8 0.8 0.8]); set (h, 'LineStyle', '-', 'LineWidth', 1, 'EdgeColor', 'none'); % Raise current axis to the top layer, to prevent it % from being hidden by the grayed area set (gca, 'Layer', 'top'); end % function stk_plot_shadedci stk/inst/misc/plot/stk_plot1d.m0000664000175000017500000000462312617165720015441 0ustar bectbect% STK_PLOT1D is a convenient plot function for 1D kriging predictions % % CALL: stk_plot1d (XI, ZI, XT, ZT, ZP) % % plots the evaluation points (XI, ZI), the "true function" with values % ZT on the grid XT, and a representation of the prediction ZP on the % same grid XT: the kriging prediction (posterior mean) surrounded by a % shaded area corresponding to 95% pointwise confidence intervals. % % It is possible to omit plotting either the observations (XI, ZI) or % the true function ZT by providing empty matrices. % % CALL: stk_plot1d (XI, ZI, XT, ZT, ZP, ZSIM) % % also plots a set ZSIM of samplepaths. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_plot1d (xi, zi, xt, zt, zp, zsim) % Shaded area representing pointwise confidence intervals if (nargin > 4) && (~ isempty (zp)) stk_plot_shadedci (xt, zp); hold on; end % Plot sample paths if (nargin > 5) && (~ isempty (zsim)) plot (xt, zsim, '-', 'LineWidth', 1, 'Color', [0.39, 0.47, 0.64]); hold on; end % Ground truth if (nargin > 3) && (~ isempty (zt)) plot (xt, zt, '--', 'LineWidth', 3, 'Color', [0.39, 0.47, 0.64]); hold on; end % Kriging predictor (posterior mean) if (nargin > 4) && (~ isempty (zp)) plot (xt, zp.mean, 'LineWidth', 3, 'Color', [0.95 0.25 0.3]); hold on; end % Evaluations if ~ isempty (zi) plot (xi, zi, 'ko', 'MarkerSize', 6, 'MarkerFaceColor', 'k'); end hold off; set (gca, 'box', 'off'); legend off; end % function stk_plot1d stk/inst/misc/plot/stk_xlabel.m0000664000175000017500000000276312617165720015510 0ustar bectbect% STK_XLABEL is a replacement for 'xlabel' for use in STK's examples % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function h = stk_xlabel (varargin) [h, varargin] = stk_get_axis_arg (varargin{:}); xlab = varargin{1}; % Get global STK options stk_options = stk_options_get ('stk_xlabel', 'properties'); user_options = varargin(2:end); % Apply to all axes for i = 1:(length (h)) % Set x-label and apply STK options xlabel (h(i), xlab, stk_options{:}); % Apply user-provided options if ~ isempty (user_options) set (h(i), user_options{:}); end end end % function stk_xlabel stk/inst/misc/plot/stk_axes.m0000664000175000017500000000237612617165720015201 0ustar bectbect% STK_AXES is a replacement for 'axes' for use in STK's examples % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function h = stk_axes (varargin) % Get global STK options options = stk_options_get ('stk_axes', 'properties'); % Create figure h = axes (options{:}); % Apply user-provided options if ~ isempty (varargin) set (h, varargin{:}); end end % function stk_axes stk/inst/misc/plot/stk_labels.m0000664000175000017500000000216412617165720015476 0ustar bectbect% STK_LABELS is a shortcut for stk_xlabel + stk_ylabel % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_labels (xlab, ylab, varargin) stk_xlabel (xlab, varargin{:}); stk_ylabel (ylab, varargin{:}); end % function stk_labels stk/inst/misc/plot/stk_plot2d.m0000664000175000017500000000276012617165720015442 0ustar bectbect% STK_PLOT2D [deprecated] % % See also: stk_factorialdesign/contour, stk_factorialdesign/mesh, ... % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_plot2d (plotfun, x, z, varargin) if ~ isa (x, 'stk_factorialdesign') errmsg = 'x should be an stk_factorialdesign object.'; stk_error (errmsg, 'IncorrectArgument'); end warning ('STK:stk_plot2d:Deprecated', ... 'stkplot2d is deprecated, please use @stk_factorialdesign/plot instead'); if ~ ischar (plotfun) % assume it's a function handle, then plotfun = func2str (plotfun); end feval (plotfun, x, z, varargin{:}); end % function stk_plot2d stk/inst/misc/plot/stk_subplot.m0000664000175000017500000000255212617165720015725 0ustar bectbect% STK_SUBPLOT is a replacement for 'subplot' for use in STK's examples % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function h = stk_subplot (m, n, p, varargin) % Get global STK options stk_options = stk_options_get ('stk_axes', 'properties'); % Create axes h = subplot (m, n, p); % Apply STK options first if ~ isempty (stk_options) set (h, stk_options{:}); end % Apply user-provided options if ~ isempty (varargin) set (h, varargin{:}); end end % function stk_subplot stk/inst/misc/plot/stk_ylabel.m0000664000175000017500000000276312617165720015511 0ustar bectbect% STK_YLABEL is a replacement for 'ylabel' for use in STK's examples % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function h = stk_ylabel (varargin) [h, varargin] = stk_get_axis_arg (varargin{:}); ylab = varargin{1}; % Get global STK options stk_options = stk_options_get ('stk_ylabel', 'properties'); user_options = varargin(2:end); % Apply to all axes for i = 1:(length (h)) % Set y-label and apply STK options ylabel (h(i), ylab, stk_options{:}); % Apply user-provided options if ~ isempty (user_options) set (h(i), user_options{:}); end end end % function stk_ylabel stk/inst/misc/benchmarks/0000775000175000017500000000000012617165717014337 5ustar bectbectstk/inst/misc/benchmarks/stk_benchmark_bivnorm.m0000664000175000017500000000414412617165717021067 0ustar bectbect% STK_BENCHMARK_BIVNORM % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . mu = [1 2]; % means sigma = [3 4]; % standard deviations rho = 0.37; % correlation coefficients n = 10000; z = 10 * (rand (n, 2) - 0.5); % Covariance matrix (for use with mvncdf) K11 = sigma(1) ^ 2; K12 = sigma(1) * sigma(2) * rho; K22 = sigma(2) ^2; % Compute with mvncdf tic; p_mvncdf = mvncdf (z, mu, [K11 K12; K12 K22]); t_mvncdf = toc; % Compute with stk_distrib_bivnorm_cdf tic; p_stk = stk_distrib_bivnorm_cdf (z, mu(1), mu(2), sigma(1), sigma(2), rho); t_stk = toc; err = abs (p_stk - p_mvncdf); fprintf ('t_stk = %.1f µs/eval\n', t_stk / n * 1e6); fprintf ('t_mvncdf = %.1f µs/eval\n', t_mvncdf / n * 1e6); fprintf ('t_mvncdf / t_stk = %.1f\n', t_mvncdf / t_stk); fprintf ('maximal absolute difference: %.2g\n', max (err)) fprintf ('maximal relative difference: %.2g\n', max (err ./ p1)) %%% Example of a "large" difference (approx. 1e-8 relative error) % % z1 = -3.798119125813876 % z2 = -4.397490942716200 % % p1 = stk_distrib_bivnorm_cdf ([z1 z2], 1, 2, 3, 4, 0.37) % % -> 1.0015256831575151e-02 % % p2 = mvncdf ([z1 z2], [1 2], [9 4.44; 4.44 16]); % % -> 1.0015256938405132e-02 (Matlab R2012a) % %%%%%%%% Which one is more accurate ??? stk/inst/misc/benchmarks/stk_benchmark_cov1.m0000664000175000017500000000240512617165717020261 0ustar bectbect% STK_BENCHMARK_COV1 % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . %% Benchmark parameters DIM = 1; N = 500; REP = 5; covname = 'stk_materncov_iso'; %% Evaluate computation time model = stk_model(covname, DIM); tic; for i = 1:REP, x = stk_sampling_regulargrid(N, DIM); K = stk_make_matcov(model, x, x); end t = toc / REP; fprintf('% 20s: %.3f seconds\n', covname, t); stk/inst/misc/benchmarks/stk_benchmark_paramestim.m0000664000175000017500000000476512617165717021566 0ustar bectbect% STK_BENCHMARK_PARAMESTIM A simple 1D parameter estimation benchmark % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_benchmark_paramestim () NREP = 10; t = zeros (1, NREP); for noise_std = [0 0.1], for ni = [10 50], for i = 1:NREP, tic; test_function (ni, noise_std); t(i) = toc; end fprintf ('noise_std = %.1f ', noise_std); fprintf ('ni = %d ', ni); t_est = median (t); t_mad = mean (abs (t - t_est)); fprintf ('t = %.3f [%.3f]\n', t_est, t_mad); end end end function test_function (ni, noise_std) f = @(x)(- (0.8 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); DIM = 1; % Dimension of the factor space BOX = [-1.0; 1.0]; % Factor space NOISY = (noise_std > 0); NITER = 5; % number of random designs generated in stk_sampling_maximinlhs() xi = stk_sampling_maximinlhs (ni, DIM, BOX, NITER); % evaluation points zi = stk_feval (f, xi); % evaluation results if NOISY, zi = zi + noise_std * randn (ni, 1); end model = stk_model ('stk_materncov_iso'); if ~ NOISY, % Noiseless case: set a small "regularization" noise % the (log)variance of which is provided by stk_param_init model.lognoisevariance = 1e-10; else % Otherwise, set the variance of the noise % (assumed to be known, not estimated, in this example) model.lognoisevariance = 2 * log (noise_std); end % Estimate the parameters model.param = stk_param_estim (model, xi, zi, log ([1.0; 4.0; 1/0.4])); end stk/inst/misc/benchmarks/stk_benchmark_logdet.m0000664000175000017500000000326312617165717020672 0ustar bectbect% STK_BENCHMARK_LOGDET1 % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . % NREP = 1000; n = 20; % test on small matrices NREP = 100; n = 200; % test on large matrices d = 2; x = stk_sampling_maximinlhs (n, d, [], 10); model = stk_model ('stk_materncov52_aniso', d); propname = { ... 'log_det_covariance_matrix_a', ... 'log_det_covariance_matrix_b', ... 'log_det_covariance_matrix_c', ... 'log_det_covariance_matrix_d', ... 'log_det_covariance_matrix_e' }; L = length (propname); t = zeros (L, 1); v = zeros (L, 1); for k = 1:L fprintf('Method %d/%d...', k, L); tic; for i = 1:NREP, kreq = stk_kreq_qr (model, x); logdet = get (kreq, propname{k}); end t(k) = toc / NREP; v(k) = logdet; fprintf('\n'); end display (t) display (v) stk/inst/misc/benchmarks/stk_benchmark_cov2.m0000664000175000017500000000676712617165717020301 0ustar bectbect% STK_BENCHMARK_COV2 % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . %% Benchmark parameters DIM = 1; N_START = 50; N_MAX = 2000; covnames = { ... 'stk_materncov32_iso', ... 'stk_materncov52_iso', ... 'stk_materncov_iso' }; result = struct('covname', [], 't', [], 'n', []); stk_figure ('stk_benchmark_cov2'); %% Main loop for j = 1:4, switch j case 1 disp('Using stk_parallel_engine_none...'); stk_parallel_stop(); case 2 disp('parallelization on (if available) / msfb = Inf'); stk_parallel_start(); M = stk_options_get('stk_sf_matern', 'min_size_for_parallelization'); stk_options_set('stk_sf_matern', 'min_size_for_parallelization', +Inf); case 3 disp('parallelization on (if available) / msfb = 1'); stk_options_set('stk_sf_matern', 'min_size_for_parallelization', 1); case 4 fprintf('parallelization on (if available) / msfb = %d (default)', M); stk_options_set('stk_sf_matern', 'min_size_for_parallelization', M); end for k = 1:length(covnames), % loop over covariance functions result(j, k).covname = covnames{k}; model = stk_model(covnames{k}, DIM); REP = 5000; n = N_START; while n <= N_MAX tic; x = stk_sampling_regulargrid(n, DIM); for i = 1:REP, K = stk_make_matcov(model, x, x); end t = toc / REP; result(j, k).n(end+1) = n; result(j, k).t(end+1) = t; cla; loglog(result(j, k).n, result(j, k).t, 'o-'); drawnow; n = ceil(n * 1.4); REP = ceil(1/t); end end end %% Figure legtxt = {}; %#ok<*AGROW> loglog(vertcat(result(1, :).n)', vertcat(result(1, :).t)', 'x:'); hold on; for k = 1:length(covnames) legtxt = [legtxt {sprintf('%s (par. off)', covnames{k})}]; end loglog(vertcat(result(2, :).n)', vertcat(result(2, :).t)', 'o-'); for k = 1:length(covnames) legtxt = [legtxt {sprintf('%s (par. on, msfp=+Inf)', covnames{k})}]; end loglog(vertcat(result(3, :).n)', vertcat(result(3, :).t)', 's--'); for k = 1:length(covnames) legtxt = [legtxt {sprintf('%s (par. on, msfp=1)', covnames{k})}]; end loglog(vertcat(result(4, :).n)', vertcat(result(4, :).t)', 'd-.'); for k = 1:length(covnames) legtxt = [legtxt {sprintf('%s (par. on, msfp=%d)', covnames{k}, M)}]; end h = legend(legtxt, 'Location', 'NorthWest'); set(h, 'Interpreter', 'none'); stk_labels ('n', 'computation time'); stk/inst/misc/dist/0000775000175000017500000000000012617165720013157 5ustar bectbectstk/inst/misc/dist/stk_filldist.m0000664000175000017500000001353712617165720016041 0ustar bectbect% STK_FILLDIST computes the fill distance of a set of points % % CALL: FD = stk_filldist(X, BOX) % % computes the fill distance FD of the dataset X in the hyper-rectangle % BOX, using the computational-geometric algorithm of L. Pronzato and % W. G. Muller [1]. Recall that % % D = max_{Y in BOX} min_{1 <= i <= n} norm(X(i,:) - Y), (1) % % where norm(.) denotes the Euclidean norm in R^d. Optimal designs with % respect to the fill distance are sometimes called "minimax" designs % (see, e.g., [2]). % % CALL: FD = stk_filldist(X) % % assumes that the fill distance is to be computed with respect to the % hyperrectangle BOX = [0; 1]^d. % % CALL: FD = stk_filldist(X, Y) % % computes the fill distance FD of X using the "test set" Y. More preci- % sely, if X and Y are respectively n x d and m x d, then % % FD = max_{1 <= j <= m} min_{1 <= i <= n} norm(X(i,:) - Y(j,:)), % % If Y is dense enough in some subset BOX of R^d, then FD should be close % to the actual fill distance of X in BOX. % % CALL: [FD, YMAX] = stk_filldist(...) % % also returns the point YMAX where the maximal distance is attained. % % NOTE: % % stk_filldist is actually a wrapper around stk_filldist_discretized and % stk_filldist_exact. Which function to call is guessed based on the number % of rows of the second argument. Because of that, the test set Y is required % to have at least 3 rows. % % REFERENCES % % [1] Luc Pronzato and Werner G. Muller, "Design of computer % experiments: space filling and beyond", Statistics and Computing, % 22(3):681-701, 2012. % % [2] Mark E. Johnson, Leslie M. Moore and Donald Ylvisaker, "Minimax % and maximin distance designs", Journal of Statistical Planning % and Inference, 26(2):131-148, 1990. % % See also: stk_dist, stk_mindist, stk_filldist_exact, stk_filldist_discretized % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [fd, ymax] = stk_filldist(x, arg2) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end x = double(x); if nargin == 1, % defaults: "exact" over [0; 1]^d default_box = repmat([0; 1], 1, size(x, 2)); fd = stk_filldist_exact(x, default_box); else arg2 = double(arg2); ny = size(arg2, 1); if ny == 2, % arg2 is interpreted as a box [fd, ymax] = stk_filldist_exact(x, arg2); elseif ny > 2, % arg2 is interpreted a discrete test set [fd, idx_max] = __stk_filldist_discr_mex__(x, arg2); ymax = arg2(idx_max, :); else errmsg = 'Incorrect size for argument #2: nb rows > 1 expected.'; stk_error(errmsg, 'InvalidArgument'); end end % if end % function stk_filldist %% % Check that both double-precision matrices and stk_dataframe objects are accepted %!test %%% exact %! d = 3; x = rand(7, d); box = repmat([0; 1], 1, d); %! fd1 = stk_filldist(x, box); %! fd2 = stk_filldist(stk_dataframe(x), stk_dataframe(box)); %! assert(stk_isequal_tolabs(fd1, fd2)); %!test %%% discretized %! d = 3; x = rand(7, d); y = rand(20, d); %! fd1 = stk_filldist(x, y); %! fd2 = stk_filldist(stk_dataframe(x), stk_dataframe(y)); %! assert(stk_isequal_tolabs(fd1, fd2)); %% % fd = 0 if X = Y (discretized filldist) %!test %! n = 5; % must be bigger than 2 %! for dim = 1:10, %! x = rand(n, dim); %! fd = stk_filldist(x, x); %! assert(stk_isequal_tolabs(fd, 0.0)); %! end %% % One point in the middle of [0; 1]^d (exact & discretized filldist) %!test %%% exact %! for dim = 1:6, %! x = 0.5 * ones(1, dim); %! fd = stk_filldist(x); % [0; 1]^d is the default box %! assert(stk_isequal_tolabs(fd, 0.5 * sqrt(dim))); %! end %!test %%% discretized %! for dim = 1:6, %! x = 0.5 * ones(1, dim); %! y = stk_sampling_regulargrid(2^dim, dim); % [0; 1]^d is the default box %! fd = stk_filldist(x, y); %! assert(stk_isequal_tolabs(fd, 0.5 * sqrt(dim))); %! end %% % One point in the middle of [1; 2]^d (exact filldist) %!test %! for dim = [1 3 7], %! box = repmat([1; 2], 1, dim); %! x = 1 + 0.5 * ones(1, dim); %! fd = stk_filldist(x, box); %! assert(stk_isequal_tolabs(fd, 0.5 * sqrt(dim))); %! end %% % 20 points in [-1; 1]^3 %!test %! dim = 3; %! box = repmat([-1; 1], 1, dim); %! x = stk_sampling_randunif(20, dim, box); %! y = stk_sampling_regulargrid(3^dim, dim, box); %! fd1 = stk_filldist(x, box); %! fd2 = stk_filldist(x, y); %! assert(fd1 >= fd2 - 10 * eps); %% % One point at the origin, BOX = [0; 1]^d %!test %%% exact %! for dim = [1 3 7], %! x = zeros(1, dim); %! [fd, ymax] = stk_filldist_exact(x); %! assert(stk_isequal_tolabs(fd, sqrt(dim))); %! assert(stk_isequal_tolabs(ymax, ones(1, dim))); %! end %!test %%% discretized %! for dim = [1 3 7], %! x = zeros(1, dim); %! y = stk_sampling_regulargrid(3^dim, dim); %! [fd, ymax] = stk_filldist(x, y); %! assert(stk_isequal_tolabs(fd, sqrt(dim))); %! assert(stk_isequal_tolabs(ymax, ones(1, dim))); %! end stk/inst/misc/dist/stk_gpquadform.m0000664000175000017500000001173212617165720016367 0ustar bectbect% STK_GPQUADFORM [experimental, not part of public API yet... UAYOR!] % % CALL: Q = stk_gpquadform (X, Y, RX, RY) % % computes a matrix Q, whose entries Q(i,j) are given by a Gibbs- % Paciorek quadratic form % % Q(i,j) = \sum_{k = 1}^d (X(i,k) - Y(j,k))^2 / R(i,j,k)^2, % % where % % R(i,j,k)^2 = RX(i,k)^2 + RY(i,k)^2, % % assuming that % % * X and RX have size [nX d], % * Y and RY have size [nY d]. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function Q = stk_gpquadform (x, y, rx, ry, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % read argument #1 if isstruct (x), x = x.a; end % read argument #2 if isstruct (y), y = y.a; end % read argument #4 if nargin < 4, if isempty (y) ry = rx; else errmsg = 'Not enough input arguments.'; stk_error (errmsg, 'NotEnoughInputArgs'); end else if (isempty (y)) && (~ isempty (ry)) && (~ isequal (rx, ry)) errmsg = 'ry should be empty or equal to rx'; stk_error (errmsg, 'IncorrectArgument'); end end % read argument #5 if nargin < 5, pairwise = false; else if ~ islogical (pairwise) errmsg = 'Argument ''pairwise'' should be either true or false.'; stk_error (errmsg, 'TypeMismatch'); end end if pairwise, if isempty (y), Q = zeros (size (x, 1), 1); else Q = __stk_gpquadform_pairwise__ (x, y, rx, ry); end else if isempty (y), Q = __stk_gpquadform_matrixx__ (x, rx); else Q = __stk_gpquadform_matrixy__ (x, y, rx, ry); end end end % function stk_gpquadform %%%%%%%%% % TESTS % %%%%%%%%% %!shared x, y, z, rx, ry, rz %! x = rand(5, 2); rx = rand(5, 2) + 1; %! y = rand(6, 2); ry = rand(6, 2) + 1; %! z = rand(5, 3); rz = rand(5, 3) + 1; %% % Check that an error is raised when sizes are incompatible %!error Q = stk_gpquadform(x, ry, y, ry) %!error Q = stk_gpquadform(x, rz, y, ry) %!error Q = stk_gpquadform(x, rx, y, rx) %!error Q = stk_gpquadform(x, rx, y, rz) %!error Q = stk_gpquadform(x, rx, z, ry) %% % Check that ".a" structures are accepted %!test %! Dxy1 = stk_gpquadform(x, y, rx, ry); %! Dxy2 = stk_gpquadform(struct('a', x), struct('a', y), rx, ry); %! assert(stk_isequal_tolabs(Dxy1, Dxy2)); %% % Tests with r = 1/sqrt(2) %!shared x, y, z, rx, ry, rz %! x = zeros (11, 5); rx = 1/sqrt(2) * ones (11, 5); %! y = zeros (13, 5); ry = 1/sqrt(2) * ones (13, 5); %! z = ones ( 7, 5); rz = 1/sqrt(2) * ones ( 7, 5); %!test %! Qx = stk_gpquadform(x, [], rx); %! assert(isequal(Qx, zeros(11))); %!test %! Qxx = stk_gpquadform(x, x, rx, rx); %! assert(isequal(Qxx, zeros(11))); %!test %! Qxy = stk_gpquadform(x, y, rx, ry); %! assert(isequal(Qxy, zeros(11, 13))); %!test %! Qzz = stk_gpquadform(z, [], rz); %! assert(isequal(Qzz, zeros(7))); %!test %! Qxz = stk_gpquadform(x, z, rx, rz); %! assert(stk_isequal_tolabs(Qxz, 5 * ones(11, 7))); %% % Tests with a random r %!test %! x = randn(5, 3); rx = 1 + rand(5, 3); %! y = randn(5, 3); ry = 1 + rand(5, 3); %! Q1 = stk_gpquadform(x, y, rx, ry, true); % pairwise %! Q2 = stk_gpquadform(x, y, rx, ry, false); %! assert(isequal(size(Q1), [5 1])); %! assert(isequal(size(Q2), [5 5])); %! assert(stk_isequal_tolabs(Q1, diag(Q2))); %!test %! x = randn(5, 3); rx = 1 + rand(5, 3); %! Q1 = stk_gpquadform(x, [], rx, [], true); % pairwise %! assert(stk_isequal_tolabs(Q1, zeros(5, 1))); %! Q1 = stk_gpquadform(x, x, rx, rx, true); % pairwise %! assert(stk_isequal_tolabs(Q1, zeros(5, 1))); %% % Tests with r = 2 %!shared x, y, z, rx, ry, rz %! x = zeros (11, 5); rx = 2 * ones (11, 5); %! y = zeros (13, 5); ry = 2 * ones (13, 5); %! z = ones ( 7, 5); rz = 2 * ones ( 7, 5); %!test %! Qx = stk_gpquadform(x, [], rx); %! assert(isequal(Qx, zeros(11))); %!test %! Qxx = stk_gpquadform(x, x, rx, rx); %! assert(isequal(Qxx, zeros(11))); %!test %! Qxy = stk_gpquadform(x, y, rx, ry); %! assert(isequal(Qxy, zeros(11, 13))); %!test %! Qzz = stk_gpquadform(z, [], rz); %! assert(isequal(Qzz, zeros(7))); %!test %! Qxz = stk_gpquadform(x, z, rx, rz); %! assert(stk_isequal_tolabs(Qxz, 5/8 * ones(11, 7))); stk/inst/misc/dist/stk_filldist_exact.m0000664000175000017500000001437512617165720017226 0ustar bectbect% STK_FILLDIST_EXACT computes the (exact) fill distance of a set of points % % CALL: FD = stk_filldist_exact(X, BOX) % % computes the fill distance FD of the dataset X in the hyper-rectangle % BOX, using the computational-geometric algorithm of L. Pronzato and % W. G. Muller [1]. Recall that % % D = max_{Y in BOX} min_{1 <= i <= n} norm(X(i,:) - Y), (1) % % where norm(.) denotes the Euclidean norm in R^d. Optimal designs with % respect to the fill distance are sometimes called "minimax" designs % (see, e.g., [2]). % % CALL: FD = stk_filldist_exact(X) % % assumes that the fill distance is to be computed with respect to the % hyperrectangle BOX = [0; 1]^d. % % CALL: [FD, YMAX] = stk_filldist_exact(...) % % also returns the point YMAX where the maximal distance is attained, % i.e., the argmax in equation (1). % % REFERENCES % % [1] Luc Pronzato and Werner G. Muller, "Design of computer % experiments: space filling and beyond", Statistics and Computing, % 22(3):681-701, 2012. % % [2] Mark E. Johnson, Leslie M. Moore and Donald Ylvisaker, "Minimax % and maximin distance designs", Journal of Statistical Planning % and Inference, 26(2):131-148, 1990. % % See also: stk_filldist, stk_filldist_discretized, stk_dist, stk_mindist % Copyright Notice % % Copyright (C) 2013 SUPELEC, Guillaume Carlier & Florian Pasanisi % % Authors: Julien Bect % Florian Pasanisi % and Guillaume Carlier % % Maintainer: Julien Bect % % Guillaume Carlier and Florian Pasanisi wrote a first implementation % of the algorithm following the paper of Pronzato & Muller (2011), % which was subsequently streamlined and adapted to the STK toolbox % by Julien Bect. % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [fd, ymax] = stk_filldist_exact(x, box) %--------------------------------------- if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end x = double(x); [n, d] = size(x); if nargin == 1, box = repmat([0; 1], 1, d); else box = double(box); end %--- Construct a triangulation that covers [0; 1]^d ------------------------------------- x = add_symm(x, box); % extend using symmetries with respect to the faces % 2013/03/13: at the present time, Octave doesn't have the 'stable' option % (but, fortunately, we don't really care about doing a STABLE sort here...) % remove duplicates to avoid a a warning in delaunayn() x = unique(x, 'rows'); dt = delaunayn(x); % Delaunay trianulation nt = length(dt(:, 1)); % number of triangles %--- Compute centers and radiuses ------------------------------------------------------- center = zeros(nt, d); % prepare for computing the centers rsquared = zeros(nt, 1); % prepare for computing the (squared) radiuses for i = 1:nt, Z = x(dt(i, :), :); % vertices of the simplex W = sum(Z.^2, 2); % squared norms C = repmat(Z(1, :), d, 1) - Z(2:end, :); B = (W(1) - W(2:end))/2; center(i, :) = transpose(C\B); rsquared(i, 1) = sum(center(i,:).^2) + W(1) - 2 * Z(1, :) * center(i, :)'; end %--- Find the simplices for which the center is (almost) inside the box ----------------- % enlarge box for numerical tolerance TOLERANCE = 1e-10; bbox = box + TOLERANCE * [-1; 1] * diff(box); inside = true(size(center, 1), 1); for j = 1:d, inside = inside & (center(:, j) >= bbox(1, j)) ... & (center(:, j) <= bbox(2, j)) ; end %--- Grand finale ----------------------------------------------------------------------- % maximal radius for centers that are almost inside the box [rsquared_max, idx_max] = max(rsquared .* double(inside)); % project on the box ymax = max(min(center(idx_max, :), box(2, :)), box(1, :)); % fill distance fd = sqrt(rsquared_max); % safety net if isinf(fd) || any(isnan(ymax)), errmsg = 'This is surprising... How did I get here ???'; stk_error(errmsg, 'AlgorithmFailure'); end end % function stk_filldist_exact ------------------------------------------------------- %%%%%%%%%%%%%%% % add_sym % %%%%%%%%%%%%%%% function y = add_symm(x, box) %---------------------------------------------------------- [n d] = size(x); k = 2 * d + 1; y = repmat(x, k, 1); for j = 1:d y(n*j+1:(j+1)*n, j) = 2 * box(1, j) - x(1:n, j); y((k-j)*n+1:(k+1-j)*n, j) = 2 * box(2, j) - x(1:n, j); end end % function add_symm ----------------------------------------------------------------- %% % Check that both double-precision matrices and stk_dataframe objects are accepted %!test %! d = 3; x = rand(7, d); box = repmat([0; 1], 1, d); %! fd1 = stk_filldist_exact(x, box); %! fd2 = stk_filldist_exact(stk_dataframe(x), stk_dataframe(box)); %! assert(stk_isequal_tolabs(fd1, fd2)); %% % One point in the middle of [0; 1]^d %!test %! for dim = 1:6, %! x = 0.5 * ones(1, dim); %! fd = stk_filldist_exact(x); % [0; 1]^d is the default box %! assert(stk_isequal_tolabs(fd, 0.5 * sqrt(dim))); %! end %% % One point in the middle of [1; 2]^d %!test %! for dim = [1 3 7], %! box = repmat([1; 2], 1, dim); %! x = 1 + 0.5 * ones(1, dim); %! fd = stk_filldist_exact(x, box); %! assert(stk_isequal_tolabs(fd, 0.5 * sqrt(dim))); %! end %% % One point at the origin, BOX = [0; 1]^d %!test %! for dim = [1 3 7], %! x = zeros(1, dim); %! [fd, ymax] = stk_filldist_exact(x); %! assert(stk_isequal_tolabs(fd, sqrt(dim))); %! assert(stk_isequal_tolabs(ymax, ones(1, dim))); %! end stk/inst/misc/dist/stk_mindist.m0000664000175000017500000000556512617165720015700 0ustar bectbect% STK_MINDIST computes the separation distance of a set of points % % CALL: D = stk_mindist(X) % % computes the separation distance D of X. More precisely, if X is an % n x d matrix, then % % D = min_{1 <= i < j <= n} norm(X(i,:) - X(j,:)), % % where norm(.) denotes the Euclidean norm in R^d. % % See also: stk_dist, stk_filldist % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function md = stk_mindist(x) if nargin > 1, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % call MEX-file md = __stk_mindist_mex__(double(x)); end % function stk_mindist %% % Check that both double-precision matrices and stk_dataframe objects are accepted %!test %! d = 3; x = rand(7, d); %! md1 = stk_mindist(x); %! md2 = stk_mindist(stk_dataframe(x)); %! assert(stk_isequal_tolabs(md1, md2)); %% % Check that sk_mindist(x) is empty when x has zero lines %!test %! for nc = [0 5 10], %! x = zeros(0, nc); %! d = stk_mindist(x); %! assert(isempty(d)); %! end %% % Check that sk_mindist(x) is empty when x has only one line. %!test %! for nc = [0 5 10], %! x = rand(1, nc); %! d = stk_mindist(x); %! assert(isempty(d)); %! end %% % Check that sk_mindist(x) is 0.0 when x has 0 columns (but at least 2 lines) %!test %! for nr = [2 5 10], %! x = zeros(nr, 0); %! d = stk_mindist(x); %! assert(isequal(d, 0.0)); %! end %% % Random matrices with at least 2 lines and 1 column %!test %! %! nrep = 20; %! TOL_REL = 1e-15; %! %! for irep = 1:nrep, %! %! n = 2 + floor(rand * 10); %! d = 1 + floor(rand * 10); %! x = rand(n, d); %! z = stk_mindist(x); %! %! assert(isequal(size(d), [1, 1])); %! assert(~isnan(d)); %! assert(~isinf(d)); %! %! % check the result %! mindist = Inf; %! for i = 1:(n-1), %! for j = (i+1):n, %! mindist = min(mindist, norm(x(i,:) - x(j,:))); %! end %! end %! assert(abs(z - mindist) <= TOL_REL * mindist); %! %! end stk/inst/misc/dist/stk_filldist_discretized.m0000664000175000017500000001027712617165720020430 0ustar bectbect% STK_FILLDIST_DISCRETIZED computes the (discrete) fill distance of a set of points % % CALL: FD = stk_filldist_discretized(X, Y) % % computes the fill distance FD of X using the "test set" Y. More precisely, if % X and Y are respectively n x d and m x d, then % % FD = max_{1 <= j <= m} min_{1 <= i <= n} norm(X(i,:) - Y(j,:)), % % where norm(.) denotes the Euclidean norm in R^d. If Y is dense enough in some % subset BOX of R^d, then FD should be close to the actual fill distance of X in % BOX (see: stk_filldist_exact). Optimal designs with respect to the fill distance % are sometimes called "minimax" designs (see, e.g., [1]). % % CALL: [D, ARGMAX] = stk_filldist_discretized(X, Y) % % also returns the value ARGMAX of the index j for which the maximum is attained. % (If the maximum is obtained for several values of j, the smallest is returned.) % % REFERENCE % % [1] Mark E. Johnson, Leslie M. Moore and Donald Ylvisaker, "Minimax % and maximin distance designs", Journal of Statistical Planning % and Inference, 26(2):131-148, 1990. % % See also: stk_filldist, stk_filldist_exact, stk_dist, stk_mindist % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [fd, ymax] = stk_filldist_discretized(x, y) if nargin > 2, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end x = double(x); y = double(y); % call MEX-file [fd, idx_max] = __stk_filldist_discr_mex__(x, y); ymax = y(idx_max, :); end % function stk_filldist_discretized %% % Two non-empty matrices are expected as input arguments %!error stk_filldist_discretized(0.0) % incorrect nb of arguments %!error stk_filldist_discretized(0.0, 0.0, pi) % incorrect nb of arguments %!error stk_filldist_discretized(0.0, []) % second arg is empty %!error stk_filldist_discretized([], 0.0) % first arg is empty %% % Check that both double-precision matrices and stk_dataframe objects are accepted %!test %! d = 3; x = rand(7, d); y = rand(20, d); %! fd1 = stk_filldist_discretized(x, y); %! fd2 = stk_filldist_discretized(stk_dataframe(x), stk_dataframe(y)); %! assert(stk_isequal_tolabs(fd1, fd2)); %% % fd = 0 if X = Y %!test %! n = 5; %! for dim = 1:10, %! x = rand(n, dim); %! fd = stk_filldist_discretized(x, x); %! assert(stk_isequal_tolabs(fd, 0.0)); %! end %% % fd = norm if nx = ny = 1 %!test %! for dim = 1:10, %! x = rand(1, dim); %! y = rand(1, dim); %! fd = stk_filldist_discretized(x, y); %! assert(stk_isequal_tolabs(fd, norm(x - y))); %! end %% % Filldist = max(dist) if ny = 1 %!test %! n = 4; %! for dim = 2:10, %! x = zeros(n, dim); %! y = rand(1, dim); %! fd = stk_filldist_discretized(x, y); %! assert(stk_isequal_tolabs(fd, max(stk_dist(x, y)))); %! end %% % One point in the middle of [0; 1]^d %!test %! for dim = [1 3 6], %! x = 0.5 * ones(1, dim); %! y = stk_sampling_regulargrid(2^dim, dim); % [0; 1]^d is the default box %! fd = stk_filldist_discretized(x, y); %! assert(stk_isequal_tolabs(fd, 0.5 * sqrt(dim))); %! end %% % One point at the origin, BOX = [0; 1]^d %!test %! for dim = [1 3 7], %! x = zeros(1, dim); %! y = stk_sampling_regulargrid(3^dim, dim); %! [fd, ymax] = stk_filldist_discretized(x, y); %! assert(stk_isequal_tolabs(fd, sqrt(dim))); %! assert(stk_isequal_tolabs(ymax, ones(1, dim))); %! end stk/inst/misc/dist/stk_dist.m0000664000175000017500000000647112617165720015171 0ustar bectbect% STK_DIST computes a matrix of (Euclidean) distances % % CALL: D = stk_dist(X, Y) % % computes the matrix of distances between X and Y. More precisely, if % X is an nX x d matrix, and Y an nY x d matrix, the D is an nX x nY % matrix with % % D_{i,j} = norm(X(i,:) - Y(j,:)), % % where norm(.) denotes the Euclidean norm in R^d. % % See also: stk_mindist, stk_filldist, norm % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function D = stk_dist(x, y, pairwise) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % read argument #1 x = double(x); % read argument #2 if nargin < 2, y = []; else y = double(y); end % read argument #3 if nargin < 3, pairwise = false; else if ~islogical(pairwise) errmsg = 'Argument ''pairwise'' should be either true or false.'; stk_error(errmsg, 'TypeMismatch'); end end if pairwise, if isempty(y), D = zeros(size(x, 1), 1); else D = __stk_dist_pairwise__ (x, y); %D = sqrt (sum ((x - y) .^ 2, 2)); % The MEX-file is usually faster end else if isempty(y), D = __stk_dist_matrixx__(x); else D = __stk_dist_matrixy__(x, y); end end end % function stk_dist %% % Check that an error is raised in nargin is neither 1 nor 2 %!error stk_dist(); %!error stk_dist(0, 0, 0); %!error stk_dist(0, 0, 0, 0); %% % Check that an error is raised when the number of columns differs %!error stk_dist(0, ones(1, 2)); %!error stk_dist(eye(3), ones(1, 2)); %!error stk_dist(ones(2, 1), zeros(2)); %% % Test with some simple matrices %!shared x, y, z %! x = zeros(11, 5); %! y = zeros(13, 5); %! z = ones(7, 5); %!test %! Dx = stk_dist(x); %! assert(isequal(Dx, zeros(11))); %!test %! Dxx = stk_dist(x, x); %! assert(isequal(Dxx, zeros(11))); %!test %! Dxy = stk_dist(x, y); %! assert(isequal(Dxy, zeros(11, 13))); %!test %! Dzz = stk_dist(z, z); %! assert(isequal(Dzz, zeros(7))); %!test %! Dxz = stk_dist(x, z); %! assert(stk_isequal_tolabs(Dxz, sqrt(5)*ones(11, 7))); %!test %! x = randn(5,3); %! y = randn(5,3); %! D1 = stk_dist(x, y, true); % pairwise %! D2 = stk_dist(x, y); %! assert(stk_isequal_tolabs(D1, diag(D2))); %!test %! x = randn(5,3); %! D1 = stk_dist(x, [], true); % pairwise %! assert(stk_isequal_tolabs(D1, zeros(5, 1))); %! D1 = stk_dist(x, x, true); % pairwise %! assert(stk_isequal_tolabs(D1, zeros(5, 1))); stk/inst/misc/design/0000775000175000017500000000000012617165717013473 5ustar bectbectstk/inst/misc/design/stk_maxabscorr.m0000664000175000017500000000456512617165717016705 0ustar bectbect% STK_MAXABSCORR computes the maximal absolute correlation for a set of points % % CALL: MAC = stk_maxabscorr (X) % % computes the Maximum Absolute (linear) Correlation MAC between the columns % of the array X. % % NOTES: % % * The construction of experimental designs (more specifically, Latin % hypercubes samples) with a small MAC is considered, e.g., by Florian % (1992) and Cioppa & Lucas (2007). % % * When X is a Latin hypercube sample, the linear (Pearson) correlation % coefficients and Spearman's rank correlation coefficients coincide. % % REFERENCES % % [1] Ales Florian, "An Efficient Sampling Scheme: Updated Latin Hypercube % Sampling", Probabilistic Engineering Mechanics, 7:123-130, 1992. % http://dx.doi.org/10.1016/0266-8920(92)90015-A % % [2] Thomas M. Cioppa and Thomas W. Lucas, "Efficient Nearly Orthogonal and % Space-Filling Latin Hypercubes, Technometrics, 49:1, 45-55, 2007. % http://dx.doi.org/10.1198/004017006000000453 % % See also: stk_mindist, stk_filldist, stk_phipcrit % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function mac = stk_maxabscorr (x) if nargin > 1 stk_error ('Too many input arguments.', 'TooManyInputArgs'); end % compute the correlation matrix c = corr (double (x)); % get rid of diagonal terms c = triu (c, 1); mac = max (abs (c(:))); end % function stk_maxabscorr %!assert (stk_isequal_tolabs (0.0, ... % Test on an OLHS(5) %! stk_maxabscorr ([0.4 0.8 0 -0.4 -0.8; -0.8 0.4 0 0.8 -0.4]'))); stk/inst/misc/design/stk_phipcrit.m0000664000175000017500000000754112617165717016363 0ustar bectbect% STK_PHIPCRIT computes the "phi_p" criterion of Morris & Mitchell % % CALL: D = stk_phipcrit (X, P) % % computes the phi_P criterion on the set of points X, which is defined for % an n x d array X as % % D = (sum_{1 <= i < j <= n} d_ij ^ (-p)) ^ (-1/p) % % where d_ij is the Euclidean distance in R^d between X(i,:) and X(j,:). % % CALL: D = stk_phipcrit (X) % % computes the phi_P criterion with P = 50. % % NOTES: % % * In the special case P = 2, this criterion has first been introduced by % Audze & Eglais (1977). % % * When p -> +Inf, the value of the phi_p criterion tends to the inverse of % the mindist criterion. The phi_p criterion with a high value of p is % often used in place of the mindist criterion for its being easier to % optimize. Morris & Mitchell recommend using p in the range 20-50 for this % purpose. % % REFERENCES % % [1] Max D. Morris and Toby J. Mitchell, "Exploratory Designs for Computer % Experiments", Journal of Statistical Planning and Inference, % 43(3):381-402, 1995. % % [2] P. Audze and V. Eglais, "New approach for planning out experiments", % Problems of Dynamics and Strengths, 35:104-107, 1977. % % [3] Luc Pronzato and Werner G. Muller, "Design of computer % experiments: space filling and beyond", Statistics and Computing, % 22(3):681-701, 2012. % % [4] G. Damblin, M. Couplet and B. Iooss, "Numerical studies of space filling % designs: optimization of Latin hypercube samples and subprojection % properties", Journal of Simulation, in press. % % See also: stk_mindist, stk_filldist % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function phi = stk_phipcrit (x, p) if nargin > 2 stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin < 2, p = 50; end % compute the distance matrix D = stk_dist (x); % compute mindist D = D + diag (inf (1, size (x, 1))); z = min (D(:)); % compute the value of the criterion if z > 0 tmp = triu ((D / z) .^ (-p), 1); phi = 1 / z * sum(tmp(:)) .^ (1/p); else phi = Inf; end end % function stk_phipcrit %!shared x %! x = [0, 0.2, 0.4, 0.6, 0.8, 1.0; %! 0, 0.6, 0.8, 1.0, 0.2, 0.4]'; %!assert (stk_isequal_tolabs ... %! (stk_phipcrit (x, 10), 3.946317664423303, 1e-15)) %!assert (stk_isequal_tolabs ... %! (stk_phipcrit (x, 50), 3.614077252813102, 1e-15)); %!assert (stk_isequal_tolabs ... %! (stk_phipcrit (x, 100), 3.574589859827413, 1e-15)); %!assert (stk_isequal_tolabs ... %! (stk_phipcrit (x, 1e9), 1 / stk_mindist (x), 1e-8)); %!assert (isequal (stk_phipcrit (ones (2)), Inf)); % library (DiceDesign) # load DiceDesign 1.2 % options (digits = 16) # display 16 significat digits % % x <- data.frame (x1 = c(0, 0.2, 0.4, 0.6, 0.8, 1.0), % x2 = c(0, 0.6, 0.8, 1.0, 0.2, 0.4)) % % phiP (x, 10) # 3.946317664423303 % phiP (x, 50) # 3.614077252813102 % phiP (x, 100) # 3.574589859827413 % phiP (x, 1000) # Inf, but we can do better stk/inst/misc/error/0000775000175000017500000000000012617165720013345 5ustar bectbectstk/inst/misc/error/stk_assert_box.m0000664000175000017500000000445412617165720016564 0ustar bectbect% STK_ASSERT_BOX ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_assert_box (box, dim) mnemonic = 'InvalidBox'; % Name of the input variable (if available) boxname = inputname (1); if isempty (boxname), boxname = 'box'; end % Pretend that the error has been thrown by the caller stack = dbstack; stack = stack(2:end); % Check that box is a numeric matrix (the behaviour of ismatrix is inconsistent % between Matlab and Octave for arrays with more than two dimensions...) ismatrix = isnumeric (box) && (length( size (box)) == 2); if ~ ismatrix, errmsg = sprintf ('%s is not a numeric matrix.', boxname); stk_error (errmsg, mnemonic, stack); end [n, d] = size (box); if n ~= 2, errmsg = sprintf ('%s should have two rows, not more, not less.', boxname); stk_error (errmsg, mnemonic, stack); end if d == 0, errmsg = sprintf ('%s should have at least one column.', boxname); stk_error (errmsg, mnemonic, stack); end if (nargin == 2) && (d ~= dim) errmsg = sprintf ('%s should have exactly %d columns.', boxname, dim); stk_error (errmsg, mnemonic, stack); end if any (isnan (box)), errmsg = sprintf ('%s should at least one column.', boxname); stk_error (errmsg, mnemonic, stack); end if any (box(1, :) > box(2, :)), errmsg = sprintf ('%s has invalid boundaries.', boxname); stk_error (errmsg, mnemonic, stack); end end % function stk_assert_box stk/inst/misc/error/stk_error.m0000664000175000017500000000531312617165720015537 0ustar bectbect% STK_ERROR throws an STK error with a good-looking error identifier. % Copyright Notice % % Copyright (C) 2012 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_error (errmsg, mnemonic, stack) % second component of error identifier = name of calling function % (unless stk_error has been called directly from the base workspace) if nargin < 3, stack = dbstack (); if length (stack) == 1, caller = 'BaseWorkspace'; else % pretend that the error has been thrown by the caller stack = stack(2:end); % and get caller name to form the error identifier caller = stack(1).name; end else % if a "stack" has been provided by the user, we use it without asking % questions (if it's a struct) if ~ isstruct (stack) || ~ isfield (stack, 'name'), % We will throw an error, but not the one we were requested to! errmsg = 'Argument "stack" should be a valid stack structure.'; mnemonic = 'InvalidArgument'; stack = dbstack (); end caller = stack(1).name; end % keep only subfunction name (Octave) gt_pos = strfind (caller, '>'); if ~ isempty (gt_pos), caller = caller((gt_pos + 1):end); end % construct the error structure errstruct = struct (... 'message', errmsg, ... 'identifier', sprintf ('STK:%s:%s', caller, mnemonic), ... 'stack', stack); error (errstruct); end % function stk_error %!shared errmsg, mnemonic, badstack %! errmsg = 'Go ahead, make my day.'; %! mnemonic = 'ClintEastwood'; %! badstack = 0; % not a valid stack structure % Valid use of stk_error %!error stk_error(errmsg, mnemonic); % Use of an incorrect stack structure %!error stk_error (errmsg, mnemonic, badstack); %!error id=STK:stk_error:InvalidArgument stk_error (errmsg, mnemonic, badstack); stk/inst/misc/options/0000775000175000017500000000000012617165720013707 5ustar bectbectstk/inst/misc/options/stk_options_set.m0000664000175000017500000000476012617165720017323 0ustar bectbect% STK_OPTIONS_SET sets the value of one or all STK options % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function opts = stk_options_set (varargin) persistent options if isempty (options) options = init_options (); mlock; end switch nargin case 0, % nothing to do, just return the output case 1, % reset if (ischar (varargin{1})) && strcmp (varargin{1}, 'default') options = init_options (); else stk_error ('Syntax error', 'SyntaxError'); end case 2, options.(varargin{1}) = varargin{2}; case 3, options.(varargin{1}).(varargin{2}) = varargin{3}; otherwise stk_error ('Incorrect number of input arguments.', 'SyntaxError'); end opts = options; end % function stk_options_set function opts = init_options () opts = struct (); opts.stk_sf_matern.min_size_for_parallelization = 1e5; opts.stk_sf_matern.min_block_size = 1e3; opts.stk_dataframe.disp_format = 'basic'; % 'basic' or 'verbose' opts.stk_dataframe.disp_spstr = ' '; opts.stk_param_getdefaultbounds.tolvar = 5.0; opts.stk_param_getdefaultbounds.tolscale = 5.0; opts.stk_param_estim.optim_display_level = 'off'; opts.stk_figure.properties = {'InvertHardcopy', 'off', 'Color', [1 1 1]}; opts.stk_xlabel.properties = {'FontSize', 10, 'Color', [0.2 0 1]}; opts.stk_ylabel.properties = opts.stk_xlabel.properties; opts.stk_zlabel.properties = opts.stk_xlabel.properties; opts.stk_title.properties = {'FontSize', 10, 'FontWeight', 'bold'}; opts.stk_axes.properties = {'FontSize', 8}; end % function init_options stk/inst/misc/options/stk_options_get.m0000664000175000017500000000264712617165720017311 0ustar bectbect% STK_OPTIONS_GET returns the value of one or all STK options % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function argout = stk_options_get (varargin) opts = stk_options_set (); switch nargin case 0, % nothing to do, just return the output argout = opts; case 1, argout = opts.(varargin{1}); case 2, argout = opts.(varargin{1}).(varargin{2}); otherwise stk_error ('Too many input arguments.', 'TooManyInputArgs'); end end % function stk_options_get stk/inst/misc/optim/0000775000175000017500000000000012617165720013344 5ustar bectbectstk/inst/misc/optim/stk_select_optimizer.m0000664000175000017500000000654112617165720017772 0ustar bectbect% STK_SELECT_OPTIMIZER selects an optimizer for stk_param_estim() % % CALL: OPTIM_NUM = stk_select_optimizer (BOUNDS_AVAILABLE) % % returns a number that indicates which optimizer STK should use for % box-constrained (if BOUNDS_AVAILABLE is true or absent) or unconstrained % optimization in its parameter estimation procedure. The result OPTIM_NUM is % equal to 1 for Octave/sqp, 2 for Matlab/fminsearch, or 3 for Matlab/fmincon. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function optim_num = stk_select_optimizer (bounds_available, display) persistent optim_num_con optim_num_unc % Invocation with no arguments (setup) => recheck which optimizer to use force_recheck = (nargin == 0); % Select an appropriate optimizer if isempty (optim_num_con) || isempty (optim_num_unc) || force_recheck, if isoctave, % Use sqp for both unconstrained and box-constrained optimization optim_num_con = 1; optim_num_unc = 1; else % check if Matlab's fmincon is available optim_num_con = 2 + stk_optim_hasfmincon (); % use fminsearch (Nelder-Mead) for unconstrained optimization optim_num_unc = 2; % TODO: use fminunc for unconstrained optimization in Matlab % if the Optimization Toolbox is available (?) end mlock; % In Matlab, warn if fmincon is not present if (~ isoctave) && (optim_num_con == 2) warning (['Function fmincon not found, ', ... 'falling back on fminsearch.']); %#ok end end % Return the selected optimizer if nargin > 0 if bounds_available, optim_num = optim_num_con; else optim_num = optim_num_unc; end else optim_num = []; end % Display status if (nargin > 1) && display, fprintf ('Constrained optimizer for stk_param_estim: '); switch optim_num_con case 1, % octave / sqp fprintf ('sqp.\n'); case 2, % Matlab / fminsearch fprintf ('NONE.\n'); case 3, % Matlab / fmincon fprintf ('fmincon.\n'); otherwise error ('Unexpected value for optim_num_con'); end fprintf ('Unconstrained optimizer for stk_param_estim: '); switch optim_num_unc case 1, % octave / sqp fprintf ('sqp.\n'); case 2, % Matlab / fminsearch fprintf ('fminsearch.\n'); otherwise error ('Unexpected value for optim_num_unc'); end end end % function stk_select_optimizer stk/inst/misc/text/0000775000175000017500000000000012617165721013201 5ustar bectbectstk/inst/misc/text/stk_sprintf_colvect_scientific.m0000664000175000017500000001603612617165721021652 0ustar bectbect% STK_SPRINTF_COLVECT_SCIENTIFIC ... % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [str, err] = stk_sprintf_colvect_scientific (x, max_width) if isempty (x), str = ''; err = 0; return; end if nargin < 2, max_width = 8; end % Turn x into a column vector x = double (x); x = x(:); % Get rid of infinities is_inf = isinf (x); is_pos = (x > 0); is_pinf = is_inf & is_pos; is_minf = is_inf & (~ is_pos); x(is_inf) = 0.0; % Get rid of negative zeros is_zero = (x == 0); x(is_zero) = 0.0; % Compute exponents ax = abs (x); exponent = zeros (size (x)); exponent(~is_zero) = floor (log10 (ax(~ is_zero))); % Compute mantissae mantissa = x .* 10 .^ (- exponent); % Is there any negative element ? any_negative = any (x < 0); %--- Start with only one digit for the mantissa -------------------------------- % Nb digits for the mantissa (including the leading digit) n1 = 1; % Compute mantissa/exponent after rounding [mantissa_r, exponent_r] = round_ (mantissa, exponent, n1); % Maximal absolute exponent maxexp = max (abs (exponent_r)); % Nb digits for the exponent n2 = max (2, 1 + floor (log10 (maxexp))); % Nb non-digit characters (+2 for "e+") -> no decimal separator in this case n3 = any_negative + 2; % Abort this is already too long if (n1 + n2 + n3) > max_width str = repmat ('#', length (x), max_width); err = +inf; return; end % Otherwise, this is our current best solution best_err = abs (x - mantissa_r .* 10 .^ (exponent_r)); best_n1 = 1; %--- Try to add a decimal part ------------------------------------------------- if (any (best_err > eps * abs (x))) && ((n1 + n2 + n3 + 2) <= max_width) % We can add a decimal part, so let's do it... while (any (best_err > eps * abs (x))) && ((n1 + n2 + n3) < max_width) % Increase numer of digits for the mantissa (including the leading digit) n1 = n1 + 1; % Compute mantissa/exponent after rounding [mantissa_r, exponent_r] = round_ (mantissa, exponent, n1); % Maximal absolute exponent maxexp = max (abs (exponent_r)); % Nb digits for the exponent n2 = max (2, 1 + floor (log10 (maxexp))); % Nb non-digit characters (+2 for "e+") % --> "+3" for "e", "." in the mantissa and "+" in the exponent n3 = any_negative + 3; err = abs (x - mantissa_r .* 10 .^ (exponent_r)); if (max (err) < max (best_err)) best_err = err; best_n1 = n1; end end end n1 = best_n1; %--- Produce formatted output ------------------------------------------------- % Compute mantissa/exponent after rounding [mantissa_r, exponent_r] = round_ (mantissa, exponent, n1); % format specifier for the mantissa fmt1 = sprintf ('%%%d.%df', n1 + (n1 > 1) + any_negative, n1 - 1); str1 = arrayfun (@(u)(sprintf (fmt1, u)), mantissa_r, 'UniformOutput', false); % format specifier for the exponent fmt2 = sprintf('e%%+0%dd', n2 + 1); str2 = arrayfun (@(u)(sprintf (fmt2, u)), exponent_r, 'UniformOutput', false); % merge mantissa and exponent str = [char(str1{:}) char(str2{:})]; % fix infinities if any (is_pinf), str(is_pinf, :) = [repmat(' ', 1, max_width - 3) 'Inf']; end if any (is_minf) str(is_minf, :) = [repmat(' ', 1, max_width - 4) '-Inf']; end % Compute the maximal error if nargout > 1, err = max (abs (x - mantissa_r .* 10 .^ (exponent_r))); end end % function stk_sprintf_colvect_scientific function [mantissa_r, exponent_r] = round_ (mantissa, exponent, n1) % Round mantissa to n1 digits (including the leading digit) y = 10 ^ (n1 - 1); mantissa_r = round (mantissa * y) / y; exponent_r = exponent; % Fix mantissa values of 10 after rounding b = (abs (mantissa_r) == 10); mantissa_r(b) = sign (mantissa_r(b)); exponent_r(b) = exponent_r(b) + 1; end % function round_ %!shared x, s %! x = [1.2; -34567]; %!test s = stk_sprintf_colvect_scientific(x, 1); %!assert (isequal(s, ['#'; '#'])) %!test s = stk_sprintf_colvect_scientific(x, 3); %!assert (isequal(s, ['###'; '###'])) %!test s = stk_sprintf_colvect_scientific(x, 5); %!assert (isequal(s, ['#####'; '#####'])) %!test s = stk_sprintf_colvect_scientific(x, 6); %!assert (isequal(s, [' 1e+00'; '-3e+04'])) %!test s = stk_sprintf_colvect_scientific(x, 7); %!assert (isequal(s, [' 1e+00'; '-3e+04'])) %!test s = stk_sprintf_colvect_scientific(x, 8); %!assert (isequal(s, [' 1.2e+00'; '-3.5e+04'])) %!test s = stk_sprintf_colvect_scientific(x, 9); %!assert (isequal(s, [' 1.20e+00'; '-3.46e+04'])) %!test s = stk_sprintf_colvect_scientific(x, 10); %!assert (isequal(s, [' 1.200e+00'; '-3.457e+04'])) %!test s = stk_sprintf_colvect_scientific(x, 11); %!assert (isequal(s, [' 1.2000e+00'; '-3.4567e+04'])) %!test s = stk_sprintf_colvect_scientific(x, 12); %!assert (isequal(s, [' 1.2000e+00'; '-3.4567e+04'])) %!shared x, s %! x = [0.9; 0.91; 0.99; 0.999]; %!test s = stk_sprintf_colvect_scientific (x, 4); %!assert (isequal(s, ['####'; '####'; '####'; '####'])) %!test s = stk_sprintf_colvect_scientific (x, 5); %!assert (isequal(s, ['9e-01'; '9e-01'; '1e+00'; '1e+00'])) %!test s = stk_sprintf_colvect_scientific (x, 6); %!assert (isequal(s, ['9e-01'; '9e-01'; '1e+00'; '1e+00'])) %!test s = stk_sprintf_colvect_scientific (x, 7); %!assert (isequal(s, ['9.0e-01'; '9.1e-01'; '9.9e-01'; '1.0e+00'])) %!test s = stk_sprintf_colvect_scientific (x, 8); %!assert (isequal(s, ['9.00e-01'; '9.10e-01'; '9.90e-01'; '9.99e-01'])) %!shared x, s %! x = [0.9; -0.91; 0.99; 0.999]; %!test s = stk_sprintf_colvect_scientific (x, 4); %!assert (isequal(s, ['####'; '####'; '####'; '####'])) %!test s = stk_sprintf_colvect_scientific (x, 5); %!assert (isequal(s, ['#####'; '#####'; '#####'; '#####'])) %!test s = stk_sprintf_colvect_scientific (x, 6); %!assert (isequal(s, [' 9e-01'; '-9e-01'; ' 1e+00'; ' 1e+00'])) %!test s = stk_sprintf_colvect_scientific (x, 7); %!assert (isequal(s, [' 9e-01'; '-9e-01'; ' 1e+00'; ' 1e+00'])) %!test s = stk_sprintf_colvect_scientific (x, 8); %!assert (isequal(s, [' 9.0e-01'; '-9.1e-01'; ' 9.9e-01'; ' 1.0e+00'])) %!test %! x = [1e6; -1e10; 1e-221]; %! s = stk_sprintf_colvect_scientific(x, 10); %! assert(isequal(s, [' 1e+006'; '-1e+010'; ' 1e-221'])); stk/inst/misc/text/stk_sprintf_colvect_fixedpoint.m0000664000175000017500000001015512617165721021677 0ustar bectbect% STK_SPRINTF_COLVECT_FIXEDPOINT ... % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [str, err] = stk_sprintf_colvect_fixedpoint(x, max_width) if isempty(x), str = ''; err = 0; return; end if nargin < 2, max_width = 8; end % turn x into a column vector x = double(x); x = x(:); % get rid of infinities is_inf = isinf (x); is_pos = (x > 0); is_pinf = is_inf & is_pos; is_minf = is_inf & (~ is_pos); x(is_inf) = 0.0; % get rid of negative zeros is_zero = (x == 0); x(is_zero) = 0.0; % Is there any negative element ? any_negative = any(x < 0); % Start without decimal part ax = abs(x); n1 = max(1, floor(log10(max(ax))) + 1); n2 = 0; n3 = any_negative; % Abort this is already too long if (n1 + n2 + n3) > max_width str = repmat('#', length(x), max_width); err = +inf; return; end % Otherwise, this is our current best solution best_err = max(abs(fix(x) - x)); best_n2 = 0; % Should we add a decimal part ? if (best_err > eps) && ((n1 + n2 + n3 + 2) <= max_width) % We can add a decimal part, so let's do it... while (best_err > eps) && ((n1 + n2 + n3) < max_width) n2 = n2 + 1; % add one decimal n3 = 1 + any_negative; % +1 for the comma c = 10 ^ (-n2); xx = (round (ax / c)) * c; err = max (abs (ax - xx)); if err < best_err, best_err = err; best_n2 = n2; end end end err = best_err; n2 = best_n2; fmt = sprintf ('%%%d.%df', n1 + n2 + n3, n2); str = arrayfun (@(u) sprintf (fmt, u), x, 'UniformOutput', false); str = char (str{:}); % fix infinities if any (is_pinf), str(is_pinf, :) = [repmat(' ', 1, max_width - 3) 'Inf']; end if any (is_minf) str(is_minf, :) = [repmat(' ', 1, max_width - 4) '-Inf']; end end % function stk_sprintf_colvect_fixedpoint %!shared x, s %! x = [1.2; 3.48]; %!test s = stk_sprintf_colvect_fixedpoint(x, 1); %!assert (isequal(s, ['1'; '3'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 2); %!assert (isequal(s, ['1'; '3'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 3); %!assert (isequal(s, ['1.2'; '3.5'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 4); %!assert (isequal(s, ['1.20'; '3.48'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 5); %!assert (isequal(s, ['1.20'; '3.48'])) %!shared x, s %! x = [1.2; -3.48]; %!test s = stk_sprintf_colvect_fixedpoint(x, 1); %!assert (isequal(s, ['#'; '#'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 2); %!assert (isequal(s, [' 1'; '-3'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 3); %!assert (isequal(s, [' 1'; '-3'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 4); %!assert (isequal(s, [' 1.2'; '-3.5'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 5); %!assert (isequal(s, [' 1.20'; '-3.48'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 6); %!assert (isequal(s, [' 1.20'; '-3.48'])) %!shared x, s %! x = [0.2; 0.48]; %!test s = stk_sprintf_colvect_fixedpoint(x, 1); %!assert (isequal(s, ['0'; '0'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 2); %!assert (isequal(s, ['0'; '0'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 3); %!assert (isequal(s, ['0.2'; '0.5'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 4); %!assert (isequal(s, ['0.20'; '0.48'])) %!test s = stk_sprintf_colvect_fixedpoint(x, 5); %!assert (isequal(s, ['0.20'; '0.48'])) stk/inst/misc/text/stk_sprintf_framed.m0000664000175000017500000000227412617165721017250 0ustar bectbect% STK_SPRINTF_FRAMED writes formatted text into a frame. % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function s = stk_sprintf_framed(fmt, varargin) a = sprintf([' ' fmt ' '], varargin{:}); b = repmat('=', 1, length(a)); s = sprintf('#%s#\n#%s#\n#%s#\n', b, a, b); end % function stk_sprintf_framed stk/inst/misc/text/stk_disp_examplewelcome.m0000664000175000017500000000256612617165721020277 0ustar bectbect% STK_DISP_EXAMPLEWELCOME % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_disp_examplewelcome () stack = dbstack (); if length(stack) >= 2, demo_name = stack(2).name; display_help = true; else demo_name = 'This is a demo example...'; display_help = false; end fprintf ('\n%s\n', stk_sprintf_framed (demo_name)); if display_help help (demo_name); end end % function stk_disp_examplewelcome stk/inst/misc/text/stk_sprintf_colvect.m0000664000175000017500000000351212617165721017445 0ustar bectbect% STK_SPRINTF_COLVECT ... % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function str = stk_sprintf_colvect (x, max_width) if nargin < 2, max_width = 8; end % Try fixed-point notation first. [str, err_fp] = stk_sprintf_colvect_fixedpoint (x, max_width); if err_fp > 0, % Accept fixed-point notation if the error is zero, % try scientific notation otherwise. [str_sc, err_sc] = stk_sprintf_colvect_scientific (x, max_width); if err_sc < err_fp, % Choose scientific notation if it's better than fixed-point str = str_sc; end end end % function stk_sprintf_colvect %!shared s %!test s = stk_sprintf_colvect ([1 1e1], 6); %!assert (isequal (s, [' 1'; '10'])) %!test s = stk_sprintf_colvect ([1 1e3], 6); %!assert (isequal (s, [' 1'; '1000'])) %!test s = stk_sprintf_colvect ([1 1e5], 6); %!assert (isequal (s, [' 1'; '100000'])) %!test s = stk_sprintf_colvect ([1 1e6], 6); %!assert (isequal (s, ['1e+00'; '1e+06'])) stk/inst/misc/text/stk_disp_progress.m0000664000175000017500000000352512617165721017130 0ustar bectbect% STK_DISP_PROGRESS ... % % Example: % % for i = 1:1000, % stk_disp_progress ('toto ', i, 1000); % end % % See also: waitbar % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Authors: Emmanuel Vazquez % Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_disp_progress (msg, n, N) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if ~ ((n > 0) && (n <= N)) stk_error ('n should be between 1 and N', 'InvalidArgument'); end persistent revmsg if n == 1 revmsg = []; end % Print current progress message msg = sprintf (msg, n, N); fprintf ([revmsg, msg]); % Prepare for erasing next time revmsg = repmat (sprintf ('\b'), 1, length (msg)); if n == N fprintf ('\n'); end end % function stk_disp_progress %!error stk_disp_progress ('toto ', 0, 1); %!test stk_disp_progress ('toto ', 1, 1); %!error stk_disp_progress ('toto ', 2, 1); %!test %! stk_disp_progress ('toto ', 1, 2); %! stk_disp_progress ('toto ', 2, 2); stk/inst/misc/test/0000775000175000017500000000000012617165721013174 5ustar bectbectstk/inst/misc/test/stk_isequal_tolabs.m0000664000175000017500000000672212617165721017251 0ustar bectbect% STK_ISEQUAL_TOLABS tests approximate equality of two matrices or structures. % % CALL: BOOL = stk_isequal_tolabs(A, B, TOLABS) % % returns true if A and B are numeric arrays of the same size, such that for % any pair (a, b) of corresponding entries, % % abs(b - a) <= TOLABS. (1) % % For numeric array, the function returns false is either % % * the array don't have identical sizes, or % * the array have identical sizes but (1) doesn't hold. % % If A and B are structures with the same list of fieldnames, the function % works recursively on the fields, and returns true iff all the fields are % approximately equal. % % CALL: b = stk_isequal_tolabs(a, b) % % uses the default value 1e-8 for TOLABS. % % See also isequal. % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function res = stk_isequal_tolabs(a, b, tolabs) DEFAULT_TOLABS = 1e-8; if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin == 2, tolabs = DEFAULT_TOLABS; end if isstruct(a) && isstruct(b), L = fieldnames(a); if ~isequal(fieldnames(b), L), res = false; return; end res = true; for k = 1:length(L), if ~isfield(b, L{k}), res = false; return; end res = stk_isequal_tolabs(a.(L{k}), b.(L{k}), tolabs); if ~ res, return; end end elseif isnumeric(a) && isnumeric(b) res = all(abs(b(:) - a(:)) <= tolabs); elseif ischar (a) && ischar (b) res = strcmp (a, b); elseif iscell (a) && iscell (b) for i = 1:numel(a), if ~stk_isequal_tolabs (a{i}, b{i}, tolabs); res = false; return; end end res = true; elseif (isa (a, 'stk_dataframe') || isa (a, 'stk_kreq_qr')) ... && (strcmp (class (a), class (b))) res = stk_isequal_tolabs (struct (a), struct (b), tolabs); else res = false; end end % function stk_isequal_tolabs %!shared r1, r2, a, b, tolabs %! a = 1.01; b = 1.02; tolabs = 0.1; %!error rr = stk_isequal_tolabs(); %!error rr = stk_isequal_tolabs(a); %!test r1 = stk_isequal_tolabs(a, b); %!test r2 = stk_isequal_tolabs(a, b, tolabs); %!error rr = stk_isequal_tolabs(a, b, tolabs, pi); %!test assert(~r1); %!test assert(r2); %!test %! a = struct('u', []); b = struct('v', []); %! assert(~ stk_isequal_tolabs(a, b)) %!test %! a = struct('u', 1.01); b = struct('u', 1.02); %! assert(stk_isequal_tolabs(a, b, tolabs)) stk/inst/misc/test/stk_is_lhs.m0000664000175000017500000000503012617165721015512 0ustar bectbect% STK_IS_LHS tests if a given set of points forms a LHS % % CALL: OK = stk_is_lhs (X, N, DIM, BOX) % % tests if X is a Latin Hypercube Sample (LHS) of size N, over the hyper- % rectangle BOX of dimension DIM. The result OK is true if X is a LHS and % false otherwise. % % CALL: OK = stk_is_lhs (X, N, DIM) % % tests if X is a Latin Hypercube Sample (LHS) of size N, over the hyper- % rectangle [0; 1]^DIM. % % CALL: OK = stk_is_lhs (X) % % tests if X is a Latin Hypercube Sample (LHS). Both the size N and the % number DIM of factors are inferred from X. % % All three calling syntaxes accept both matrix-type inputs or data structures % (with an 'a' field) for X. % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function b = stk_is_lhs (x, n, dim, box) if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end x = double (x); if nargin == 1, [n dim] = size (x); elseif nargin == 2, if size (x, 1) ~= n, b = false; return; end dim = size (x, 2); else % nargin > 2 if ~ isequal (size (x), [n dim]) b = false; return; end end % read argument 'box' if (nargin < 4) || (isempty (box)) xmin = zeros (1, dim); xmax = ones (1, dim); else if ~ isa (box, 'stk_hrect') box = stk_hrect (box); end xmin = box.lower_bounds; xmax = box.upper_bounds; end for j = 1:dim, y = x(:,j); if (xmin(j) > min(y)) || (xmax(j) < max(y)) b = false; return; end y = (y - xmin(j)) / (xmax(j) - xmin(j)); y = ceil (y * n); if ~ isequal (sort (y), (1:n)'), b = false; return; end end b = true; end % function stk_is_lhs stk/inst/misc/test/stk_isequal_tolrel.m0000664000175000017500000000704412617165721017264 0ustar bectbect% STK_ISEQUAL_TOLREL tests approximate equality of two matrices or structures. % % CALL: BOOL = stk_isequal_tolrel(A, B, TOLREL) % % returns true if A and B are numeric arrays of the same size, such that for % any pair (a, b) of corresponding entries, % % abs(b - a) <= TOLABS, (1) % % where % % TOLABS = max(max(A(:)), max(B(:))) * TOLREL. % % For numeric array, the function returns false is either % % * the array don't have identical sizes, or % * the array have identical sizes but (1) doesn't hold. % % If A and B are structures with the same list of fieldnames, the function % works recursively on the fields, and returns true iff all the fields are % approximately equal. % % CALL: b = stk_isequal_tolrel(a, b) % % uses the default value 1e-8 for TOLREL. % % See also isequal. % Copyright Notice % % Copyright (C) 2012, 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function res = stk_isequal_tolrel(a, b, tolrel) DEFAULT_TOLREL = 1e-8; if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin == 2, tolrel = DEFAULT_TOLREL; end if isstruct(a) && isstruct(b), L = fieldnames(a); if ~isequal(fieldnames(b), L), res = false; return; end res = true; for k = 1:length(L), if ~isfield(b, L{k}), res = false; return; end res = stk_isequal_tolrel(a.(L{k}), b.(L{k}), tolrel); if ~ res, return; end end elseif isnumeric(a) && isnumeric(b) aa = a(:); bb = b(:); tolabs = max(abs(aa), abs(bb)) * tolrel; res = all(abs(bb - aa) <= tolabs); elseif ischar (a) && ischar (b) res = strcmp (a, b); elseif iscell (a) && iscell (b) for i = 1:numel(a), if ~ stk_isequal_tolrel (a{i}, b{i}, tolrel); res = false; return; end end res = true; elseif isa (a, 'stk_dataframe') && (strcmp (class (a), class (b))) res = stk_isequal_tolrel (struct (a), struct (b), tolrel); else res = false; end end % function stk_isequal_tolrel %!shared r1, r2, a, b, tolrel %! a = 1.01; b = 1.02; tolrel = 0.1; %!error rr = stk_isequal_tolrel(); %!error rr = stk_isequal_tolrel(a); %!test r1 = stk_isequal_tolrel(a, b); %!test r2 = stk_isequal_tolrel(a, b, tolrel); %!error rr = stk_isequal_tolrel(a, b, tolrel, pi); %!test assert(~r1); %!test assert(r2); %!test %! a = struct('u', []); b = struct('v', []); %! assert(~ stk_isequal_tolrel(a, b)) %!test %! a = struct('u', 1.01); b = struct('u', 1.02); %! assert(stk_isequal_tolrel(a, b, tolrel)) stk/inst/misc/test/stk_test_dfbinaryop.m0000664000175000017500000000317012617165721017430 0ustar bectbect% STK_TEST_DFBINARYOP ... % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_test_dfbinaryop (F, a1, a2) try x1 = stk_dataframe (a1); x2 = stk_dataframe (a2); res = feval (F, a1, a2); x3 = feval (F, x1, x2); assert (isa (x3, 'stk_dataframe') && isequal (double (x3), res)); x3 = feval (F, x1, a2); assert (isa (x3, 'stk_dataframe') && isequal (double (x3), res)); x3 = feval (F, a1, a2); assert (isequal (x3, res)); catch err = lasterror (); if strcmp (err.message, ['octave_base_value::array_value(): ' ... 'wrong type argument `class''']) warning (msg.message); else rethrow (err); end end % try end % function stk_test_dfbinaryop stk/inst/misc/mole/0000775000175000017500000000000012617165720013150 5ustar bectbectstk/inst/misc/mole/isoctave/0000775000175000017500000000000012617165720014765 5ustar bectbectstk/inst/misc/mole/isoctave/isoctave.m0000664000175000017500000000236312617165720016764 0ustar bectbect% ISOCTAVE returns true if Octave is used as an interpreter, false otherwise % Copyright Notice % % Copyright (C) 2011-2013 SUPELEC % % Author: Julien Bect % % Note: was called 'stk_is_octave_in_use' in STK <= 2.0.1 % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function octave_in_use = isoctave persistent b; if isempty (b), b = (exist ('OCTAVE_VERSION', 'builtin') == 5); mlock; end octave_in_use = b; end % function isoctave stk/inst/misc/mole/linsolve/0000775000175000017500000000000012617165720015003 5ustar bectbectstk/inst/misc/mole/linsolve/linsolve.m0000664000175000017500000001050712617165720017017 0ustar bectbect## Copyright (C) 2013 Nir Krakauer ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; If not, see . ## -*- texinfo -*- ## @deftypefn {Function File} {@var{x} =} linsolve (@var{A}, @var{b}) ## @deftypefnx {Function File} {@var{x} =} linsolve (@var{A}, @var{b}, @var{opts}) ## @deftypefnx {Function File} {[@var{x}, @var{R}] =} linsolve (@dots{}) ## Solve the linear system @code{A*x = b}. ## ## With no options, this function is equivalent to the left division operator ## @w{(@code{x = A \ b})} or the matrix-left-divide function ## @w{(@code{x = mldivide (A, b)})}. ## ## Octave ordinarily examines the properties of the matrix @var{A} and chooses ## a solver that best matches the matrix. By passing a structure @var{opts} ## to @code{linsolve} you can inform Octave directly about the matrix @var{A}. ## In this case Octave will skip the matrix examination and proceed directly ## to solving the linear system. ## ## @strong{Warning:} If the matrix @var{A} does not have the properties ## listed in the @var{opts} structure then the result will not be accurate ## AND no warning will be given. When in doubt, let Octave examine the matrix ## and choose the appropriate solver as this step takes little time and the ## result is cached so that it is only done once per linear system. ## ## Possible @var{opts} fields (set value to true/false): ## ## @table @asis ## @item LT ## @var{A} is lower triangular ## ## @item UT ## @var{A} is upper triangular ## ## @item UHESS ## @var{A} is upper Hessenberg (currently makes no difference) ## ## @item SYM ## @var{A} is symmetric or complex Hermitian (currently makes no difference) ## ## @item POSDEF ## @var{A} is positive definite ## ## @item RECT ## @var{A} is general rectangular (currently makes no difference) ## ## @item TRANSA ## Solve @code{A'*x = b} by @code{transpose (A) \ b} ## @end table ## ## The optional second output @var{R} is the inverse condition number of ## @var{A} (zero if matrix is singular). ## @seealso{mldivide, matrix_type, rcond} ## @end deftypefn ## Author: Nir Krakauer ## STK notes: ## * This version of linsolve.m comes from revision b66f068e4468 of Octave's ## hg repository (changeset by Nir Krakauer on 2013-09-26, 09:38:51) ## * The only change that has been made is the introduction of a tolerance ## in the first assert of the first unit test, that's all ! function [x, R] = linsolve (A, b, opts) if (nargin < 2 || nargin > 3) print_usage (); endif if (! (isnumeric (A) && isnumeric (b))) error ("linsolve: A and B must be numeric"); endif ## Process any opts if (nargin > 2) if (! isstruct (opts)) error ("linsolve: OPTS must be a structure"); endif trans_A = false; if (isfield (opts, "TRANSA") && opts.TRANSA) trans_A = true; A = A'; endif if (isfield (opts, "POSDEF") && opts.POSDEF) A = matrix_type (A, "positive definite"); endif if (isfield (opts, "LT") && opts.LT) if (trans_A) A = matrix_type (A, "upper"); else A = matrix_type (A, "lower"); endif endif if (isfield (opts, "UT") && opts.UT) if (trans_A) A = matrix_type (A, "lower"); else A = matrix_type (A, "upper"); endif endif endif x = A \ b; if (nargout > 1) if (issquare (A)) R = rcond (A); else R = 0; endif endif endfunction # linsolve %!test %! n = 4; %! A = triu (rand (n)); %! x = rand (n, 1); %! b = A' * x; %! opts.UT = true; %! opts.TRANSA = true; %! assert (linsolve (A, b, opts), A' \ b, 1e-12); %!error linsolve () %!error linsolve (1) %!error linsolve (1,2,3) %!error linsolve ({1},2) %!error linsolve (1,{2}) %!error linsolve (1,2,3) stk/inst/misc/mole/corr/0000775000175000017500000000000012617165720014115 5ustar bectbectstk/inst/misc/mole/corr/corr.m0000664000175000017500000000713412617165720015245 0ustar bectbect% CORR ... % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % % This code is looesely based on Octave 3.7.7+'s quantile.m., where % the original copyright notice was: % % ## Copyright (C) 1996-2013 John W. Eaton % ## % ## This file is part of Octave. % ## % ## Octave is free software; you can redistribute it and/or modify it % ## under the terms of the GNU General Public License as published by % ## the Free Software Foundation; either version 3 of the License, or % ## (at your option) any later version. % ## % ## Octave 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 Octave; see the file COPYING. If not, see % ## . % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function c = corr (x, y) % Note: the original Octave code has been rewritten to avoid calling cov, since % there is a long-standing incompatiblity between Matlab's cov and Octave's cov % (see https://savannah.gnu.org/bugs/?40751) n = size (x, 1); x = x - repmat (mean (x), n, 1); sx = std (x, 1); sx (sx == 0) = nan; if nargin < 2, y = x; sy = sx; else assert (size (y, 1) == n); y = y - repmat (mean (y), n, 1); sy = std (y, 1) sy (sy == 0) = nan; end % Special case, scalar is always 100% correlated with itself if isscalar (x) if isa (x, 'single') && isa (y, 'single') c = single (1.0); else c = 1.0; end return; end c = x' * y; s = sx' * sy; c = c ./ (n * s); end % function corr %!test %! x = rand (10); %! cc1 = corr (x); %! cc2 = corr (x, x); %! assert (isequal (size (cc1), [10, 10])) %! assert (isequal (size (cc2), [10, 10])) %! assert (stk_isequal_tolabs (cc1, cc2, sqrt (eps))) %!test %! x = [1:3]'; %! y = [3:-1:1]'; %! assert (stk_isequal_tolabs (corr (x, y), -1, 5*eps)); %! assert (stk_isequal_tolabs (corr (x, flipud (y)), 1, 5*eps)); %! assert (stk_isequal_tolabs (corr ([x, y]), [1 -1; -1 1], 5*eps)); %!test %! x = single ([1:3]'); %! y = single ([3:-1:1]'); %! assert (stk_isequal_tolabs (corr (x, y), single (-1), 5*eps)); %! assert (stk_isequal_tolabs (corr (x, flipud (y)), single (1), 5*eps)); %! assert (stk_isequal_tolabs (corr ([x, y]), single ([1 -1; -1 1]), 5*eps)); %!assert (stk_isequal_tolabs (corr (5), 1)) %!assert (stk_isequal_tolabs (corr (single (5)), single (1))) %% Test input validation %!error corr () %!error corr (1, 2, 3) %!error corr ([1; 2], ["A", "B"]) %!error corr (ones (2,2,2)) %!error corr (ones (2,2), ones (2,2,2)) stk/inst/misc/mole/isrow/0000775000175000017500000000000012617165720014313 5ustar bectbectstk/inst/misc/mole/isrow/isrow.m0000664000175000017500000000210612617165720015633 0ustar bectbect% ISROW returns true for row vectors and false otherwise % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function b = isrow (x) n = length (x); b = isequal (size (x), [1 n]); end % function isrow stk/inst/misc/mole/quantile/0000775000175000017500000000000012617165720014772 5ustar bectbectstk/inst/misc/mole/quantile/quantile.m0000664000175000017500000003710312617165720016776 0ustar bectbect% QUANTILE ... % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % % The function comes from Octave 3.7.6+'s quantile.m, with minor % modifications. The original copyright notice was: % % Copyright (C) 2008-2012 Ben Abbott and Jaroslav Hajek % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . % ## Copyright (C) 2008-2012 Ben Abbott and Jaroslav Hajek % ## % ## This file is part of Octave. % ## % ## Octave is free software; you can redistribute it and/or modify it % ## under the terms of the GNU General Public License as published by % ## the Free Software Foundation; either version 3 of the License, or (at % ## your option) any later version. % ## % ## Octave 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 Octave; see the file COPYING. If not, see % ## . % % ## -*- texinfo -*- % ## @deftypefn {Function File} {@var{q} =} quantile (@var{x}) % ## @deftypefnx {Function File} {@var{q} =} quantile (@var{x}, @var{p}) % ## @deftypefnx {Function File} {@var{q} =} quantile (@var{x}, @var{p}, @var{dim}) % ## @deftypefnx {Function File} {@var{q} =} quantile (@var{x}, @var{p}, @var{dim}, @var{method}) % ## For a sample, @var{x}, calculate the quantiles, @var{q}, corresponding to % ## the cumulative probability values in @var{p}. All non-numeric values (NaNs) % ## of @var{x} are ignored. % ## % ## If @var{x} is a matrix, compute the quantiles for each column and % ## return them in a matrix, such that the i-th row of @var{q} contains % ## the @var{p}(i)th quantiles of each column of @var{x}. % ## % ## If @var{p} is unspecified, return the quantiles for % ## @code{[0.00 0.25 0.50 0.75 1.00]}. % ## The optional argument @var{dim} determines the dimension along which % ## the quantiles are calculated. If @var{dim} is omitted, and @var{x} is % ## a vector or matrix, it defaults to 1 (column-wise quantiles). If % ## @var{x} is an N-D array, @var{dim} defaults to the first non-singleton % ## dimension. % ## % ## The methods available to calculate sample quantiles are the nine methods % ## used by R (@url{http://www.r-project.org/}). The default value is % ## @w{METHOD = 5}. % ## % ## Discontinuous sample quantile methods 1, 2, and 3 % ## % ## @enumerate 1 % ## @item Method 1: Inverse of empirical distribution function. % ## % ## @item Method 2: Similar to method 1 but with averaging at discontinuities. % ## % ## @item Method 3: SAS definition: nearest even order statistic. % ## @end enumerate % ## % ## Continuous sample quantile methods 4 through 9, where p(k) is the linear % ## interpolation function respecting each methods' representative cdf. % ## % ## @enumerate 4 % ## @item Method 4: p(k) = k / n. That is, linear interpolation of the % ## empirical cdf. % ## % ## @item Method 5: p(k) = (k - 0.5) / n. That is a piecewise linear function % ## where the knots are the values midway through the steps of the empirical % ## cdf. % ## % ## @item Method 6: p(k) = k / (n + 1). % ## % ## @item Method 7: p(k) = (k - 1) / (n - 1). % ## % ## @item Method 8: p(k) = (k - 1/3) / (n + 1/3). The resulting quantile % ## estimates are approximately median-unbiased regardless of the distribution % ## of @var{x}. % ## % ## @item Method 9: p(k) = (k - 3/8) / (n + 1/4). The resulting quantile % ## estimates are approximately unbiased for the expected order statistics if % ## @var{x} is normally distributed. % ## @end enumerate % ## % ## Hyndman and Fan (1996) recommend method 8. Maxima, S, and R % ## (versions prior to 2.0.0) use 7 as their default. Minitab and SPSS % ## use method 6. @sc{matlab} uses method 5. % ## % ## References: % ## % ## @itemize @bullet % ## @item Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New % ## S Language. Wadsworth & Brooks/Cole. % ## % ## @item Hyndman, R. J. and Fan, Y. (1996) Sample quantiles in % ## statistical packages, American Statistician, 50, 361--365. % ## % ## @item R: A Language and Environment for Statistical Computing; % ## @url{http://cran.r-project.org/doc/manuals/fullrefman.pdf}. % ## @end itemize % ## % ## Examples: % ## @c Set example in small font to prevent overfull line % ## % ## @smallexample % ## @group % ## x = randi (1000, [10, 1]); # Create empirical data in range 1-1000 % ## q = quantile (x, [0, 1]); # Return minimum, maximum of distribution % ## q = quantile (x, [0.25 0.5 0.75]); # Return quartiles of distribution % ## @end group % ## @end smallexample % ## @seealso{prctile} % ## @end deftypefn % % ## Author: Ben Abbott % ## Description: Matlab style quantile function of a discrete/continuous distribution function q = quantile (x, p, dim, method) if nargin < 2, p = []; end if nargin < 3, dim = 1; end if nargin < 4, % Use Matlab compatiblity mode method = 5; end if (~ (isnumeric (x) || islogical (x))) error ('quantile: X must be a numeric vector or matrix'); end if (isempty (p)) p = [0.00 0.25, 0.50, 0.75, 1.00]; end if (~ (isnumeric (p) && isvector (p))) error ('quantile: P must be a numeric vector'); end if (~ (isscalar (dim) && dim == fix (dim)) ... || ~(1 <= dim && dim <= ndims (x))) error ('quantile: DIM must be an integer and a valid dimension'); end % Set the permutation vector. perm = 1:ndims (x); perm(1) = dim; perm(dim) = 1; % Permute dim to the 1st index. x = permute (x, perm); % Save the size of the permuted x N-d array. sx = size (x); % Reshape to a 2-d array. x = reshape (x, [sx(1), prod(sx(2:end))]); % Calculate the quantiles. q = octave__quantile__ (x, p, method); % Return the shape to the original N-d array. q = reshape (q, [numel(p), sx(2:end)]); % Permute the 1st index back to dim. q = ipermute (q, perm); end % function quantile %!test %! p = 0.5; %! x = sort (rand (11)); %! q = quantile (x, p); %! assert (isequal (q, x(6,:))); %! x = x.'; %! q = quantile (x, p, 2); %! assert (isequal (q, x(:,6))); % Note: method 3 not available yet because Matlab doesn't have roundb() %!test %! p = [0.00, 0.25, 0.50, 0.75, 1.00]; %! x = [1; 2; 3; 4]; %! a = [1.0000 1.0000 2.0000 3.0000 4.0000 %! 1.0000 1.5000 2.5000 3.5000 4.0000 %! 1.0000 1.0000 2.0000 3.0000 4.0000 %! 1.0000 1.0000 2.0000 3.0000 4.0000 %! 1.0000 1.5000 2.5000 3.5000 4.0000 %! 1.0000 1.2500 2.5000 3.7500 4.0000 %! 1.0000 1.7500 2.5000 3.2500 4.0000 %! 1.0000 1.4167 2.5000 3.5833 4.0000 %! 1.0000 1.4375 2.5000 3.5625 4.0000]; %! for m = [1:2 4:9] %! q = quantile (x, p, 1, m).'; %! assert (stk_isequal_tolabs (q, a(m,:), 0.0001)); %! end %!test %! p = [0.00, 0.25, 0.50, 0.75, 1.00]; %! x = [1; 2; 3; 4; 5]; %! a = [1.0000 2.0000 3.0000 4.0000 5.0000 %! 1.0000 2.0000 3.0000 4.0000 5.0000 %! 1.0000 1.0000 2.0000 4.0000 5.0000 %! 1.0000 1.2500 2.5000 3.7500 5.0000 %! 1.0000 1.7500 3.0000 4.2500 5.0000 %! 1.0000 1.5000 3.0000 4.5000 5.0000 %! 1.0000 2.0000 3.0000 4.0000 5.0000 %! 1.0000 1.6667 3.0000 4.3333 5.0000 %! 1.0000 1.6875 3.0000 4.3125 5.0000]; %! for m = [1:2 4:9] %! q = quantile (x, p, 1, m).'; %! assert (stk_isequal_tolabs (q, a(m,:), 0.0001)); %! end %!test %! p = [0.00, 0.25, 0.50, 0.75, 1.00]; %! x = [1; 2; 5; 9]; %! a = [1.0000 1.0000 2.0000 5.0000 9.0000 %! 1.0000 1.5000 3.5000 7.0000 9.0000 %! 1.0000 1.0000 2.0000 5.0000 9.0000 %! 1.0000 1.0000 2.0000 5.0000 9.0000 %! 1.0000 1.5000 3.5000 7.0000 9.0000 %! 1.0000 1.2500 3.5000 8.0000 9.0000 %! 1.0000 1.7500 3.5000 6.0000 9.0000 %! 1.0000 1.4167 3.5000 7.3333 9.0000 %! 1.0000 1.4375 3.5000 7.2500 9.0000]; %! for m = [1:2 4:9] %! q = quantile (x, p, 1, m).'; %! assert (stk_isequal_tolabs (q, a(m,:), 0.0001)); %! end %!test %! p = [0.00, 0.25, 0.50, 0.75, 1.00]; %! x = [1; 2; 5; 9; 11]; %! a = [1.0000 2.0000 5.0000 9.0000 11.0000 %! 1.0000 2.0000 5.0000 9.0000 11.0000 %! 1.0000 1.0000 2.0000 9.0000 11.0000 %! 1.0000 1.2500 3.5000 8.0000 11.0000 %! 1.0000 1.7500 5.0000 9.5000 11.0000 %! 1.0000 1.5000 5.0000 10.0000 11.0000 %! 1.0000 2.0000 5.0000 9.0000 11.0000 %! 1.0000 1.6667 5.0000 9.6667 11.0000 %! 1.0000 1.6875 5.0000 9.6250 11.0000]; %! for m = [1:2 4:9] %! q = quantile (x, p, 1, m).'; %! assert (stk_isequal_tolabs (q, a(m,:), 0.0001)); %! end %!test %! p = [0.00, 0.25, 0.50, 0.75, 1.00]; %! x = [16; 11; 15; 12; 15; 8; 11; 12; 6; 10]; %! a = [6.0000 10.0000 11.0000 15.0000 16.0000 %! 6.0000 10.0000 11.5000 15.0000 16.0000 %! 6.0000 8.0000 11.0000 15.0000 16.0000 %! 6.0000 9.0000 11.0000 13.5000 16.0000 %! 6.0000 10.0000 11.5000 15.0000 16.0000 %! 6.0000 9.5000 11.5000 15.0000 16.0000 %! 6.0000 10.2500 11.5000 14.2500 16.0000 %! 6.0000 9.8333 11.5000 15.0000 16.0000 %! 6.0000 9.8750 11.5000 15.0000 16.0000]; %! for m = [1:2 4:9] %! q = quantile (x, p, 1, m).'; %! assert (stk_isequal_tolabs (q, a(m,:), 0.0001)); %! end %!test %! p = [0.00, 0.25, 0.50, 0.75, 1.00]; %! x = [-0.58851; 0.40048; 0.49527; -2.551500; -0.52057; ... %! -0.17841; 0.057322; -0.62523; 0.042906; 0.12337]; %! a = [-2.551474 -0.588505 -0.178409 0.123366 0.495271 %! -2.551474 -0.588505 -0.067751 0.123366 0.495271 %! -2.551474 -0.625231 -0.178409 0.123366 0.495271 %! -2.551474 -0.606868 -0.178409 0.090344 0.495271 %! -2.551474 -0.588505 -0.067751 0.123366 0.495271 %! -2.551474 -0.597687 -0.067751 0.192645 0.495271 %! -2.551474 -0.571522 -0.067751 0.106855 0.495271 %! -2.551474 -0.591566 -0.067751 0.146459 0.495271 %! -2.551474 -0.590801 -0.067751 0.140686 0.495271]; %! for m = [1:2 4:9] %! q = quantile (x, p, 1, m).'; %! assert (stk_isequal_tolabs (q, a(m,:), 0.0001)); %! end %!test %! p = 0.5; %! x = [0.112600, 0.114800, 0.052100, 0.236400, 0.139300 %! 0.171800, 0.727300, 0.204100, 0.453100, 0.158500 %! 0.279500, 0.797800, 0.329600, 0.556700, 0.730700 %! 0.428800, 0.875300, 0.647700, 0.628700, 0.816500 %! 0.933100, 0.931200, 0.963500, 0.779600, 0.846100]; %! tol = 0.00001; %! x(5,5) = NaN; %! assert (stk_isequal_tolabs ... %! (quantile (x, p, 1), ... %! [0.27950, 0.79780, 0.32960, 0.55670, 0.44460], tol)); %! x(1,1) = NaN; %! assert (stk_isequal_tolabs ... %! (quantile (x, p, 1), ... %! [0.35415, 0.79780, 0.32960, 0.55670, 0.44460], tol)); %! x(3,3) = NaN; %! assert (stk_isequal_tolabs ... %! (quantile (x, p, 1), ... %! [0.35415, 0.79780, 0.42590, 0.55670, 0.44460], tol)); %!test %! sx = [2, 3, 4]; %! x = rand (sx); %! dim = 2; %! p = 0.5; %! yobs = quantile (x, p, dim); %! yexp = median (x, dim); %! assert (isequal (yobs, yexp)); %% Test input validation %!error quantile () %!error quantile (1, 2, 3, 4, 5) %!error quantile (['A'; 'B'], 10) % %!error quantile (1:10, [true, false]) % % this test fails in Octave 3.2.x %!error quantile (1:10, ones (2,2)) %!error quantile (1, 1, 1.5) %!error quantile (1, 1, 0) %!error quantile (1, 1, 3) %!error quantile ((1:5)', 0.5, 1, 0) %!error quantile ((1:5)', 0.5, 1, 10) % ## For the cumulative probability values in @var{p}, compute the % ## quantiles, @var{q} (the inverse of the cdf), for the sample, @var{x}. % ## % ## The optional input, @var{method}, refers to nine methods available in R % ## (http://www.r-project.org/). The default is @var{method} = 7. % ## @seealso{prctile, quantile, statistics} % % ## Author: Ben Abbott % ## Vectorized version: Jaroslav Hajek % ## Description: Quantile function of empirical samples function inv = octave__quantile__ (x, p, method) if (isinteger (x) || islogical (x)) x = double (x); end % set shape of quantiles to column vector. p = p(:); % Save length and set shape of samples. % FIXME: does sort guarantee that NaN's come at the end? x = sort (x); m = sum (~ isnan (x)); [xr, xc] = size (x); % Initialize output values. inv = Inf (class (x)) * (-(p < 0) + (p > 1)); inv = repmat (inv, 1, xc); % Do the work. k = find ((p >= 0) & (p <= 1)); if (any (k)) n = length (k); p = p(k); % Special case of 1 row. if (xr == 1) inv(k,:) = repmat (x, n, 1); return; end % The column-distribution indices. pcd = kron (ones (n, 1), xr*(0:xc-1)); mm = kron (ones (n, 1), m); switch (method) case {1, 2, 3} switch (method) case 1 p = max (ceil (kron (p, m)), 1); inv(k,:) = x(p + pcd); case 2 p = kron (p, m); p_lr = max (ceil (p), 1); p_rl = min (floor (p + 1), mm); inv(k,:) = (x(p_lr + pcd) + x(p_rl + pcd))/2; case 3 % Used by SAS, method PCTLDEF=2. % http://support.sas.com/onlinedoc/913/getDoc/en/statug.hlp/stdize_sect14.htm t = max (kron (p, m), 1); t = roundb (t); inv(k,:) = x(t + pcd); end otherwise switch (method) case 4 p = kron (p, m); case 5 % Used by Matlab. p = kron (p, m) + 0.5; case 6 % Used by Minitab and SPSS. p = kron (p, m+1); case 7 % Used by S and R. p = kron (p, m-1) + 1; case 8 % Median unbiased. p = kron (p, m+1/3) + 1/3; case 9 % Approximately unbiased respecting order statistics. p = kron (p, m+0.25) + 0.375; otherwise error ('quantile: Unknown METHOD, ''%d''', method); end % Duplicate single values. imm1 = (mm == 1); x(2,imm1) = x(1,imm1); % Interval indices. pi = max (min (floor (p), mm-1), 1); pr = max (min (p - pi, 1), 0); pi = pi + pcd; inv(k,:) = (1-pr) .* x(pi) + pr .* x(pi+1); end end end % function octave__quantile__ stk/inst/misc/mole/graphics_toolkit/0000775000175000017500000000000012617165720016515 5ustar bectbectstk/inst/misc/mole/graphics_toolkit/graphics_toolkit.m0000664000175000017500000000407112617165720022242 0ustar bectbect% GRAPHICS_TOOLKIT indicates which toolkit is assigned to new figures. % % This is a (partial) replacement for the graphics_toolkit function that is missing both % from Matlab and from some old version f Octave. % % CALL: NAME = graphics_toolkit () % % returns: % % * the result of get (0, 'defaultfigure__backend__') if you're running an old version % of Octave that does not have graphics_toolkit, % % * 'matlab-nojvm' if running Matlab without the Java Virtual Machine, % % * 'matlab-jvm' if running Matlab with the Java Virtual Machine. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function name = graphics_toolkit () if isoctave, try % This should work on older versions of Octave, e.g., 3.2.4 % (there was no notion of a 'toolkit' at the time, but if gnuplot % is reported as the backend, then it is also the toolkit) name = get (0, 'defaultfigure__backend__'); catch error ('Unable to determine which toolkit is being used.'); end else % Matlab try assert (usejava ('jvm')); name = 'matlab-jvm'; catch name = 'matlab-nojvm'; end end end % function graphics_toolkit %#ok<*CTCH> stk/inst/misc/distrib/0000775000175000017500000000000012617165720013654 5ustar bectbectstk/inst/misc/distrib/stk_distrib_normal_cdf.m0000664000175000017500000000643712617165720020551 0ustar bectbect% STK_DISTRIB_NORMAL_CDF [STK internal] % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [p, q] = stk_distrib_normal_cdf (z, mu, sigma) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin > 1, z = bsxfun (@minus, z, mu); end if nargin < 3, sigma = 1; end if isscalar (sigma) if sigma > 0 z = z / sigma; k0 = false; k1 = true; elseif sigma == 0 k0 = true; k1 = false; else k0 = false; k1 = false; end else if ~ isequal (size (z), size (sigma)) [z, sigma] = stk_commonsize (z, sigma); end k0 = (sigma == 0); k1 = (sigma > 0); z(k1) = z(k1) ./ sigma(k1); end p = nan (size (z)); q = nan (size (z)); kp = (z >= 0); kz = ~ isnan (z); if any (k1) % sigma > 0 k1 = bsxfun (@and, k1, kz); k1n = k1 & (~ kp); k1p = k1 & kp; % Deal with positive values of x: compute q first, then p = 1 - q q_k1p = 0.5 * erfc (0.707106781186547524 * z(k1p)); q(k1p) = q_k1p; p(k1p) = 1 - q_k1p; % Deal with negative values of x: compute p first, then q = 1 - p p_k1n = 0.5 * erfc (- 0.707106781186547524 * z(k1n)); p(k1n) = p_k1n; q(k1n) = 1 - p_k1n; end if any (k0) % sigma == 0 k0 = bsxfun (@and, k0, kz); p_k0 = double (kp(k0)); p(k0) = p_k0; q(k0) = 1 - p_k0; end end % function stk_distrib_normal_cdf %!assert (stk_isequal_tolrel (stk_distrib_normal_cdf ([1; 3], 1, [1 10]), ... %! [0.5, ... % normcdf ((1 - 1) / 1) %! 0.5; ... % normcdf ((1 - 1) / 10) %! 0.5 * erfc(-sqrt(2)), ... % normcdf ((3 - 1) / 1) %! 0.5 * erfc(-0.1*sqrt(2)) ... % normcdf ((3 - 1) / 10) %! ], eps)); %!test %! [p, q] = stk_distrib_normal_cdf (10); %! assert (isequal (p, 1.0)); %! assert (stk_isequal_tolrel (q, 7.6198530241604975e-24, eps)); %!assert (isequal (stk_distrib_normal_cdf ( 0.0), 0.5)); %!assert (isequal (stk_distrib_normal_cdf ( inf), 1.0)); %!assert (isequal (stk_distrib_normal_cdf (-inf), 0.0)); %!assert (isnan (stk_distrib_normal_cdf ( nan))); %!assert (isnan (stk_distrib_normal_cdf (0, 0, -1))); %!assert (isequal (stk_distrib_normal_cdf (0, 0, 0), 1.0)); %!assert (isequal (stk_distrib_normal_cdf (0, 1, 0), 0.0)); %!assert (isequal (stk_distrib_normal_cdf (1, 0, 0), 1.0)); stk/inst/misc/distrib/stk_distrib_normal_pdf.m0000664000175000017500000000447112617165720020562 0ustar bectbect% STK_DISTRIB_NORMAL_PDF [STK internal] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function density = stk_distrib_normal_pdf (z, mu, sigma) if nargin > 3, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin > 1, z = bsxfun (@minus, z, mu); end if nargin > 2, [z, sigma] = stk_commonsize (z, sigma); z = z ./ sigma; k0 = (sigma > 0); else sigma = 1; k0 = 1; end xx = z .^ 2; density = nan (size (z)); k0 = k0 & (~ isnan (z)); kb = (xx > 1491); % when x^2 > 1491, the result is 0 in double precision % Deal with "large" values of abs(x) k = k0 & kb; density(k) = 0; % Deal with "small" values of abs(x) k = k0 & (~ kb); density(k) = 0.39894228040143268 * exp (- 0.5 * xx(k)); density = bsxfun (@rdivide, density, sigma); end % function stk_distrib_normal_pdf %!assert (stk_isequal_tolrel (stk_distrib_normal_pdf ([1; 3], 1, [1 10]), ... %! [1 / sqrt(2 * pi) ... % normpdf ((1 - 1) / 1) %! 0.1 / sqrt(2 * pi); ... % normpdf ((1 - 1) / 10) / 10 %! exp(-2) / sqrt(2 * pi) ... % normpdf ((3 - 1) / 1) %! 3.910426939754558780e-2 ... % normpdf ((3 - 1) / 10) / 10 %! ], eps)); %!assert (isequal (stk_distrib_normal_pdf (inf), 0.0)); %!assert (isequal (stk_distrib_normal_pdf (-inf), 0.0)); %!assert (isnan (stk_distrib_normal_pdf (nan))); %!assert (isnan (stk_distrib_normal_pdf (0, 0, -1))); stk/inst/misc/distrib/stk_distrib_student_cdf.m0000664000175000017500000000637612617165720020751 0ustar bectbect% STK_DISTRIB_STUDENT_CDF [STK internal] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % % This code is very loosely based on Octave's tcdf function: % ## Copyright (C) 2013 Julien Bect % ## Copyright (C) 2012 Rik Wehbring % ## Copyright (C) 1995-2012 Kurt Hornik % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [p, q] = stk_distrib_student_cdf (z, nu, mu, sigma) if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin > 2, z = bsxfun (@minus, z, mu); end if nargin > 3, z = bsxfun (@rdivide, z, sigma); end xx = z .^ 2; [z, xx, nu] = stk_commonsize (z, xx, nu); % Return NaN for negative values of nu (or nu == NaN, or x == NaN) p = nan (size (z)); q = nan (size (z)); k0 = (nu > 0) & (~ isnan (z)); % Gaussian case (nu = +inf) k_inf = isinf (nu); k = k0 & k_inf; [p(k), q(k)] = stk_distrib_normal_cdf (z(k)); k0 = k0 & (~ k_inf); kp = (z > 0); kn = k0 & (~ kp); kp = k0 & kp; k_big_abs = (xx > nu); % Student case (nu < +inf) for positive x: compute q first, then p = 1 - q k = kp & k_big_abs; q(k) = betainc (nu(k) ./ (nu(k) + xx(k)), nu(k)/2, 1/2) / 2; k = kp & (~ k_big_abs); q(k) = 0.5 * (1 - betainc (xx(k) ./ (nu(k) + xx(k)), 1/2, nu(k)/2)); p(kp) = 1 - q(kp); % Student case (nu < +inf) for negative x: compute p first, then q = 1 - p k = kn & k_big_abs; p(k) = betainc (nu(k) ./ (nu(k) + xx(k)), nu(k)/2, 1/2) / 2; k = kn & (~ k_big_abs); p(k) = 0.5 * (1 - betainc (xx(k) ./ (nu(k) + xx(k)), 1/2, nu(k)/2)); q(kn) = 1 - p(kn); end % function stk_distrib_student_cdf %!assert (stk_isequal_tolrel ( ... %! stk_distrib_student_cdf ([-1; 0; 1], [1 2], 0, [1 10]), ... %! [0.25, ... % tcdf ((-1 - 0)/1, 1) %! 4.6473271920707004e-01; ... % tcdf ((-1 - 0)/10, 2) %! 0.50, ... % tcdf (( 0 - 0)/1, 1) %! 0.50; ... % tcdf (( 0 - 0)/10, 2) %! 0.75, ... % tcdf (( 1 - 0)/1, 1) %! 5.3526728079292996e-01 ... % tcdf (( 1 - 0)/10, 2) %! ], 4 * eps)) %!test %! [p, q] = stk_distrib_student_cdf (1e10, 2); %! assert (isequal (p, 1.0)); %! assert (stk_isequal_tolrel (q, 4.999999999999999999925e-21, 10 * eps)); %!assert (isequal (stk_distrib_student_cdf (0.0, 1), 0.5)); %!assert (isequal (stk_distrib_student_cdf (inf, 1), 1.0)); %!assert (isequal (stk_distrib_student_cdf (-inf, 1), 0.0)); %!assert (isnan (stk_distrib_student_cdf (nan, 1))); stk/inst/misc/distrib/stk_distrib_student_ei.m0000664000175000017500000001010112617165720020567 0ustar bectbect% STK_DISTRIB_STUDENT_EI computes the Student expected improvement % % CALL: EI = stk_distrib_student_ei (Z, NU) % % computes the expected improvement of a Student random variable with NU % degrees of freedom above the threshold Z. % % CALL: EI = stk_distrib_student_ei (Z, NU, MU, SIGMA) % % computes the expected improvement of a Student random variable with NU % degrees of freedom, location parameter MU and scale parameter SIGMA, % above the threshold Z. % % CALL: EI = stk_distrib_student_ei (Z, NU, MU, SIGMA, MINIMIZE) % % computes the expected improvement of a Student random variable with NU % degrees of freedom, location parameter MU and scale parameter SIGMA, % below the threshold Z if MINIMIZE is true, above the threshold Z % otherwise. % % REFERENCES % % [1] R. Benassi, J. Bect and E. Vazquez. Robust Gaussian process-based % global optimization using a fully Bayesian expected improvement % criterion. In: Learning and Intelligent Optimization (LION 5), % LNCS 6683, pp. 176-190, Springer, 2011 % % [2] B. Williams, T. Santner and W. Notz. Sequential Design of Computer % Experiments to Minimize Integrated Response Functions. Statistica % Sinica, 10(4):1133-1152, 2000. % % See also stk_distrib_normal_ei % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Romain Benassi % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function ei = stk_distrib_student_ei (z, nu, mu, sigma, minimize) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end nu(nu < 0) = nan; if nargin > 2, delta = bsxfun (@minus, mu, z); else % Default: mu = 0; delta = - z; end if nargin > 3, sigma(sigma < 0) = nan; else % Default sigma = 1; end % Default: compute the EI for a maximization problem if nargin > 4, minimize = logical (minimize); else minimize = false; end % Reduce to the maximization case if minimize, delta = - delta; end [delta, nu, sigma] = stk_commonsize (delta, nu, sigma); ei = nan (size (delta)); b0 = ~ (isnan (delta) | isnan (nu) | isnan (sigma)); b1 = (nu > 1); b2 = (sigma > 0); % The EI is infinite for nu <= 1 ei(b0 & (~ b1)) = +inf; b0 = b0 & b1; % Compute the EI where nu > 1 and sigma > 0 b = b0 & b2; if any (b) u = delta(b) ./ sigma(b); nu = nu(b); ei(b) = sigma(b) .* ((nu + u .^ 2) ./ (nu - 1) ... .* stk_distrib_student_pdf (u, nu) ... + u .* stk_distrib_student_cdf (u, nu)); end % Compute the EI where nu > 1 and sigma == 0 b = b0 & (~ b2); ei(b) = max (0, delta(b)); % Correct numerical inaccuracies ei(ei < 0) = 0; end % function stk_distrib_student_ei %!assert (stk_isequal_tolrel (stk_distrib_student_ei (0, 2), 1 / sqrt (2), eps)) %!test % Decreasing as a function of z %! ei = stk_distrib_student_ei (linspace (-10, 10, 200), 3.33); %! assert (all (diff (ei) < 0)) %!shared M, mu, sigma, ei, nu %! M = randn (1, 10); %! mu = randn (5, 1); %! sigma = 1 + rand (1, 1, 7); %! nu = 2; %! ei = stk_distrib_student_ei (M, nu, mu, sigma); %!assert (isequal (size (ei), [5, 10, 7])) %!assert (all (ei(:) >= 0)) %!assert (isequal (ei, stk_distrib_student_ei (M, nu, mu, sigma, false))); %!assert (isequal (ei, stk_distrib_student_ei (-M, nu, -mu, sigma, true))); stk/inst/misc/distrib/stk_distrib_student_pdf.m0000664000175000017500000000534312617165720020757 0ustar bectbect% STK_DISTRIB_STUDENT_PDF [STK internal] % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % % This code is very loosely based on Octave's tpdf function: % ## Copyright (C) 2012 Rik Wehbring % ## Copyright (C) 1995-2012 Kurt Hornik % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function density = stk_distrib_student_pdf (z, nu, mu, sigma) if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin > 2, z = bsxfun (@minus, z, mu); end if nargin > 3, z = bsxfun (@rdivide, z, sigma); else sigma = 1; end C = sqrt (nu) .* beta (nu / 2, 0.5); if isscalar (nu) if nu == +inf % Gaussian case (nu = +inf) density = 0.39894228040143268 * exp (- 0.5 * (z .^ 2)); else % Student case (nu < +inf) density = exp (- 0.5 * (nu + 1) * log (1 + z .^ 2 / nu)) / C; end else [z, nu, C] = stk_commonsize (z, nu, C); density = nan (size (z)); % Gaussian case (nu = +inf) k = (nu == +inf); density(k) = 0.39894228040143268 * exp (- 0.5 * (z(k) .^ 2)); % Student case (nu < +inf) k = (nu > 0); nu = nu(k); density(k) = exp (- 0.5 * (nu + 1) .* log (1 + z(k) .^ 2 ./ nu)) ./ C(k); end density = bsxfun (@rdivide, density, sigma); end % function stk_distrib_student_pdf %!assert (stk_isequal_tolrel ( ... %! stk_distrib_student_pdf ([1; 3], [1; 2], [0 1], [1 10]), ... %! [0.50 / pi ... % tpdf ((1 - 1) / 10, 1) %! 0.10 / pi; ... % tpdf ((1 - 1) / 10, 1) / 10 %! 1 / (11 * sqrt(11)) ... % tpdf ((3 - 0) / 1, 2) / 1 %! 3.4320590294804165e-02 ... % tpdf ((3 - 1) / 10, 2) / 10 %! ], eps)); %!assert (isequal (stk_distrib_student_pdf ( inf, 1.0), 0.0)); %!assert (isequal (stk_distrib_student_pdf (-inf, 1.0), 0.0)); %!assert (isnan (stk_distrib_student_pdf ( nan, 1.0))); stk/inst/misc/distrib/stk_distrib_bivnorm_cdf.m0000664000175000017500000001260112617165720020723 0ustar bectbect% STK_DISTRIB_BIVNORM_CDF [STK internal] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function [p, q] = stk_distrib_bivnorm_cdf (z, mu1, mu2, sigma1, sigma2, rho) if nargin > 6, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end %--- Split z into [z1, z2] ----------------------------------------------------- s = size (z); if s(end) ~= 2 stk_error (['Incorrect size: expecting an array with length 2 ' ... 'on its last dimension.'], 'IncorrectSize'); end S = struct ('type', '()', 'subs', {repmat({':'}, size(s))}); S.subs{end} = 1; z1 = subsref (z, S); S.subs{end} = 2; z2 = subsref (z, S); %--- Substract the means ------------------------------------------------------- if ~ isequal (mu1, 0) z1 = bsxfun (@minus, z1, mu1); end if ~ isequal (mu2, 0) z2 = bsxfun (@minus, z2, mu2); end %--- Bring everything to a common size ----------------------------------------- if ~ isequal (size (z1), size (z2), size (sigma1), size (sigma2), size (rho)) [z1, z2, sigma1, sigma2, rho] = stk_commonsize ... (z1, z2, sigma1, sigma2, rho); end p = nan (size (z1)); q = nan (size (z1)); %--- Deal with special cases --------------------------------------------------- b1 = (sigma1 == 0.0); if any (b1) % First component is zero a.s. [p(b1) q(b1)] = handle_singular_case (b1, z1, z2, sigma2); end b2 = (~ b1) & (sigma2 == 0.0); if any (b2) % Second component is zero a.s. [p(b2) q(b2)] = handle_singular_case (b2, z2, z1, sigma1); end %--- Deal with the general case ------------------------------------------------ b0 = ~ (b1 | b2); if any (b0) z1 = z1(b0) ./ sigma1(b0); z2 = z2(b0) ./ sigma2(b0); [p(b0), q(b0)] = __stk_distrib_bivnorm0_cdf__ ([z1 z2], rho(b0)); end end % function stk_distrib_bivnorm_cdf function [p q] = handle_singular_case (b1, z1, z2, sigma2) z1_ = z1(b1); z2_ = z2(b1); sigma2_ = sigma2(b1); % Values for the case z1 < 0 s = size (z1_); p = zeros (s); q = ones (s); b1p = (z1_ >= 0); if any (b1p) [p(b1p) q(b1p)] = stk_distrib_normal_cdf (z2_(b1p), 0, sigma2_(b1p)); end end % function handle_singular_case %!test %! %! z1 = [0 1; -1 2]; %! z2 = [0 1; 1 -2]; %! %! z = cat (3, z1, z2); % 2 x 2 x 2 %! %! mu1 = 0; % 1 x 1 x 1 %! mu2 = [0 1]; % 1 x 2 x 1 %! %! sigma1 = [1 3]; % 1 x 2 x 1 %! sigma2 = [1; 2]; % 2 x 1 x 1 %! %! rho = [0; 0.5]; % 2 x 1 x 1 %! %! %% BROADCASTING => the result will be a 2 x 2 matrix %! %! p = stk_distrib_bivnorm_cdf (z, mu1, mu2, sigma1, sigma2, rho); %! %! p11 = 0.25; % mvncdf ([ 0 0], [0 0], [1 0; 0 1]); %! p12 = 0.315279329909118; % mvncdf ([ 1 1], [0 1], [9 0; 0 1]); %! p21 = 0.146208349559646; % mvncdf ([-1 1], [0 0], [1 1; 1 4]); %! p22 = 0.064656239880040; % mvncdf ([ 2 -2], [0 1], [9 3; 3 4]); %! %! assert (stk_isequal_tolabs (p, [p11 p12; p21 p22], 1e-14)) %%% [p, q] = stk_distrib_bivnorm_cdf ([inf z], 0, 0, 1, 1, 0) with various z's %!test %! [p, q] = stk_distrib_bivnorm_cdf ([inf -inf], 0, 0, 1, 1, 0); %! assert ((p == 0.0) && (q == 1.0)) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([inf -10], 0, 0, 1, 1, 0); %! assert (stk_isequal_tolrel (p, 7.619853024160489e-24, 1e-12)) %! assert (q == 1.0) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([inf 0], 0, 0, 1, 1, 0); %! assert (stk_isequal_tolrel (p, 0.5, 1e-12)) %! assert (stk_isequal_tolrel (q, 0.5, 1e-12)) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([inf 10], 0, 0, 1, 1, 0); %! assert (p == 1.0); %! assert (stk_isequal_tolrel (q, 7.619853024160489e-24, 1e-12)) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([inf inf], 0, 0, 1, 1, 0); %! assert ((p == 1.0) && (q == 0.0)) %%% [p, q] = stk_distrib_bivnorm_cdf ([z inf], 0, 0, 1, 1, 0) with various z's %!test %! [p, q] = stk_distrib_bivnorm_cdf ([-inf inf], 0, 0, 1, 1, 0); %! assert ((p == 0.0) && (q == 1.0)) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([-10 inf], 0, 0, 1, 1, 0); %! assert (stk_isequal_tolrel (p, 7.619853024160489e-24, 1e-12)) %! assert (q == 1.0) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([0 inf], 0, 0, 1, 1, 0); %! assert (stk_isequal_tolrel (p, 0.5, 1e-12)) %! assert (stk_isequal_tolrel (q, 0.5, 1e-12)) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([10 inf], 0, 0, 1, 1, 0); %! assert (p == 1.0); %! assert (stk_isequal_tolrel (q, 7.619853024160489e-24, 1e-12)) %!test %! [p, q] = stk_distrib_bivnorm_cdf ([inf inf], 0, 0, 1, 1, 0); %! assert ((p == 1.0) && (q == 0.0)) %!test % A mixture of singular and non-singular cases %! p = stk_distrib_bivnorm_cdf ([0 0], 0, 0, [1; 0], 1, 0); %! assert (isequal (p, [0.25; 0.5])); stk/inst/misc/distrib/stk_distrib_normal_ei.m0000664000175000017500000000742712617165720020412 0ustar bectbect% STK_DISTRIB_NORMAL_EI computes the normal (Gaussian) expected improvement % % CALL: EI = stk_distrib_normal_ei (Z) % % computes the expected improvement of a standard normal (Gaussian) % random variable above the threshold Z. % % CALL: EI = stk_distrib_normal_ei (Z, MU, SIGMA) % % computes the expected improvement of a Gaussian random variable % with mean MU and standard deviation SIGMA, above the threshold Z. % % CALL: EI = stk_distrib_normal_ei (Z, MU, SIGMA, MINIMIZE) % % computes the expected improvement of a Gaussian random variable % with mean MU and standard deviation SIGMA, below the threshold Z % if MINIMIZE is true, above the threshold Z otherwise. % % REFERENCES % % [1] D. R. Jones, M. Schonlau and William J. Welch. Efficient global % optimization of expensive black-box functions. Journal of Global % Optimization, 13(4):455-492, 1998. % % [2] J. Mockus, V. Tiesis and A. Zilinskas. The application of Bayesian % methods for seeking the extremum. In L.C.W. Dixon and G.P. Szego, % editors, Towards Global Optimization, volume 2, pages 117-129, North % Holland, New York, 1978. % % See also stk_distrib_student_ei % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Romain Benassi % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function ei = stk_distrib_normal_ei (z, mu, sigma, minimize) if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if nargin > 1, delta = bsxfun (@minus, mu, z); else % Default: mu = 0; delta = - z; end if nargin > 2, sigma(sigma < 0) = nan; else % Default: sigma = 1 sigma = 1; end % Default: compute the EI for a maximization problem if nargin > 3, minimize = logical (minimize); else minimize = false; end % Reduce to the maximization case if minimize, delta = - delta; end [delta, sigma] = stk_commonsize (delta, sigma); ei = nan (size (delta)); b0 = ~ (isnan (delta) | isnan (sigma)); b1 = (sigma > 0); % Compute the EI where sigma > 0 b = b0 & b1; if any (b) u = delta(b) ./ sigma(b); ei(b) = sigma(b) .* (stk_distrib_normal_pdf (u) ... + u .* stk_distrib_normal_cdf (u)); end % Compute the EI where sigma == 0 b = b0 & (~ b1); ei(b) = max (0, delta(b)); % Correct numerical inaccuracies ei(ei < 0) = 0; end % function stk_distrib_normal_ei %!assert (stk_isequal_tolrel (stk_distrib_normal_ei (0.0), 1 / sqrt (2 * pi), eps)) %!test % Decreasing as a function of z %! ei = stk_distrib_normal_ei (linspace (-10, 10, 200)); %! assert (all (diff (ei) < 0)) %!shared M, mu, sigma, ei %! M = randn (1, 10); %! mu = randn (5, 1); %! sigma = 1 + rand (1, 1, 7); %! ei = stk_distrib_normal_ei (M, mu, sigma); %!assert (isequal (size (ei), [5, 10, 7])) %!assert (all (ei(:) >= 0)) %!assert (isequal (ei, stk_distrib_normal_ei (M, mu, sigma, false))); %!assert (isequal (ei, stk_distrib_normal_ei (-M, -mu, sigma, true))); stk/inst/misc/parallel/0000775000175000017500000000000012617165720014010 5ustar bectbectstk/inst/misc/parallel/stk_parallel_stop.m0000664000175000017500000000212712617165720017712 0ustar bectbect% STK_PARALLEL_STOP stops the parallelization engine. % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_parallel_stop () stk_parallel_stop (stk_parallel_engine_get ()); end % function stk_parallel_stop stk/inst/misc/parallel/stk_parallel_engine_set.m0000664000175000017500000000270712617165720021051 0ustar bectbect% STK_PARALLEL_ENGINE_SET chooses a parallelization engine. % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function pareng = stk_parallel_engine_set(new_pareng) persistent current_pareng % initialization if isempty(current_pareng) % no parallel engine, to begin with current_pareng = stk_parallel_engine_none(); % lock the mfile in memory to prevent current_pareng from being cleared mlock(); end if nargin > 0, current_pareng = new_pareng; end % Return the current parallel engine pareng = current_pareng; end % function stk_parallel_engine_set stk/inst/misc/parallel/stk_parallel_engine_get.m0000664000175000017500000000215712617165720021034 0ustar bectbect% STK_PARALLEL_ENGINE_GET returns the current parallelization engine. % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function pareng = stk_parallel_engine_get() pareng = stk_parallel_engine_set(); end % function stk_parallel_engine_get stk/inst/misc/parallel/@stk_parallel_engine_none/0000775000175000017500000000000012617165720021131 5ustar bectbectstk/inst/misc/parallel/@stk_parallel_engine_none/stk_parallel_stop.m0000664000175000017500000000207512617165720025035 0ustar bectbect% STK_PARALLEL_STOP [overload STK function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_parallel_stop(eng) %#ok % nothing to do ! end % function stk_parallel_stop stk/inst/misc/parallel/@stk_parallel_engine_none/stk_parallel_feval.m0000664000175000017500000000261612617165720025146 0ustar bectbect% STK_PARALLEL_FEVAL [overload STK function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = stk_parallel_feval(eng, f, x, vectorized, min_block_size) % TODO: remplacer vectorized par max_block_size ? if vectorized % STK-style vectorization supported z = feval(f, x); else % STK-style vectorization not supported => loop over the rows of x n = size(x, 1); z = zeros(n, 1); parfor i = 1:n, z(i) = feval(f, x(i, :)); end end end % function stk_parallel_feval stk/inst/misc/parallel/@stk_parallel_engine_none/stk_parallel_engine_none.m0000664000175000017500000000216012617165720026327 0ustar bectbect% STK_PARALLEL_ENGINE_NONE [overload STK function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function pareng = stk_parallel_engine_none() pareng = class(struct(), 'stk_parallel_engine_none'); end % function stk_parallel_engine_none stk/inst/misc/parallel/stk_parallel_cutblocks.m0000664000175000017500000000326412617165720020721 0ustar bectbect% STK_PARALLEL_CUTBLOCKS [STK internal] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function blocks = stk_parallel_cutblocks(x, ncores, min_block_size) x = double(x); n = size(x, 1); %--- Choose the actual block size & number of blocks ---------------------------- nb_blocks = min(ncores, max(1, floor(n / min_block_size))); block_size = ceil(n / nb_blocks); %--- Cut blocks ----------------------------------------------------------------- ind1 = 1 + ((1:nb_blocks)' - 1) * block_size; ind2 = min(n, ind1 + block_size - 1); % note: the last blocks can be slightly smaller than the others blocks = struct('i', cell(1, nb_blocks), 'j', [], 'xi', [], 'K', []); for b = 1:nb_blocks, blocks(b).i = ind1(b):ind2(b); blocks(b).xi = x(blocks(b).i, :); end end % function stk_parallel_cutblocks stk/inst/misc/parallel/stk_parallel_start.m0000664000175000017500000000273712617165720020071 0ustar bectbect% STK_PARALLEL_START starts the parallelization engine. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function eng = stk_parallel_start () eng = stk_parallel_engine_get (); if strcmp (class (eng), 'stk_parallel_engine_none') %#ok % use Mathworks' PCT if available if (~ isoctave) && (exist ('matlabpool','file')) eng = stk_parallel_engine_parfor (); stk_parallel_engine_set (eng); end else warning (['A parallel computing engine ' ... 'is already started (or so it seems).']); %#ok end end % function stk_parallel_start stk/inst/misc/parallel/@stk_parallel_engine_parfor/0000775000175000017500000000000012617165720021463 5ustar bectbectstk/inst/misc/parallel/@stk_parallel_engine_parfor/stk_parallel_stop.m0000664000175000017500000000231712617165720025366 0ustar bectbect% STK_PARALLEL_STOP [overload STK function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function stk_parallel_stop(eng) %#ok if matlabpool('size') == 0, warning('There was no worker pool open.'); else matlabpool close; end stk_parallel_engine_set(stk_parallel_engine_none()); end % function stk_parallel_stop stk/inst/misc/parallel/@stk_parallel_engine_parfor/stk_parallel_engine_parfor.m0000664000175000017500000000234112617165720027214 0ustar bectbect% STK_PARALLEL_ENGINE_PARFOR [overload STK function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function pareng = stk_parallel_engine_parfor() if matlabpool('size') > 0, warning('A worker pool is already open.'); else matlabpool open; end pareng = class(struct(), 'stk_parallel_engine_parfor'); end % function stk_parallel_engine_parfor stk/inst/misc/parallel/@stk_parallel_engine_parfor/stk_parallel_feval.m0000664000175000017500000000323112617165720025472 0ustar bectbect% STK_PARALLEL_FEVAL [overload STK function] % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = stk_parallel_feval(eng, f, x, vectorized, min_block_size) % TODO: remplacer vectorized par max_block_size ? if vectorized % STK-style vectorization supported ncores = max(1, matlabpool('size')); blocks = stk_parallel_cutblocks(x, ncores, min_block_size); nb_blocks = length(blocks); z = cell(nb_blocks, 1); parfor b = 1:nb_blocks, z{b} = feval(f, blocks(b).xi); end z = vertcat(z{:}); else % STK-style vectorization not supported => loop over the rows of x n = size(x, 1); z = zeros(n, 1); parfor i = 1:n, z(i) = feval(f, x(i, :)); end end end % function stk_parallel_feval stk/inst/misc/parallel/stk_parallel_feval.m0000664000175000017500000000241012617165720020015 0ustar bectbect% STK_PARALLEL_FEVAL does parallel evaluations of a function. % Copyright Notice % % Copyright (C) 2013 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = stk_parallel_feval(f, x, vectorized, min_block_size) if nargin < 3, vectorized = true; end if nargin < 4, min_block_size = 1; end z = stk_parallel_feval(stk_parallel_engine_get(), ... f, x, vectorized, min_block_size); end % function stk_parallel_feval stk/inst/examples/0000775000175000017500000000000012617165717013105 5ustar bectbectstk/inst/examples/03_miscellaneous/0000775000175000017500000000000012617165717016252 5ustar bectbectstk/inst/examples/03_miscellaneous/stk_example_misc02.m0000664000175000017500000001075712617165717022133 0ustar bectbect% STK_EXAMPLE_MISC02 How to use priors on the covariance parameters % % A Matern covariance in dimension one is considered as an example. A Gaussian % prior is used for all three parameters: log-variance, log-regularity and log- % inverse-range. The corresponding parameter estimates are Maximum A Posteriori % (MAP) estimates or, more precisely, Restricted MAP (ReMAP) estimates. % % Several values for the variance of the prior are successively considered, to % illustrate the effect of this prior variance on the parameter estimates. When % the variance is small, the MAP estimate is close to the mode of the prior. On % the other hand, when the variance is large, the prior becomes "flat" and the % MAP estimate is close to the ReML estimate (see figure b). % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome %% DEFINE AN ARTIFICIAL ONE-DIMENSIONAL DATASET DIM = 1; % dimension of the factor space BOX = [0.0; 1.0]; % factor space xi = [0.25; 0.26; 0.50; 0.60]; zi = [1.00; 1.10; 0.20; 0.35]; %% SPECIFICATION OF THE MODEL & REML ESTIMATION model = stk_model ('stk_materncov_iso'); % small "regularization noise". model.lognoisevariance = 2 * log (1e-6); % Mode of the prior on the parameters of the Matern covariance % (also serves as an initial guess for the optimization) SIGMA2 = 1.0; % variance parameter NU = 2.0; % regularity parameter RHO1 = 0.4; % scale (range) parameter param0 = log ([SIGMA2; NU; 1/RHO1]); % Estimate covariance parameters (without prior) model.param = stk_param_estim (model, xi, zi, param0); param_opt_reml = model.param; %% EXPERIMENT WITH SEVERAL VALUES FOR PRIOR VARIANCES std_list = [10 1 0.2 0.01]; NT = 400; % nb of points in the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); stk_figure ('stk_example_misc02 (a)'); param_opt = zeros (length (param0), length (std_list)); for k = 1:length (std_list), % Prior on the parameters of the Matern covariance model.prior.mean = param0; model.prior.invcov = eye (length (param0)) ./ (std_list(k)^2); % Estimate covariance parameters (with a prior) model.param = stk_param_estim (model, xi, zi, param0); param_opt(:, k) = model.param; % Carry out kriging prediction zp = stk_predict (model, xi, zi, xt); % Plot predicted values and pointwise confidences intervals stk_subplot (2, 2, k); stk_plot1d (xi, zi, xt, [], zp); stk_labels ('input x', 'predicted output z'); stk_title (sprintf ('prior std = %.2f', std_list(k))); end %% FIGURE: ESTIMATED PARAMETER VERSUS PRIOR STD stk_figure ('stk_example_misc02 (b)'); param_name = {'SIGMA2', 'NU', '1/RHO'}; for j = 1:3, stk_subplot (2, 2, j); % estimated parameter versus prior std h = semilogx (std_list, exp (param_opt(j, :)), 'ko-'); set (h, 'LineWidth', 2, 'MarkerFaceColor', 'y'); stk_labels ('prior std', param_name{j}); % add an horizontal line showing the value of REML estimation hold on; semilogx (xlim, exp (param_opt_reml(j)) * [1 1], 'r--'); % add a second horizontal line showing the mode of the prior hold on; semilogx (xlim, exp (param0(j)) * [1 1], 'b--'); % adjust ylim yy = exp ([param_opt(j, :) param_opt_reml(j) param0(j)]); ylim_min = min (yy); ylim_max = max (yy); delta = ylim_max - ylim_min; ylim ([ylim_min - 0.05*delta ylim_max + 0.05*delta]); end if ~ strcmp (graphics_toolkit (), 'gnuplot') h1 = legend ('MAP estimates', 'REML estimate', 'mode of the prior'); h2 = stk_subplot (2, 2, 4); axis off; set (h1, 'Position', get (h2, 'Position')); end %!test stk_example_misc02; close all; stk/inst/examples/03_miscellaneous/stk_example_misc01.m0000664000175000017500000000477512617165717022135 0ustar bectbect% STK_EXAMPLE_MISC01 Several correlation functions from the Matern family % % The Matern 1/2 correlation function is also known as the "exponential correla- % tion function". This is the correlation function of an Ornstein-Ulhenbeck pro- % cess. % % The Matern covariance function tends to the Gaussian correlation function when % its regularity (smoothness) parameter tends to infinity. % % See also: stk_materncov_iso, stk_materncov_aniso % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_misc01'); %% List of correlation functions SIGMA2 = 1.0; % variance parameter RHO1 = 1.0; % scale (range) parameter % kriging with constant mean function (ordinary kriging) list_cov = {... 'Matern 1/2', 'stk_materncov_iso', log([SIGMA2; 0.5; 1/RHO1]); ... 'Matern 3/2', 'stk_materncov32_iso', log([SIGMA2; 1/RHO1]); ... 'Matern 5/2', 'stk_materncov52_iso', log([SIGMA2; 1/RHO1]); ... 'Matern 8.0', 'stk_materncov_iso', log([SIGMA2; 8.0; 1/RHO1]); ... 'Gaussian', 'stk_gausscov_iso', log([SIGMA2; 1/RHO1]) }; NB_COVARIANCE_FUNCTIONS = size (list_cov, 1); %% Visualisation x1 = 0.0; x2 = stk_sampling_regulargrid (1000, 1, [-5; 5]); col = {'r', 'b', 'g', 'k', 'm--'}; for j = 1:NB_COVARIANCE_FUNCTIONS, covfun = list_cov{j, 2}; param = list_cov{j, 3}; plot (x2, feval (covfun, param, x1, x2 ), col{j}); hold on; end stk_labels ('x', 'correlation r(x)'); legend (list_cov{:, 1}); stk_title ('Some members of the Matern family'); %!test stk_example_misc01; close all; stk/inst/examples/03_miscellaneous/stk_example_misc04.m0000664000175000017500000001047212617165717022127 0ustar bectbect% STK_EXAMPLE_MISC04 Pareto front simulation % % DESCRIPTION % % We consider a bi-objective optimization problem, where the objective % functions are modeled as a pair of independent stationary Gaussian % processes with a Matern 5/2 isotropic covariance function. % % Figure (a): we draw (unconditional) samplepaths of the Pareto front % using (unconditional) samplepaths of the pair of objective functions. % % Figure (b): we represent a Monte-Carlo estimate of the probability of % domination, computed on a grid. % % REFERENCE % % [1] Michael Binois, David Ginsbourger and Olivier Roustant, Quantifying % uncertainty on Pareto fronts with Gaussian Process conditional simu- % lations, Preprint hal-00904811, 2013. % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; %% MODEL DIM = 3; BOX = repmat ([0; 1], 1, DIM); model1 = stk_model ('stk_materncov52_iso', DIM); model1.param = log ([1.0 1/0.5]); model1.response_name = 'y1'; model2 = stk_model ('stk_materncov52_iso', DIM); model2.param = log ([1.0 1/2.0]); model2.response_name = 'y2'; NB_SIMULATION_POINTS = 500; x_sim = stk_sampling_randunif (NB_SIMULATION_POINTS, DIM, BOX); %% SIMULATE AND PLOT REALIZATIONS OF THE PARETO FRONT NB_SAMPLEPATHS = 20; % Simulate samplepaths y1_sim = stk_generate_samplepaths (model1, x_sim, NB_SAMPLEPATHS); y2_sim = stk_generate_samplepaths (model2, x_sim, NB_SAMPLEPATHS); % Empirical lower/upper bounds for each response y1_min = min (y1_sim(:)); y1_max = max (y1_sim(:)); y2_min = min (y2_sim(:)); y2_max = max (y2_sim(:)); % Axis for a nice plot y1_axis = [y1_min - 0.05 * (y1_max - y1_min), y1_max]; y2_axis = [y2_min - 0.05 * (y2_max - y2_min), y2_max]; % Figure + colormap stk_figure ('stk_example_misc04 (a)'); cm = jet (NB_SAMPLEPATHS); for i = 1:NB_SAMPLEPATHS, y_sim = [y1_sim(:, i) y2_sim(:, i)]; y_nd = y_sim(stk_paretofind (y_sim), :); % Add two extremities to the Pareto front y_nd_0 = stk_dataframe ([y_nd(1, 1) y2_max], y_nd.colnames); y_nd_1 = stk_dataframe ([y1_max y_nd(end, 2)], y_nd.colnames); y_nd = [y_nd_0; y_nd; y_nd_1]; %#ok stairs (y_nd.data(:, 1), y_nd.data(:, 2), 'Color', cm(i, :)); stk_labels (model1.response_name, model2.response_name); axis ([y1_axis y2_axis]); hold on; end stk_title ('Simulated Pareto fronts'); %% SIMULATE DOMINATED REGION NB_SAMPLEPATHS = 100; % Simulate samplepaths y1_sim = stk_generate_samplepaths (model1, x_sim, NB_SAMPLEPATHS); y2_sim = stk_generate_samplepaths (model2, x_sim, NB_SAMPLEPATHS); % Empirical lower/upper bounds for each response y1_min = min (y1_sim(:)); y1_max = max (y1_sim(:)); y2_min = min (y2_sim(:)); y2_max = max (y2_sim(:)); % Axes for a nice plot y1_axis = [y1_min - 0.05 * (y1_max - y1_min), y1_max]; y2_axis = [y2_min - 0.05 * (y2_max - y2_min), y2_max]; % Test points n_test = 100 ^ 2; y_test = stk_sampling_regulargrid (n_test, 2, [y1_axis' y2_axis']); y_test.colnames = {model1.response_name, model2.response_name}; isdom = zeros (size (y_test, 1), 1); for i = 1:NB_SAMPLEPATHS, y_sim = [y1_sim(:, i) y2_sim(:, i)]; isdom = isdom + stk_isdominated (y_test, y_sim); end isdom = isdom / NB_SAMPLEPATHS; % Figure (b) stk_figure ('stk_example_misc04 (b)'); colormap (hot); pcolor (y_test, isdom); colorbar ('YTick', [0 .25 .5 .75 1], ... 'YTickLabel', {'0%', '25%', '50%', '75%', '100%'}); stk_title ('Probability of domination'); %!test stk_example_misc04; close all; stk/inst/examples/03_miscellaneous/stk_example_misc03.m0000664000175000017500000000475412617165717022134 0ustar bectbect% STK_EXAMPLE_MISC03 How to deal with (known) seasonality % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome %% Sinusoid + noise t_obs = (0:0.05:12)'; S_obs = sin (t_obs + 0.3) + 0.1 * randn (size (t_obs)); stk_figure ('stk_example_misc03'); plot (t_obs, S_obs, 'k.'); stk_labels ('month number t', 'sunspots S'); t = (0:0.01:30)'; %% Gaussian process model with constant prior mean model = stk_model ('stk_materncov52_iso'); % Initial guess for the parameters of the Matern covariance [param0, lnv0] = stk_param_init (model, t_obs, S_obs, [], true); % Estimate the parameters [model.param, model.lognoisevariance] = stk_param_estim ... (model, t_obs, S_obs, param0, lnv0); % Carry out the kriging prediction S_posterior = stk_predict (model, t_obs, S_obs, t); % Display the result hold on; plot (t, S_posterior.mean, 'r-'); %% Gaussian process model with seasonality % Periodicity assumed to be known T0 = 2 * pi; % Here we use an EXPERIMENTAL feature of STK model2 = stk_model ('stk_materncov52_iso'); model2.order = nan; model2.lm = @(t)([ones(length(t),1) sin(2*pi*t/T0) cos(2*pi*t/T0)]); % Initial guess for the parameters of the Matern covariance [param0, lnv0] = stk_param_init (model2, t_obs, S_obs, [], true); % Estimate the parameters [model2.param, model2.lognoisevariance] = ... stk_param_estim (model2, t_obs, S_obs, param0, lnv0); % Carry out the kriging prediction S_posterior = stk_predict (model2, t_obs, S_obs, t); % Display the result hold on; plot (t, S_posterior.mean, 'g-'); %% Display models display (model) display (model2) %!test stk_example_misc03; close all; stk/inst/examples/02_design_of_experiments/0000775000175000017500000000000012617165717017766 5ustar bectbectstk/inst/examples/02_design_of_experiments/stk_example_doe03.m0000664000175000017500000001302112617165717023447 0ustar bectbect% STK_EXAMPLE_DOE03 A simple illustration of 1D Bayesian optimization % % Our goal here is to optimize the one-dimensional function % % x |--> x * sin (x) % % over the interval [0; 4 * pi]. % % A Matern 5/2 prior with known parameters is used. % % Evaluations points are chosen sequentially using the Expected Improvement (EI) % criterion, starting from an initial design of N0 = 3 points. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_doe03'); %% Problem definition % % Here we define a one-dimensional optimization problem. % % The goal is to find the maximum of f on the domain BOX. % % 1D test function f = @(x)(x .* sin (x)); % Define a 1D test function DIM = 1; % Dimension of the factor space BOX = stk_hrect ([0; 12], {'x'}); % Factor space (hyper-rectangle object) % Space discretization NT = 400; % Number of points in the grid x_grid = stk_sampling_regulargrid (NT, DIM, BOX); % Give names explicit names to the points of the grid x_grid.rownames = arrayfun ... (@(i)(sprintf ('grid%03d', i)), 1:NT, 'UniformOutput', false)'; % Values of the function on the grid z_grid = stk_feval (f, x_grid); z_grid.colnames = {'z'}; %% Initial design of experiments % % We start with an initial design of N0 points, regularly spaced on the domain. % % Size of the initial design N0 = 3; % Construction of the initial design x_init = stk_sampling_regulargrid (N0, DIM, BOX); % Give names explicit names to the points in the initial design x_init.rownames = arrayfun ... (@(i)(sprintf ('init%03d', i)), 1:N0, 'UniformOutput', false)'; % Values of the function on the initial design z_init = stk_feval (f, x_init); z_init.colnames = {'z'}; %% Specification of the model (Gaussian process prior) % % We choose a Matern 5/2 covariance with "fixed parameters" (in other % words, the variance and range parameters of the covariance function are % provided by the user rather than estimated from data). % model = stk_model ('stk_materncov52_iso'); % NOTE: the suffix '_iso' indicates an ISOTROPIC covariance function, but the % distinction isotropic / anisotropic is irrelevant here since DIM = 1. % Parameters for the Matern covariance function % ("help stk_materncov52_iso" for more information) SIGMA2 = 4.0 ^ 2; % variance parameter RHO1 = 2.0; % scale (range) parameter model.param = log ([SIGMA2; 1/RHO1]); % Play with the parameter of the model to understand their influence on the % behaviour of the algorithm ! %% Sequential design of experiments % % Here, evaluations points are chosen sequentially using the Expected % Improvement (EI) criterion, starting from the initial design defined above. % % The algorithm stops when either the maximum number of iterations is reached or % the maximum of the EI criterion falls below some threshold. % % Start with the initial design defined above data = horzcat (x_init, z_init); % Number of points to be added adaptively NB_ITER = 20; % Current value of the maximum of the Expected Improvement EI_max = +inf; % Value of EI_max for the stopping criterion EI_max_stop = (max (z_grid) - min (z_grid)) / 1e5; % Iteration number iter = 0; while (iter < NB_ITER) && (EI_max > EI_max_stop), % Trick: add a small "regularization" noise to our model model.lognoisevariance = 2 * log (min (1e-4, EI_max / 1e3)); % Carry out the kriging prediction z_post = stk_predict (model, data.x, data.z, x_grid); % Compute the Expected Improvement (EI) criterion % (the fourth argument indicates that we want to MAXIMIZE f) EI = stk_distrib_normal_ei (max (data.z), ... z_post.mean, sqrt (z_post.var), false); % Pick the point where the EI is maximum as our next evaluation point [EI_max, i_max] = max (EI); % Figure: upper panel stk_subplot (2, 1, 1); cla; stk_plot1d (data.x, data.z, x_grid, z_grid, z_post); xlim (BOX); hold on; plot (x_grid(i_max), z_grid(i_max), 'ro', 'MarkerFaceColor', 'y'); % Figure: lower panel stk_subplot (2, 1, 2); cla; plot (x_grid, EI); xlim (BOX); hold on; plot (x_grid(i_max), EI_max, 'ro', 'MarkerFaceColor', 'y'); stk_ylabel ('EI'); if EI_max > EI_max_stop, % Add the new evaluation to the DoE new_row = horzcat (x_grid(i_max, :), z_grid(i_max, :)); data = vertcat (data, new_row); %#ok iter = iter + 1; end drawnow; pause (0.2); end % Display the final DoE disp (data); % Total number of evaluations ? fprintf ('\nNumber of evaluations: %d + %d = %d.\n\n', N0, iter, N0 + iter); %!test stk_example_doe03; close all; stk/inst/examples/02_design_of_experiments/stk_example_doe01.m0000664000175000017500000000473412617165717023460 0ustar bectbect% STK_EXAMPLE_DOE01 Examples of two-dimensional designs % % All designs are constructed on the hyper-rectangle BOX = [0; 2] x [0; 4]. % % Examples of the following designs are shown: % a) Regular grid --> stk_sampling_regulargrid, % b) "Maximin" latin hypercube sample --> stk_sampling_maximinlhs, % c) RR2-scrambled Halton sequence --> stk_sampling_halton_rr2, % d) Uniformly distributed random sample --> stk_sampling_randunif. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome DIM = 2; % dimension of the factor space BOX = [0 0; 2 4]; % factor space N = 49; % size of the space-filling designs stk_figure (sprintf ('stk_exampke_doe01 - Several designs with N = %d', N)); PLOT_OPTIONS = {'ko', 'MarkerSize', 4, 'MarkerFaceColor', 'k'}; %% Regular grid x = stk_sampling_regulargrid (N, DIM, BOX); stk_subplot (2, 2, 1); plot (x(:, 1), x(:, 2), PLOT_OPTIONS{:}); stk_title ('a) Regular grid'); %% "Maximin" Latin Hypercube samples x = stk_sampling_maximinlhs (N, DIM, BOX); stk_subplot (2, 2, 2); plot (x(:, 1), x(:, 2), PLOT_OPTIONS{:}); stk_title ('b) "Maximin" LHS'); %% Halton sequence with RR2 scrambling x = stk_sampling_halton_rr2 (N, DIM, BOX); stk_subplot (2, 2, 3); plot (x(:, 1), x(:, 2), PLOT_OPTIONS{:}); stk_title ('c) Halton-RR2'); %% Random (uniform) sampling x = stk_sampling_randunif (N, DIM, BOX); stk_subplot (2, 2, 4); plot (x(:, 1), x(:, 2), PLOT_OPTIONS{:}); stk_title ('d) Random'); %!test stk_example_doe01; close all; stk/inst/examples/02_design_of_experiments/stk_example_doe02.m0000664000175000017500000000545512617165717023462 0ustar bectbect% STK_EXAMPLE_DOE02 "Sequential Maximin" design % % In this example, a two-dimensional space-filling design is progressively % enriched with new points using a "sequential maximin" approach. More % precisely, the k-th point X(k, :) is selected to maximize the distance to the % set of all previously selected points X(1, :), X(2, :), ..., X(k-1, :). % % NOTES: % % * The resulting design is NOT optimal with respect to the maximin criterion % (separation distance). % % * This procedure is not truly a *sequential* design procedure, since the % choice of the k-th point X(k, :) does NOT depend on the response at the % previously selected locations X(i, :), i < k. % % REFERENCE % % [1] Emmanuel Vazquez and Julien Bect, "Sequential search based on kriging: % convergence analysis of some algorithms", In: ISI - 58th World % Statistics Congress of the International Statistical Institute (ISI'11), % Dublin, Ireland, August 21-26, 2011. % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_doe02'); %% Preliminaries DIM = 2; BOX = repmat ([0; 1], 1, DIM); % start from, e. g., a random/maximin LHS N0 = 10; x = stk_sampling_maximinlhs (N0, DIM, BOX); % final size of the desired DoE NB_ITER = 10; % plot styles STYLE_CURRENT = {'bo', 'MarkerFaceColor', 0.7 * ones(1, 3)}; STYLE_NEXT = {'ro', 'MarkerFaceColor', 'y'}; %% Sequential design % % This section can be run several times, to produce a bigger DoE ! % for i = 1:NB_ITER, % compute the current fill distance % & the point where the maximum is attained [fd, next_x] = stk_filldist (x, BOX); % plot cla; plot (x(:, 1), x(:, 2), STYLE_CURRENT{:}); hold on; plot (next_x(:, 1), next_x(:, 2), STYLE_NEXT{:}); stk_title (sprintf ('n = %d, fd = %.2e\n', size (x, 1), fd)); drawnow; pause (0.5); % enrich the DoE x = vertcat (x, next_x); end %!test stk_example_doe02; close all; stk/inst/examples/01_kriging_basics/0000775000175000017500000000000012617165717016363 5ustar bectbectstk/inst/examples/01_kriging_basics/stk_example_kb08.m0000664000175000017500000000621512617165717021705 0ustar bectbect% STK_EXAMPLE_KB05 Generation of conditioned sample paths made easy % % It has been demonstrated, in stk_exampke_kb05, how to generate conditioned % sample paths using unconditioned sample paths and conditioning by kriging. % % This example shows how to do the same in a more concise way, letting STK % take care of the details. % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_kb08'); NB_PATHS = 10; % number of sample paths that we want to produce %% Define a 1d test function, generate observations f = @(x)(- (0.7 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); DIM = 1; % dimension of the factor space BOX = [-1.0; 1.0]; % factor space NT = 400; % nb of points in the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); zt = stk_feval (f, xt); xi_ind = [1 20 90 200 300 350]; % indices of evaluation points in xt xi = xt(xi_ind, 1); % evaluation points zi = stk_feval (f, xi); % evaluation results %% Specification of the model model = stk_model ('stk_materncov_iso'); % Parameters for the Matern covariance % ("help stk_materncov_iso" for more information) SIGMA2 = 1.0; % variance parameter NU = 4.0; % regularity parameter RHO1 = 0.4; % scale (range) parameter model.param = log ([SIGMA2; NU; 1/RHO1]); %% Method 1: explicit conditioning by kriging (as in stk_example_kb05) zsim = stk_generate_samplepaths (model, xt, NB_PATHS); % Carry out the kriging prediction at points xt [zp, lambda] = stk_predict (model, xi, zi, xt); % Condition sample paths on the observations zsimc1 = stk_conditioning (lambda, zi, zsim, xi_ind); %% Method 2: let STK take care of the details zsimc2 = stk_generate_samplepaths (model, xi, zi, xt, NB_PATHS); %% Figure stk_subplot (1, 2, 1); plot (xt, zsimc1, 'LineWidth', 2); legend off; hold on; plot (xi, zi, 'ko', 'MarkerSize', 6, 'MarkerFaceColor', 'k'); stk_title (sprintf ('%d conditional sample paths', NB_PATHS)); stk_labels ('input variable x', 'response z'); stk_subplot (1, 2, 2); plot (xt, zsimc2, 'LineWidth', 2); legend off; hold on; plot (xi, zi, 'ko', 'MarkerSize', 6, 'MarkerFaceColor', 'k'); stk_title (sprintf ('another set of %d sample paths', NB_PATHS)); stk_labels ('input variable x', 'response z'); %!test stk_example_kb08; close all; stk/inst/examples/01_kriging_basics/stk_example_kb06.m0000664000175000017500000000632112617165717021701 0ustar bectbect% STK_EXAMPLE_KB06 Ordinary kriging VS kriging with a linear trend % % The same dataset is analyzed using two variants of kriging. % % The left panel shows the result of ordinary kriging, in other words, Gaussian % process interpolation assuming a constant (but unknown) mean. The right panel % shows the result of adding a linear trend in the mean of the Gaussian process. % % The difference with the left plot is clear in extrapolation: the first predic- % tor exhibits a "mean reverting" behaviour, while the second one captures an % increasing trend in the data. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_kb06'); %% Preliminaries DIM = 1; % Dimension of the factor space BOX = [-2.0; 2.0]; % Factor space NT = 1e3; % Number of points in the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); % Construct a regular grid %% Data xi = stk_dataframe ([0.00; 0.10; 0.20], {'x'}); % Evaluation points zi = stk_dataframe ([0.00; 0.09; 0.21], {'z'}); % Evaluation results %% Default parameters for the Matern covariance % Parameters used as initial values for stk_param_estim() SIGMA2 = 1.0; % variance parameter NU = 2.0; % regularity parameter RHO1 = 0.4; % scale (range) parameter param0 = log ([SIGMA2; NU; 1/RHO1]); %% Ordinary kriging (constant mean) model = stk_model ('stk_materncov_iso', DIM); model.lognoisevariance = 2 * log (1e-10); model.order = 0; % Estimate the parameters of the covariance model.param = stk_param_estim (model, xi, zi, param0); % Carry out kriging prediction zp = stk_predict (model, xi, zi, xt); % Plot the result stk_subplot (1, 2, 1); stk_plot1d (xi, zi, xt, [], zp); stk_title ('Ordinary kriging'); ylim ([-5 5]); %% Linear trend (aka "universal kriging") % We just need to change the value of 'order' in the model model.order = 1; % Re-estimate the parameters of the covariance model.param = stk_param_estim (model, xi, zi, param0); % Carry out kriging prediction zp = stk_predict (model, xi, zi, xt); % Plot the result stk_subplot (1, 2, 2); stk_plot1d (xi, zi, xt, [], zp); stk_title ('Kriging with linear trend'); ylim ([-5 5]); %!test stk_example_kb06; close all; stk/inst/examples/01_kriging_basics/stk_example_kb09.m0000664000175000017500000000650312617165717021706 0ustar bectbect% STK_EXAMPLE_KB09 Generation of sample paths conditioned on noisy observations % % A Matern Gaussian process model is used, with constant but unknown mean % (ordinary kriging) and known covariance parameters. % % Given noisy observations from the unknown function, a batch of conditioned % sample paths is drawn using the "conditioning by kriging" technique % (stk_generate_samplepaths function). % % See also: stk_generate_samplepaths, stk_conditioning, stk_example_kb05 % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_kb09'); %% Example parameters % One-dimensional test function f = @(x)(- (0.7 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); DIM = 1; % Dimension of the factor space BOX = [-1.0; 1.0]; % Factor space % Simulation grid NT = 400; xt = stk_sampling_regulargrid (NT, DIM, BOX); zt = stk_feval (f, xt); % Default: homoscedastic noise if ~ exist ('HOMOSCEDASTIC_NOISE', 'var') HOMOSCEDASTIC_NOISE = true; end % Standard deviation of the noise if HOMOSCEDASTIC_NOISE NOISE_STD_FUNC = @(x) 0.5; else NOISE_STD_FUNC = @(x) (0.1 + (x + 1) .^ 2); end %% Choose observation points and generate noisy observations % Evaluate on set of locations composed of a regular grid of 30 points augmented % with 100 point uniformly distributed on [0 0.5] xi1 = stk_sampling_regulargrid (30, DIM, BOX); xi2 = stk_sampling_randunif (100, DIM, [0; 1]); xi = [xi1; xi2]; % Simulate noisy evaluations zi = stk_feval (f, xi); % Noiseless evaluation results noise_std = NOISE_STD_FUNC (xi.data); % Standard deviation of the noise zi = zi + noise_std .* randn (size (zi)); % Noisy evaluation results %% Gaussian process model % % In this example, the variance of the noise assumed to be known beforehand. % model = stk_model ('stk_materncov52_iso'); model.lognoisevariance = 2 * log (noise_std); % assumed known model.param = stk_param_estim (model, xi, zi); %% Generate conditional sample paths NB_PATHS = 20; zp = stk_predict (model, xi, zi, xt); z_sim_cond = stk_generate_samplepaths (model, xi, zi, xt, NB_PATHS); % Display the result stk_plot1d (xi, zi, xt, zt, zp, z_sim_cond); stk_title ('Prediction and credible intervals'); stk_labels ('input variable x', 'response z'); %!test HOMOSCEDASTIC_NOISE = true; stk_example_kb09; close all; %!test HOMOSCEDASTIC_NOISE = false; stk_example_kb09; close all; stk/inst/examples/01_kriging_basics/stk_example_kb01.m0000664000175000017500000001156312617165717021700 0ustar bectbect% STK_EXAMPLE_KB01 Ordinary kriging in 1D % % A Matern covariance function is used for the Gaussian Process (GP) prior. The % parameters of this covariance function are assumed to be known (i.e., no % parameter estimation is performed here). % % The word 'ordinary' indicates that the mean function of the GP prior is % assumed to be constant and unknown. % % The example first performs kriging prediction based on noiseless data (the % kriging predictor, which is the posterior mean of the GP model, interpolates % the data in this case) and then based on noisy data. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome % Use verbose output for the display of dataframes save_verbosity = stk_options_get ('stk_dataframe', 'disp_format'); stk_options_set ('stk_dataframe', 'disp_format', 'verbose'); %% Define a 1d test function f = @(x)(- (0.7 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); DIM = 1; % dimension of the factor space BOX = [-1.0; 1.0]; % factor space NT = 400; % nb of points in the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); zt = stk_feval (f, xt); stk_figure ('stk_example_kb01 (a)'); plot (xt, zt, 'k', 'LineWidth', 2); stk_title ('Function to be approximated'); stk_labels ('input variable x', 'response z'); %% Generate a space-filling design % % The objective is to construct an approximation of f with a budget of NI % evaluations performed on a "space-filling design". % % A regular grid (i.e., a grid with constant spacing) is constructed using % stk_sampling_regulargrid(), which is equivalent to linspace() in this 1D % example. % NI = 6; % number of evaluations xi = stk_sampling_regulargrid (NI, DIM, BOX); % evaluation points zi = stk_feval (f, xi); % evaluation results %% Specification of the model % % We choose a Matern covariance with "fixed parameters" (in other words, the % parameters of the covariance function are provided by the user rather than % estimated from data). % % The following line defines a model with a constant but unknown mean (ordinary % kriging) and a Matern covariance function. (Some default parameters are also % set, but we override them below.) model = stk_model ('stk_materncov_iso'); % NOTE: the suffix '_iso' indicates an ISOTROPIC covariance function, but the % distinction isotropic / anisotropic is irrelevant here since DIM = 1. % Parameters for the Matern covariance function % ("help stk_materncov_iso" for more information) SIGMA2 = 1.0; % variance parameter NU = 4.0; % regularity parameter RHO1 = 0.4; % scale (range) parameter model.param = log ([SIGMA2; NU; 1/RHO1]); %% Carry out the kriging prediction and display the result % % The result of a kriging predicition is provided by stk_predict() in an object % zp of type stk_dataframe, with two columns: "zp.mean" (the kriging mean) and % "zp.var" (the kriging variance). % % Carry out the kriging prediction at points xt zp = stk_predict (model, xi, zi, xt); % Display the result stk_figure ('stk_example_kb01 (b)'); stk_plot1d (xi, zi, xt, zt, zp); stk_title ('Kriging prediction based on noiseless observations'); stk_labels ('input variable x', 'response z'); %% Repeat the experiment in a noisy setting NOISEVARIANCE = (1e-1)^2; % Now the observations are perturbed by an additive Gaussian noise noise = sqrt (NOISEVARIANCE) * randn (size (zi)); zi_n = zi + noise; % We also include the observation noise in the model model_n = model; model_n.lognoisevariance = log (NOISEVARIANCE); % Carry out the kriging prediction at locations xt zp_n = stk_predict (model_n, xi, zi_n, xt); % Display the result stk_figure ('stk_example_kb01 (c)'); stk_plot1d (xi, zi_n, xt, zt, zp_n); stk_title ('Kriging prediction based on noisy observations'); stk_labels ('input variable x', 'response z'); %% Cleanup % Restore output verbosity stk_options_set ('stk_dataframe', 'disp_format', save_verbosity); %!test stk_example_kb01; close all; stk/inst/examples/01_kriging_basics/stk_example_kb04.m0000664000175000017500000001114512617165717021677 0ustar bectbect% STK_EXAMPLE_KB04 Estimating the variance of the noise % % This example constructs an ordinary kriging approximation in 1D, with % covariance parameters and noise variance estimated from the data. % % A Matern covariance function is used for the Gaussian Process (GP) prior. The % parameters of this covariance function are estimated using the Restricted % Maximum Likelihood (ReML) method. % % The mean function of the GP prior is assumed to be constant and unknown. % % In this example, the variance of the observation noise is not assumed to be % known, and is instead estimated from the data together the parameters of the % covariance function. This is triggered by the used of the fifth (optional) % argument in the call to stk_param_estim. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_kb04'); %% Define a 1d test function f = @(x)(- (0.8 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); DIM = 1; % dimension of the factor space BOX = [-1.0; 1.0]; % factor space NT = 400; % nb of points in the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); zt = stk_feval (f, xt); %% Generate a random sampling plan % % The objective is to construct an approximation of f with a budget of NI % evaluations performed on a randomly generated (uniform) design. % % Change the value of NOISEVARIANCE to add a Gaussian evaluation noise on % the observations. % NOISEVARIANCE = 0.05; NI = 30; % nb of evaluations xi = stk_sampling_randunif (NI, DIM, BOX); % evaluation points zi = stk_feval (f, xi); % evaluation results zi = zi + sqrt (NOISEVARIANCE) * randn (NI, 1); %% Specification of the model % % We choose a Matern covariance, the parameters of which will be estimated from % the data. % % The values of the parameters that are provided here, including the noise % variance, are only used as an initial point for the optimization algorithm % used in stk_param_estim(). % % The following line defines a model with a constant but unknown mean (ordinary % kriging) and a Matern covariance function. (Some default parameters are also % set, but they will be replaced below by estimated parameters.) model = stk_model ('stk_materncov_iso'); %% Estimate the parameters of the covariance function % % Here, the parameters of the Matern covariance function are estimated by the % REML (REstricted Maximum Likelihood) method using stk_param_estim(), with an % initial guess provided for the variance of the noise % % Initial guess for the parameters for the Matern covariance % (see "help stk_materncov_iso" for more information) SIGMA2 = 1.0; % variance parameter NU = 4.0; % regularity parameter RHO1 = 0.4; % scale (range) parameter param0 = log ([SIGMA2; NU; 1/RHO1]); % Initial guess for the (log of the) noise variance lnv0 = 2 * log (std (zi) / 100); [model.param, model.lognoisevariance] = ... stk_param_estim (model, xi, zi, param0, lnv0); display (model); %% Estimate the parameters of the covariance function (bis) % % The sections shows how to do the same thing without an initial guess for the % noise variance. The same initial guess (param0) is used for the other % parameters of the model. % model2 = stk_model ('stk_materncov_iso'); % Indicate that with the noise variance to be estimated model2.lognoisevariance = nan; [model2.param, model2.lognoisevariance] = ... stk_param_estim (model2, xi, zi, param0); display (model2); %% Carry out kriging prediction zp = stk_predict (model, xi, zi, xt); % Visualisation stk_plot1d (xi, zi, xt, zt, zp); stk_title ('Kriging prediction'); stk_labels ('input variable x', 'response z'); %!test stk_example_kb04; close all; stk/inst/examples/01_kriging_basics/stk_example_kb07.m0000664000175000017500000000365412617165717021710 0ustar bectbect% STK_EXAMPLE_KB07 Simulation of sample paths from a Matern process % Copyright Notice % % Copyright (C) 2013, 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_kb07'); %% Define the factor space & a Matern GP model on it % Factor space DIM = 1; BOX = [-1.0; 1.0]; % Grid N = 400; x = stk_sampling_regulargrid (N, DIM, BOX); % Model model = stk_model ('stk_materncov_iso'); SIGMA2 = 1.0; % variance parameter NU = NaN; % regularity parameter RHO1 = 0.4; % scale (range) parameter model.param = log ([SIGMA2; NU; 1/RHO1]); % Several values for nu nu_list = [0.5 1.5 2.5 10.0]; %% Generate (unconditional) sample paths NB_PATHS = 10; for k = 1:4, model.param(2) = log (nu_list(k)); zsim = stk_generate_samplepaths (model, x, NB_PATHS); % Display the result stk_subplot (2, 2, k); plot (x, zsim, 'LineWidth', 2); legend off; stk_title (sprintf ('Matern, nu = %.1f', nu_list(k))); stk_labels ('input variable x', 'response z', 'FontWeight', 'bold'); end %!test stk_example_kb07; close all; stk/inst/examples/01_kriging_basics/stk_example_kb02.m0000664000175000017500000001204612617165717021676 0ustar bectbect% STK_EXAMPLE_KB02 Ordinary kriging in 1D with parameter estimation % % We consider an ordinary kriging approximation in 1D: the mean function of the % Gaussian process prior is assumed to be constant and unknown. A Matern covari- % ance function is used, and its parameters are estimated using the Restricted % Maximum Likelihood (ReML) method. % % The example can be run either with noisy data or with noiseless (exact) data, % depending on the value of the NOISY flag (the default is false, i.e., noise- % less data). % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome % Use verbose output save_verbosity = stk_options_get ('stk_dataframe', 'disp_format'); stk_options_set ('stk_dataframe', 'disp_format', 'verbose'); %% DEFINE A 1D TEST FUNCTION f = @(x)(- (0.8 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); DIM = 1; % Dimension of the factor space BOX = [-1.0; 1.0]; % Factor space NOISY = false; % Choose either a noiseless or a noisy demo. if ~ NOISY % NOISELESS DEMO ... NI = 6; % NI = nb of evaluations that will be used else % OR NOISY DEMO ? NI = 20; % NI = nb of evaluations that will be used NOISESTD = 0.1; % NOISESTD = std deviation of the observation noise end % %% "MAXIMIN LHS" SAMPLING PLAN & CORRESPONDING EVALUATIONS % % The objective is to construct an approximation of f with a budget of NI % evaluations performed on a "maximin LHS" design. % NITER = 5; % number of random designs generated in stk_sampling_maximinlhs() xi = stk_sampling_maximinlhs (NI, DIM, BOX, NITER); % evaluation points % xi = stk_sampling_randunif (NI, DIM, BOX); zi = stk_feval (f, xi); % evaluation results if NOISY, zi = zi + NOISESTD * randn (NI, 1); end %% SPECIFICATION OF THE MODEL % % We choose a Matern covariance, the parameters of which will be estimated from % the data. % % The following line defines a model with a constant but unknown mean (ordinary % kriging) and a Matern covariance function. (Some default parameters are also % set, but they will be replaced below by estimated parameters.) model = stk_model ('stk_materncov_iso'); %% ESTIMATION OF THE PARAMETERS OF THE COVARIANCE FUNCTION % % Here, the parameters of the Matern covariance function are estimated by the % REML (REstricted Maximum Likelihood) method using stk_param_estim(). % % Initial guess for the parameters of the Matern covariance [param0, lnv0] = stk_param_init (model, xi, zi, BOX, NOISY); % % Alternative: user-defined initial guess for the parameters % % (see "help stk_materncov_iso" for more information) % SIGMA2 = 1.0; % variance parameter % NU = 4.0; % regularity parameter % RHO1 = 0.4; % scale (range) parameter % param0 = log ([SIGMA2; NU; 1/RHO1]); if ~ NOISY, % Noiseless case: set a small "regularization" noise % the (log)variance of which is provided by stk_param_init model.lognoisevariance = lnv0; else % Otherwise, set the variance of the noise % (assumed to be known, not estimated, in this example) model.lognoisevariance = 2 * log (NOISESTD); end % Estimate the parameters model.param = stk_param_estim (model, xi, zi, param0); model %#ok %% CARRY OUT KRIGING PREDICTION AND DISPLAY RESULTS NT = 400; % Number of points in the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); % Generate a regular grid zt = stk_feval (f, xt); % Values of f on the grid % Compute the kriging predictor (and the kriging variance) on the grid zp = stk_predict (model, xi, zi, xt); %% Visualisation stk_figure ('stk_example_kb02 (a)'); plot (xt, zt, 'k', 'LineWidth', 2); stk_title ('Function to be approximated'); stk_labels ('input variable x', 'response z'); stk_figure ('stk_example_kb02 (b)'); stk_plot1d (xi, zi, xt, zt, zp); stk_title ('Kriging prediction with estimated parameters'); stk_labels ('input variable x', 'response z'); %% Cleanup % Restore output verbosity stk_options_set ('stk_dataframe', 'disp_format', save_verbosity); %!test stk_example_kb02; close all; stk/inst/examples/01_kriging_basics/stk_example_kb05.m0000664000175000017500000001106012617165717021674 0ustar bectbect% STK_EXAMPLE_KB05 Generation of conditioned sample paths % % A Matern Gaussian process model is used, with constant but unknown mean % (ordinary kriging) and known covariance parameters. % % Given noiseless observations from the unknown function, a batch of conditioned % sample paths is drawn using the "conditioning by kriging" technique. In short, % this means that unconditioned sample path are simulated first (using % stk_generate_samplepaths), and then conditioned on the observations by kriging % (using stk_conditioning). % % Note: in this example, for pedagogical purposes, conditioned samplepaths are % simulated in two steps: first, unconditioned samplepaths are simulated; % second, conditioned samplepaths are obtained using conditioning by kriging. % In practice, these two steps can be carried out all at once using % stk_generate_samplepath (see, e.g., stk_example_kb09). % % See also: stk_generate_samplepaths, stk_conditioning, stk_example_kb09 % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_kb05'); %% Define a 1d test function f = @(x)(- (0.7 * x + sin (5 * x + 1) + 0.1 * sin (10 * x))); DIM = 1; % dimension of the factor space BOX = [-1.0; 1.0]; % factor space NT = 400; % nb of points in the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); zt = stk_feval (f, xt); %% Generate observations % % The objective is to construct an approximation of f and to simulate % conditioned sample paths from NI observations. The observation locations % are chosen as a subset of xt. % xi_ind = [1 20 90 200 300 350]; % indices of evaluation points in xt xi = xt(xi_ind, 1); % evaluation points zi = stk_feval (f, xi); % evaluation results %% Specification of the model % % We choose a Matern covariance with "fixed parameters" (in other % words, the parameters of the covariance function are provided by the user % rather than estimated from data). % % The following line defines a model with a constant but unknown mean % (ordinary kriging) and a Matern covariance function. (Some default % parameters are also set, but we override them below.) model = stk_model ('stk_materncov_iso'); % Parameters for the Matern covariance % ("help stk_materncov_iso" for more information) SIGMA2 = 1.0; % variance parameter NU = 4.0; % regularity parameter RHO1 = 0.4; % scale (range) parameter model.param = log ([SIGMA2; NU; 1/RHO1]); %% Generate (unconditional) sample paths NB_PATHS = 10; zsim = stk_generate_samplepaths (model, xt, NB_PATHS); % Display the result stk_subplot (2, 2, 1); plot (xt, zsim, 'LineWidth', 2); legend off; stk_title ('Unconditional sample paths'); stk_labels ('input variable x', 'response z'); %% Carry out the kriging prediction and generate conditional sample paths % Carry out the kriging prediction at points xt [zp, lambda] = stk_predict (model, xi, zi, xt); % Condition sample paths on the observations zsimc = stk_conditioning (lambda, zi, zsim, xi_ind); % Display the observations only stk_subplot (2, 2, 2); stk_plot1d (xi, zi); stk_title ('Observations'); stk_labels ('input variable x', 'response z'); % Display the conditional sample paths stk_subplot (2, 2, 3); plot (xt, zsimc, 'LineWidth', 2); legend off; hold on; plot (xi, zi, 'ko', 'MarkerSize', 6, 'MarkerFaceColor', 'k'); stk_title ('Conditional sample paths'); stk_labels ('input variable x', 'response z'); % Display the kriging and credible intervals stk_subplot (2, 2, 4); stk_plot1d (xi, zi, xt, zt, zp, zsimc); stk_title ('Prediction and credible intervals'); stk_labels ('input variable x', 'response z'); %!test stk_example_kb05; close all; stk/inst/examples/01_kriging_basics/stk_example_kb03.m0000664000175000017500000001200312617165717021670 0ustar bectbect% STK_EXAMPLE_KB03 Ordinary kriging in 2D % % An anisotropic Matern covariance function is used for the Gaussian Process % (GP) prior. The parameters of this covariance function (variance, regularity % and ranges) are estimated using the Restricted Maximum Likelihood (ReML) % method. % % The mean function of the GP prior is assumed to be constant and unknown. This % default choice can be overridden by means of the model.order property. % % The function is sampled on a space-filling Latin Hypercube design, and the % data is assumed to be noiseless. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . stk_disp_examplewelcome; stk_figure ('stk_example_kb03'); CONTOUR_LINES = 40; % number of levels in contour plots DOT_STYLE = {'ro', 'MarkerFaceColor', 'r', 'MarkerSize', 4}; %% CHOICE OF A TWO-DIMENSIONAL TEST FUNCTION CASENUM = 1; switch CASENUM case 1, % the classical BRANIN-HOO test function f = @stk_testfun_braninhoo; DIM = 2; BOX = [[-5; 10], [0; 15]]; NI = 20; case 2, % another test function f_ = inline (['exp(1.8*(x1+x2)) + 3*x1 + 6*x2.^2' ... '+ 3*sin(4*pi*x1)'], 'x1', 'x2'); f = @(x)(f_(x(:, 1), x(:, 2))); DIM = 2; BOX = [[-1; 1], [-1; 1]]; NI = 40; % this second function is much harder to approximate end % Optional: create an hyper-rectangle object for the input space BOX = stk_hrect (BOX, {'x_1', 'x_2'}) %% COMPUTE AND VISUALIZE THE FUNCTION ON A 80 x 80 REGULAR GRID % Size of the regular grid NT = 80 ^ DIM; % The function stk_sampling_regulargrid() does the job of creating the grid xt = stk_sampling_regulargrid (NT, DIM, BOX); % Compute the corresponding responses zt = stk_feval (f, xt); % Since xt is a regular grid, we can do a contour plot stk_subplot (2, 2, 1); contour (xt, f, CONTOUR_LINES); axis (BOX); stk_title ('function to be approximated'); %% CHOOSE A KRIGING (GAUSSIAN PROCESS) MODEL % We start with a generic (anisotropic) Matern covariance function. model = stk_model ('stk_materncov_aniso', DIM); % As a default choice, a constant (but unknown) mean is used, % i.e., model.order = 0. % model.order = 1; %%% UNCOMMENT TO USE A LINEAR TREND %%% % model.order = 2; %%% UNCOMMENT TO USE A "FULL QUADRATIC" TREND %%% %% EVALUATE THE FUNCTION ON A "MAXIMIN LHS" DESIGN xi = stk_sampling_maximinlhs (NI, DIM, BOX); zi = stk_feval (f, xi); % Add the design points to the first plot hold on; plot (xi(:, 1), xi(:, 2), DOT_STYLE{:}); %% ESTIMATE THE PARAMETERS OF THE COVARIANCE FUNCTION % Compute an initial guess for the parameters of the Matern covariance (param0) % and a reasonable log-variance for a small "regularization noise" [param0, model.lognoisevariance] = stk_param_init (model, xi, zi, BOX); % % Alternative: user-defined initial guess for the parameters of % % the Matern covariance (see "help stk_materncov_aniso" for more information) % SIGMA2 = var (zi); % NU = 2; % RHO1 = (BOX(2,1) - BOX(1,1)) / 10; % RHO2 = (BOX(2,2) - BOX(1,2)) / 10; % param0 = log ([SIGMA2; NU; 1/RHO1; 1/RHO2]); % model.lognoisevariance = 2 * log (1e-5); model.param = stk_param_estim (model, xi, zi, param0); %% CARRY OUT KRIGING PREDICITION AND VISUALIZE % Here, we compute the kriging prediction on each point of the grid zp = stk_predict (model, xi, zi, xt); % Display the result using a contour plot, to be compared with the contour % lines of the true function stk_subplot (2, 2, 2); contour (xt, zp.mean, CONTOUR_LINES); tsc = sprintf ('approximation from %d points', NI); hold on; plot (xi(:, 1), xi(:, 2), DOT_STYLE{:}); hold off; axis (BOX(:)); stk_title (tsc); %% VISUALIZE THE ACTUAL PREDICTION ERROR AND THE KRIGING STANDARD DEVIATION stk_subplot (2, 2, 3); pcolor (xt, log (abs (zp.mean - zt))); hold on; plot (xi(:, 1), xi(:, 2), DOT_STYLE{:}); hold off; axis (BOX(:)); stk_title ('true approx error (log)'); stk_subplot (2, 2, 4); pcolor (xt, 0.5 * log (zp.var)); hold on; plot (xi(:, 1), xi(:, 2), DOT_STYLE{:}); hold off; axis (BOX(:)); stk_title ('kriging std (log)'); %#ok<*NOPTS> %!test stk_example_kb03; close all; stk/inst/examples/test_functions/0000775000175000017500000000000012617165717016154 5ustar bectbectstk/inst/examples/test_functions/stk_testfun_braninhoo.m0000664000175000017500000000355412617165717022751 0ustar bectbect% STK_TESTFUN_BRANINHOO computes the Branin-Hoo function. % % The Branin-Hoo function (Branin and Hoo, 1972) is a classical test % function for global optimization algorithms, which belongs to the % well-known Dixon-Szego test set (Dixon and Szego, 1978). It is usually % minimized over [-5; 10] x [0; 15]. % % REFERENCES % % [1] Branin, F. H. and Hoo, S. K. (1972), A Method for Finding Multiple % Extrema of a Function of n Variables, in Numerical methods of % Nonlinear Optimization (F. A. Lootsma, editor, Academic Press, % London), 231-237. % % [2] Dixon L.C.W., Szego G.P., Towards Global Optimization 2, North- % Holland, Amsterdam, The Netherlands (1978) % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = stk_testfun_braninhoo (x) x = double (x); x1 = x(:, 1); x2 = x(:, 2); a = 5.1 / (4 * pi * pi); b = 5 / pi; c = 10 * (1 - 1 / (8 * pi)); y = (x2 - a * x1 .* x1 + b * x1 - 6) .^ 2 + c * cos (x1) + 10; end % function stk_testfun_braninhoo stk/inst/examples/test_functions/stk_testfun_goldsteinprice.m0000664000175000017500000000555012617165717024003 0ustar bectbect% STK_TESTFUN_GOLDSTEINPRICE computes the Goldstein-Price function % % The Goldstein-Price function [1] is a classical test function for % global optimization algorithms, which belongs to the well-known % Dixon-Szego test set [2]. % % It is usually minimized over [-2; 2] x [-2; 2]. It has a unique % global minimum at x = [0, -1] with f(x) = 3, and several local minima. % % REFERENCES % % [1] Goldstein, A.A. and Price, I.F. (1971), On descent from local % minima. Mathematics of Computation, 25(115). % % [2] Dixon L.C.W., Szego G.P. (1978), Towards Global Optimization 2, % North-Holland, Amsterdam, The Netherlands % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % % Based on the "Virtual Library for Simulation Experiments" % Copyright (C) 2013 Derek Bingham, Simon Fraser University % Authors: Sonja Surjanovic & Derek Bingham (dbingham@stat.sfu.ca) % Distributed under the GPLv2 licence % http://www.sfu.ca/~ssurjano/Code/goldprm.html % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function y = stk_testfun_goldsteinprice (x) if nargin == 0, visu_goldsteinprice (); return; end x = double (x); x1 = x(:, 1); x2 = x(:, 2); x1x1 = x1 .^ 2; x2x2 = x2 .^ 2; x1x2 = x1 .* x2; A1 = (x1 + x2 + 1) .^ 2; A2 = 19 - 14*x1 + 3*x1x1 - 14*x2 + 6*x1x2 + 3*x2x2; A = 1 + A1 .* A2; % 4th degree polynomial B1 = (2*x1 - 3*x2) .^ 2; B2 = 18 - 32*x1 + 12*x1x1 + 48*x2 - 36*x1x2 + 27*x2x2; B = 30 + B1 .* B2; % 4th degree polynomial y = A .* B; % 8th degree polynomial end % function stk_testfun_goldsteinprice function visu_goldsteinprice () s = 'Goldstein-Price function'; stk_figure (s); xt = stk_sampling_regulargrid (80^2, 2, [[-2; 2], [-2; 2]]); xt.colnames = {'x_1', 'x_2'}; surf (xt, @stk_testfun_goldsteinprice); hold on; plot3 (0, -1, 3, 'r.'); colorbar; stk_title (s); end % function visu_golsteinprice %!test % Use with nargin == 0 for visualisation %! stk_testfun_goldsteinprice (); close all; %!assert (stk_isequal_tolabs ... %! (stk_testfun_goldsteinprice ([0, -1]), 3.0, 1e-12)) stk/inst/lm/0000775000175000017500000000000012617165717011677 5ustar bectbectstk/inst/lm/@stk_lm_quadratic/0000775000175000017500000000000012617165717015325 5ustar bectbectstk/inst/lm/@stk_lm_quadratic/feval.m0000664000175000017500000000261112617165717016600 0ustar bectbect% FEVAL ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = feval (lm, x) %#ok x = double (x); [n, d] = size (x); z = horzcat (ones (n, 1), x, zeros (n, d * (d + 1) / 2)); k = d + 2; for i = 1:d for j = i:d z(:,k) = x(:, i) .* x(:, j); k = k + 1; end end end % function feval %!test %! n = 15; d = 4; %! x = stk_sampling_randunif (n, d); %! P = feval (stk_lm_quadratic (), x); %! assert (isequal (size (P), [n, 1 + d * (d + 3) / 2])); stk/inst/lm/@stk_lm_quadratic/stk_lm_quadratic.m0000664000175000017500000000230112617165717021025 0ustar bectbect% STK_LM_QUADRATIC ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function lm = stk_lm_quadratic () lm = class (struct (), 'stk_lm_quadratic'); end % function stk_lm_quadratic % Default constructor %!test %! lm = stk_lm_quadratic (); %! assert (isa (lm, 'stk_lm_quadratic')); stk/inst/lm/@stk_lm_null/0000775000175000017500000000000012617165717014322 5ustar bectbectstk/inst/lm/@stk_lm_null/feval.m0000664000175000017500000000231212617165717015573 0ustar bectbect% FEVAL ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = feval (lm, x) %#ok n = size (x, 1); z = zeros (n, 0); end % function feval %!test %! n = 15; d = 4; %! x = stk_sampling_randunif (n, d); %! P = feval (stk_lm_null (), x); %! assert (isequal (size (P), [n, 0])); stk/inst/lm/@stk_lm_null/stk_lm_null.m0000664000175000017500000000224312617165717017024 0ustar bectbect% STK_LM_NULL ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function lm = stk_lm_null () lm = class (struct (), 'stk_lm_null'); end % function stk_lm_null % Default constructor %!test %! lm = stk_lm_null (); %! assert (isa (lm, 'stk_lm_null')); stk/inst/lm/@stk_lm_matrix/0000775000175000017500000000000012617165717014654 5ustar bectbectstk/inst/lm/@stk_lm_matrix/feval.m0000664000175000017500000000220412617165717016125 0ustar bectbect% FEVAL ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = feval (lm, x) x = double (x); if isempty (lm.data), n = size (x, 1); z = zeros (n, 0); else z = lm.data(x, :); end end % function feval stk/inst/lm/@stk_lm_matrix/stk_lm_matrix.m0000664000175000017500000000314612617165717017713 0ustar bectbect% STK_LM_MATRIX ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function lm = stk_lm_matrix (data) if nargin == 0, lm = struct ('data', []); else lm = struct ('data', data); end lm = class (lm, 'stk_lm_matrix'); end % function stk_lm_matrix %!test %%% Default constructor %! lm = stk_lm_matrix (); %! assert (isa (lm, 'stk_lm_matrix')); %!test %%% dim 1 %! data = rand (10, 1); idx = 3:7; %! lm = stk_lm_matrix (data); %! assert (isa (lm, 'stk_lm_matrix')); %! assert (isequal (data(idx, :), feval (lm, idx))); %!test %%% dim 3 %! data = rand (10, 3); idx = 3:7; %! lm = stk_lm_matrix (data); %! assert (isa (lm, 'stk_lm_matrix')); %! assert (isequal (data(idx, :), feval (lm, idx))); stk/inst/lm/@stk_lm_affine/0000775000175000017500000000000012617165717014600 5ustar bectbectstk/inst/lm/@stk_lm_affine/feval.m0000664000175000017500000000233612617165717016057 0ustar bectbect% FEVAL ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = feval (lm, x) %#ok n = size (x, 1); z = horzcat (ones (n, 1), x); end % function feval %!test %! n = 15; d = 4; %! x = stk_sampling_randunif (n, d); %! P = feval (stk_lm_affine (), x); %! assert (isequal (size (P), [n, d + 1])); stk/inst/lm/@stk_lm_affine/stk_lm_affine.m0000664000175000017500000000226012617165717017557 0ustar bectbect% STK_LM_AFFINE ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function lm = stk_lm_affine () lm = class (struct (), 'stk_lm_affine'); end % function stk_lm_affine % Default constructor %!test %! lm = stk_lm_affine (); %! assert (isa (lm, 'stk_lm_affine')); stk/inst/lm/@stk_lm_cubic/0000775000175000017500000000000012617165717014435 5ustar bectbectstk/inst/lm/@stk_lm_cubic/stk_lm_cubic.m0000664000175000017500000000224412617165717017253 0ustar bectbect% STK_LM_CUBIC ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function lm = stk_lm_cubic () lm = class (struct (), 'stk_lm_cubic'); end % function stk_lm_cubic % Default constructor %!test %! lm = stk_lm_cubic (); %! assert (isa (lm, 'stk_lm_cubic')); stk/inst/lm/@stk_lm_cubic/feval.m0000664000175000017500000000315212617165717015711 0ustar bectbect% FEVAL ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = feval (lm, x) %#ok x = double (x); [n, d] = size (x); % Use stk_lm_quadratic to compute the quadratic part z2 = feval (stk_lm_quadratic, x); % And now compute all monomials of degree exactly 3 z3 = zeros (n, d * (2 + d * (3 + d)) / 6); c = 1; for i = 1:d u = x(:, i); for j = i:d v = u .* x(:, j); for k = j:d z3(:, c) = v .* x(:, k); c = c + 1; end end end z = horzcat (z2, z3); end % function feval %!test %! n = 15; d = 4; %! x = stk_sampling_randunif (n, d); %! P = feval (stk_lm_cubic (), x); %! assert (isequal (size (P), [n, 1 + d * (11 + d * (6 + d)) / 6])) stk/inst/lm/@stk_lm_constant/0000775000175000017500000000000012617165717015201 5ustar bectbectstk/inst/lm/@stk_lm_constant/stk_lm_constant.m0000664000175000017500000000227312617165717020565 0ustar bectbect% STK_LM_CONSTANT ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function lm = stk_lm_constant () lm = class (struct (), 'stk_lm_constant'); end % function stk_lm_constant % Default constructor %!test %! lm = stk_lm_constant (); %! assert (isa (lm, 'stk_lm_constant')); stk/inst/lm/@stk_lm_constant/feval.m0000664000175000017500000000231612617165717016456 0ustar bectbect% FEVAL ... [FIXME: missing documentation] % Copyright Notice % % Copyright (C) 2012-2014 SUPELEC % % Author: Julien Bect % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function z = feval (lm, x) %#ok n = size (x, 1); z = ones (n, 1); end % function feval %!test %! n = 15; d = 4; %! x = stk_sampling_randunif (n, d); %! P = feval (stk_lm_constant (), x); %! assert (isequal (size (P), [n, 1])); stk/inst/covfcs/0000775000175000017500000000000012617165717012552 5ustar bectbectstk/inst/covfcs/stk_gausscov_iso.m0000664000175000017500000001245212617165716016320 0ustar bectbect% STK_GAUSSCOV_ISO computes the isotropic Gaussian covariance function % % CALL: K = stk_gausscov_iso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and Y, % using the isotropic Gaussian covariance function with parameters PARAM. The % output matrix K has size NX x NY, where NX is the number of rows in X and NY % the number of rows in Y. The vector of parameters must have two elements: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(2) = - log (RHO), where RHO is the range parameter. % % CALL: dK = stk_gausscov_iso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to PARAM(DIFF) % if DIFF is equal to 1 or 2, or the covariance matrix itself if DIFF is equal % to -1 (in which case this is equivalent to stk_gausscov_iso (PARAM, X, Y)). % % CALL: K = stk_gausscov_iso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) between % the sets of locations X and Y. The output K is a vector of length N, where % N is the common number of rows of X and Y. % % See also: stk_sf_gausscorr, stk_gausscov_aniso % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_gausscov_iso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 param0 pairwise0 D % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % extract parameters from the "param" vector Sigma2 = exp (param(1)); invRho = exp (param(2)); % check parameter values if ~ (Sigma2 > 0) || ~ (invRho > 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) || ... ~ isequal ({x, y, param}, {x0, y0, param0}) || ... ~ isequal (pairwise, pairwise0) % compute the distance matrix D = invRho * stk_dist (x, y, pairwise); % save arguments for the nex call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; end if diff == -1, % compute the value (not a derivative) k = Sigma2 * stk_sf_gausscorr (D, -1); elseif diff == 1, % diff wrt param(1) = log(Sigma2) k = Sigma2 * stk_sf_gausscorr (D, -1); elseif diff == 2, % diff wrt param(3) = - log(invRho) k = D .* (Sigma2 * stk_sf_gausscorr (D, 1)); else error('there must be something wrong here !'); end end % function stk_gausscov_iso %% % 1D, 5x5 %!shared param, x, y %! dim = 1; %! param = log ([1.0; 2.5]); %! x = stk_sampling_randunif (5, dim); %! y = stk_sampling_randunif (5, dim); %!error stk_gausscov_iso (); %!error stk_gausscov_iso (param); %!error stk_gausscov_iso (param, x); %!test stk_gausscov_iso (param, x, y); %!test stk_gausscov_iso (param, x, y, -1); %!test stk_gausscov_iso (param, x, y, -1, false); %!error stk_gausscov_iso (param, x, y, -1, false, pi^2); %!error stk_gausscov_iso (param, x, y, -2); %!test stk_gausscov_iso (param, x, y, -1); %!error stk_gausscov_iso (param, x, y, 0); %!test stk_gausscov_iso (param, x, y, 1); %!test stk_gausscov_iso (param, x, y, 2); %!error stk_gausscov_iso (param, x, y, 3); %!error stk_gausscov_iso (param, x, y, nan); %!error stk_gausscov_iso (param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 2.5]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif (nx, dim); %! y = stk_sampling_randunif (ny, dim); %!test %! K1 = stk_gausscov_iso (param, x, y); %! K2 = stk_gausscov_iso (param, x, y, -1); %! assert (isequal (size (K1), [nx ny])); %! assert (stk_isequal_tolabs (K1, K2)); %!test %! for i = 1:2, %! dK = stk_gausscov_iso (param, x, y, i); %! assert (isequal (size (dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif (n, dim); %! y = stk_sampling_randunif (n, dim); %! %! K1 = stk_gausscov_iso (param, x, y); %! K2 = stk_gausscov_iso (param, x, y, -1, true); %! assert (isequal (size (K1), [n n])); %! assert (stk_isequal_tolabs (K2, diag (K1))); %! %! for i = 1:2, %! dK1 = stk_gausscov_iso (param, x, y, i); %! dK2 = stk_gausscov_iso (param, x, y, i, true); %! assert (isequal (size (dK1), [n n])); %! assert (stk_isequal_tolabs (dK2, diag (dK1))); %! end stk/inst/covfcs/stk_noisecov.m0000664000175000017500000000535012617165717015441 0ustar bectbect% STK_NOISECOV computes a noise covariance % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function K = stk_noisecov (ni, lognoisevariance, diff, pairwise) if nargin > 4, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end if (nargin < 3) || (isempty (diff)), diff = -1; % default: compute the value (not a derivative) end if nargin < 4 pairwise = false; % default: matrix end if isscalar (lognoisevariance), % homoscedastic % Remark: the result does not depend on diff if pairwise if lognoisevariance == -inf K = zeros (ni, 1); else K = (exp (lognoisevariance)) * (ones (ni, 1)); end else if lognoisevariance == -inf K = zeros (ni); else K = (exp (lognoisevariance)) * (eye (ni)); end end else % heteroscedastic s = size (lognoisevariance); if ~ ((isequal (s, [1, ni])) || (isequal (s, [ni, 1]))) fprintf ('lognoisevariance has size:\n'); display (s); stk_error (sprintf (['lognoisevariance was expected to be either a ' ... 'scalar or a vector of length %d\n'], ni), 'IncorrectSize'); end if diff ~= -1, error ('diff ~= -1 is not allowed in the heteroscedastic case'); end if pairwise K = exp (lognoisevariance(:)); else K = diag (exp (lognoisevariance)); end end end % function stk_noisecov %!shared ni, lognoisevariance, diff %! ni = 5; %! lognoisevariance = 0.0; %! diff = -1; %!error K = stk_noisecov(); %!error K = stk_noisecov(ni); %!test K = stk_noisecov(ni, lognoisevariance); %!test K = stk_noisecov(ni, lognoisevariance, diff); %!test K = stk_noisecov(ni, lognoisevariance, diff, true); %!error K = stk_noisecov(ni, lognoisevariance, diff, true, pi^2); stk/inst/covfcs/stk_gausscov_aniso.m0000664000175000017500000001553012617165716016637 0ustar bectbect% STK_GAUSSCOV_ANISO computes the anisotropic Gaussian covariance function % % CALL: K = stk_gausscov_aniso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and Y, % using the anisotropic Gaussian covariance function with parameters PARAM. % The output matrix K has size NX x NY, where NX is the number of rows in X % and NY the number of rows in Y. The vector of parameters must have DIM + 1 % elements, where DIM is the common number of columns of X and Y: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(2:END) = - log (RHO), where RHO is the vector of range parameters. % % CALL: dK = stk_gausscov_aniso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to PARAM(DIFF) % if DIFF is between 1 and DIM + 1, or the covariance matrix itself if DIFF is % equal to -1 (in which case this is equivalent to stk_gausscov_aniso (PARAM, % X, Y)). % % CALL: K = stk_gausscov_aniso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) between % the sets of locations X and Y. The output K is a vector of length N, where % N is the common number of rows of X and Y. % % See also: stk_sf_gausscorr, stk_gausscov_iso % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_gausscov_aniso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 xs ys param0 pairwise0 D Kx_cache compute_Kx_cache % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % check consistency for the number of factors dim = size (x, 2); if size (y, 2) ~= dim, stk_error ('xi and yi have incompatible sizes.', 'InvalidArgument'); end % check param nb_params = dim + 1; if length (param) ~= nb_params stk_error ('xi and param have incompatible sizes.', 'InvalidArgument'); else param = reshape (param, 1, nb_params); % row vector end % extract parameters from the "param" vector Sigma2 = exp (param(1)); invRho = exp (param(2:end)); % check parameter values if ~ (Sigma2 > 0) || ~ all (invRho >= 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) || ... ~ isequal ({x, y, param}, {x0, y0, param0}) || ... ~ isequal (pairwise, pairwise0) % compute the distance matrix xs = bsxfun (@times, x, invRho); ys = bsxfun (@times, y, invRho); D = stk_dist (xs, ys, pairwise); % save arguments for the next call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; % recomputation of Kx_cache is required compute_Kx_cache = true; end if diff == -1, % Compute the value (not a derivative) k = Sigma2 * stk_sf_gausscorr (D, -1); elseif diff == 1, % Differentiate wrt param(1) = log (Sigma2) k = Sigma2 * stk_sf_gausscorr (D, -1); elseif (diff >= 2) && (diff <= nb_params), % Differentiate wrt param(diff) = - log (invRho(diff-1)) ind = diff - 1; if compute_Kx_cache || isempty (Kx_cache) Kx_cache = 1 ./ (D + eps) .* (Sigma2 * stk_sf_gausscorr (D, 1)); compute_Kx_cache = false; end if pairwise, k = ((xs(:, ind) - ys(:, ind)) .^ 2) .* Kx_cache; else k = (bsxfun (@minus, xs(:, ind), ys(:, ind)')) .^ 2 .* Kx_cache; end else stk_error ('Incorrect value for the ''diff'' parameter.', ... 'InvalidArgument'); end end % function stk_gausscov_aniso %% % 1D, 5x5 %!shared param, x, y, K1, K2, K3 %! dim = 1; %! param = log ([1.0; 2.5]); %! x = stk_sampling_randunif (5, dim); %! y = stk_sampling_randunif (6, dim); %!error K0 = stk_gausscov_aniso (); %!error K0 = stk_gausscov_aniso (param); %!error K0 = stk_gausscov_aniso (param, x); %!test K1 = stk_gausscov_aniso (param, x, y); %!test K2 = stk_gausscov_aniso (param, x, y, -1); %!test K3 = stk_gausscov_aniso (param, x, y, -1, false); %!error K0 = stk_gausscov_aniso (param, x, y, -1, false, pi^2); %!assert (isequal (K1, K2)); %!assert (isequal (K1, K3)); %!test % various types of input arguments %! u = double (x); v = double (y); %! K1 = stk_gausscov_aniso (param, u, v, -1); %! K2 = stk_gausscov_aniso (param, struct ('a', u), struct ('a', v), -1); %! K3 = stk_gausscov_aniso (param, stk_dataframe (u), stk_dataframe (v), -1); %! assert (isequal (K1, K2)); %! assert (isequal (K1, K3)); %!error stk_gausscov_aniso (param, x, y, -2); %!test stk_gausscov_aniso (param, x, y, -1); %!error stk_gausscov_aniso (param, x, y, 0); %!test stk_gausscov_aniso (param, x, y, 1); %!test stk_gausscov_aniso (param, x, y, 2); %!error stk_gausscov_aniso (param, x, y, 3); %!error stk_gausscov_aniso (param, x, y, nan); %!error stk_gausscov_aniso (param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 2.5; 2.4; 2.6]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif (nx, dim); %! y = stk_sampling_randunif (ny, dim); %!test %! K1 = stk_gausscov_aniso (param, x, y); %! K2 = stk_gausscov_aniso (param, x, y, -1); %! assert (isequal (size (K1), [nx ny])); %! assert (stk_isequal_tolabs (K1, K2)); %!test %! for i = 1:(dim + 1), %! dK = stk_gausscov_aniso (param, x, y, i); %! assert (isequal (size (dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif (n, dim); %! y = stk_sampling_randunif (n, dim); %! %! K1 = stk_gausscov_aniso (param, x, y); %! K2 = stk_gausscov_aniso (param, x, y, -1, true); %! assert (isequal (size (K1), [n n])); %! assert (stk_isequal_tolabs (K2, diag (K1))); %! %! for i = 1:(dim + 1), %! dK1 = stk_gausscov_aniso (param, x, y, i); %! dK2 = stk_gausscov_aniso (param, x, y, i, true); %! assert (isequal (size (dK1), [n n])); %! assert (stk_isequal_tolabs (dK2, diag (dK1))); %! end stk/inst/covfcs/stk_materncov_iso.m0000664000175000017500000001304612617165717016465 0ustar bectbect% STK_MATERNCOV_ISO computes the isotropic Matern covariance % % CALL: K = stk_materncov_iso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and Y, % using the isotropic Matern covariance kernel with parameters PARAM. The % output matrix K has size NX x NY, where NX is the number of rows in X % and NY the number of rows in Y. The vector of parameters must have % three elements: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(2) = log(NU), where NU is the regularity parameter, % % * PARAM(3) = - log (RHO), where RHO is the range parameter. % % CALL: dK = stk_materncov_iso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to % PARAM(DIFF) if DIFF~= -1, or the covariance matrix itself if DIFF is % equal to -1 (in which case this is equivalent to stk_materncov_iso % (PARAM, X, Y)). % % CALL: K = stk_materncov_iso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) % between the sets of locations X and Y. The output K is a vector of % length N, where N is the common number of rows of X and Y. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Paul Feliot % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_materncov_iso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 param0 pairwise0 D % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % extract parameters from the "param" vector Sigma2 = exp (param(1)); Nu = exp (param(2)); invRho = exp (param(3)); % check parameter values if ~ (Sigma2 > 0) || ~ (Nu > 0) || ~ (invRho >= 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) ... || ~ isequal ({x, y, param}, {x0, y0, param0}) ... || ~ isequal (pairwise, pairwise0) % compute the distance matrix D = invRho * stk_dist (x, y, pairwise); % save arguments for the nex call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; end if diff == -1, %%% compute the value (not a derivative) k = Sigma2 * stk_sf_matern (Nu, D, -1); elseif diff == 1, %%% diff wrt param(1) = log(Sigma2) k = Sigma2 * stk_sf_matern (Nu, D, -1); elseif diff == 2, %%% diff wrt param(2) = log(Nu) k = Nu * Sigma2 * stk_sf_matern (Nu, D, 1); elseif diff == 3, %%% diff wrt param(3) = - log(invRho) k = D .* (Sigma2 * stk_sf_matern (Nu, D, 2)); else error ('there must be something wrong here !'); end end % function stk_materncov_iso %% % 1D, 5x5 %!shared param, x, y %! dim = 1; %! param = log ([1.0; 1.5; 2.9]); %! x = stk_sampling_randunif(5, dim); %! y = stk_sampling_randunif(5, dim); %!error stk_materncov_iso(); %!error stk_materncov_iso(param); %!error stk_materncov_iso(param, x); %!test stk_materncov_iso(param, x, y); %!test stk_materncov_iso(param, x, y, -1); %!test stk_materncov_iso(param, x, y, -1, false); %!error stk_materncov_iso(param, x, y, -1, false, pi^2); %!error stk_materncov_iso(param, x, y, -2); %!test stk_materncov_iso(param, x, y, -1); %!error stk_materncov_iso(param, x, y, 0); %!test stk_materncov_iso(param, x, y, 1); %!test stk_materncov_iso(param, x, y, 2); %!test stk_materncov_iso(param, x, y, 3); %!error stk_materncov_iso(param, x, y, 4); %!error stk_materncov_iso(param, x, y, nan); %!error stk_materncov_iso(param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 1.5; 2.9]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif (nx, dim); %! y = stk_sampling_randunif (ny, dim); %!test %! K1 = stk_materncov_iso (param, x, y); %! K2 = stk_materncov_iso (param, x, y, -1); %! assert (isequal (size (K1), [nx ny])); %! assert (stk_isequal_tolabs (K1, K2)); %!test %! for i = 1:3, %! dK = stk_materncov_iso (param, x, y, i); %! assert (isequal (size (dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif(n, dim); %! y = stk_sampling_randunif(n, dim); %! %! K1 = stk_materncov_iso(param, x, y); %! K2 = stk_materncov_iso(param, x, y, -1, true); %! assert(isequal(size(K1), [n n])); %! assert(stk_isequal_tolabs(K2, diag(K1))); %! %! for i = 1:3, %! dK1 = stk_materncov_iso(param, x, y, i); %! dK2 = stk_materncov_iso(param, x, y, i, true); %! assert(isequal(size(dK1), [n n])); %! assert(stk_isequal_tolabs(dK2, diag(dK1))); %! end stk/inst/covfcs/stk_materncov52_iso.m0000664000175000017500000001257612617165717016643 0ustar bectbect% STK_MATERNCOV52_ISO computes the isotropic Matern covariance % % CALL: K = stk_materncov52_iso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and Y, % using the isotropic Matern covariance kernel with nu=5/2 and parameters % PARAM. The output matrix K has size NX x NY, where NX is the number of % rows in X and NY the number of rows in Y. The vector of parameters must % have two elements: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(2) = - log (RHO), where RHO is the range parameter. % % CALL: dK = stk_materncov52_iso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to % PARAM(DIFF) if DIFF~= -1, or the covariance matrix itself if DIFF is % equal to -1 (in which case this is equivalent to stk_materncov_iso % (PARAM, X, Y)). % % CALL: K = stk_materncov52_iso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) % between the sets of locations X and Y. The output K is a vector of % length N, where N is the common number of rows of X and Y. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Paul Feliot % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_materncov52_iso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 param0 pairwise0 D % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % extract parameters from the "param" vector Sigma2 = exp (param(1)); invRho = exp (param(2)); % check parameter values if ~ (Sigma2 > 0) || ~ (invRho >= 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) ... || ~ isequal ({x, y, param}, {x0, y0, param0}) ... || ~ isequal (pairwise, pairwise0) % compute the distance matrix D = invRho * stk_dist (x, y, pairwise); % save arguments for the nex call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; end if diff == -1, %%% compute the value (not a derivative) k = Sigma2 * stk_sf_matern52 (D, -1); elseif diff == 1, %%% diff wrt param(1) = log(Sigma2) k = Sigma2 * stk_sf_matern52 (D, -1); elseif diff == 2, %%% diff wrt param(3) = - log(invRho) k = D .* (Sigma2 * stk_sf_matern52 (D, 1)); else error ('there must be something wrong here !'); end end % function stk_materncov52_iso %% % 1D, 5x5 %!shared param, x, y %! dim = 1; %! param = log ([1.0; 2.5]); %! x = stk_sampling_randunif (5, dim); %! y = stk_sampling_randunif (5, dim); %!error stk_materncov52_iso (); %!error stk_materncov52_iso (param); %!error stk_materncov52_iso (param, x); %!test stk_materncov52_iso (param, x, y); %!test stk_materncov52_iso (param, x, y, -1); %!test stk_materncov52_iso (param, x, y, -1, false); %!error stk_materncov52_iso (param, x, y, -1, false, pi^2); %!error stk_materncov52_iso (param, x, y, -2); %!test stk_materncov52_iso (param, x, y, -1); %!error stk_materncov52_iso (param, x, y, 0); %!test stk_materncov52_iso (param, x, y, 1); %!test stk_materncov52_iso (param, x, y, 2); %!error stk_materncov52_iso (param, x, y, 3); %!error stk_materncov52_iso (param, x, y, nan); %!error stk_materncov52_iso (param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 2.5]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif (nx, dim); %! y = stk_sampling_randunif (ny, dim); %!test %! K1 = stk_materncov52_iso (param, x, y); %! K2 = stk_materncov52_iso (param, x, y, -1); %! assert (isequal (size (K1), [nx ny])); %! assert (stk_isequal_tolabs (K1, K2)); %!test %! for i = 1:2, %! dK = stk_materncov52_iso (param, x, y, i); %! assert (isequal (size (dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif (n, dim); %! y = stk_sampling_randunif (n, dim); %! %! K1 = stk_materncov52_iso (param, x, y); %! K2 = stk_materncov52_iso (param, x, y, -1, true); %! assert (isequal (size (K1), [n n])); %! assert (stk_isequal_tolabs (K2, diag (K1))); %! %! for i = 1:2, %! dK1 = stk_materncov52_iso (param, x, y, i); %! dK2 = stk_materncov52_iso (param, x, y, i, true); %! assert (isequal (size (dK1), [n n])); %! assert (stk_isequal_tolabs (dK2, diag (dK1))); %! end stk/inst/covfcs/stk_materncov_aniso.m0000664000175000017500000001512612617165717017005 0ustar bectbect% STK_MATERNCOV_ANISO computes the anisotropic Matern covariance % % CALL: K = stk_materncov_aniso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and Y, % using the anisotropic Matern covariance kernel with parameters PARAM. % The output matrix K has size NX x NY, where NX is the number of rows in % X and NY the number of rows in Y. The vector of parameters must have % DIM + 1 elements, where DIM is the common number of columns of X and Y: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(2) = log(NU), where NU is the regularity parameter, % % * PARAM(2+i) = - log (RHO(i)), where RHO(i) is the range parameter for % the ith dimension. % % CALL: dK = stk_materncov_aniso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to % PARAM(DIFF) if DIFF~= -1, or the covariance matrix itself if DIFF is % equal to -1 (in which case this is equivalent to stk_materncov_aniso % (PARAM, X, Y)). % % CALL: K = stk_materncov_aniso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) % between the sets of locations X and Y. The output K is a vector of % length N, where N is the common number of rows of X and Y. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Paul Feliot % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_materncov_aniso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 xs ys param0 pairwise0 D Kx_cache compute_Kx_cache % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % check size consistency dim = size (x, 2); if (size (y, 2) ~= dim), stk_error ('xi and yi have incompatible sizes.', 'InvalidArgument'); end % check param nb_params = dim + 2; if (numel (param) ~= nb_params) stk_error ('xi and param have incompatible sizes.', 'InvalidArgument'); else param = reshape (param, 1, nb_params); % row vector end % extract parameters from the "param" vector Sigma2 = exp (param(1)); Nu = exp (param(2)); invRho = exp (param(3:end)); % check parameter values if ~ (Sigma2 > 0) || ~ (Nu > 0) || ~ all (invRho >= 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) ... || ~ isequal ({x, y, param}, {x0, y0, param0}) ... || ~ isequal (pairwise, pairwise0) % compute the distance matrix xs = bsxfun (@times, x, invRho); ys = bsxfun (@times, y, invRho); D = stk_dist (xs, ys, pairwise); % save arguments for the next call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; % recomputation of Kx_cache is required compute_Kx_cache = true; end if diff == -1, %%% compute the value (not a derivative) k = Sigma2 * stk_sf_matern (Nu, D, -1); elseif diff == 1, %%% diff wrt param(1) = log(Sigma2) k = Sigma2 * stk_sf_matern (Nu, D, -1); elseif diff == 2, %%% diff wrt param(2) = log(Nu) k = Nu * Sigma2 * stk_sf_matern (Nu, D, 1); elseif (diff >= 3) && (diff <= nb_params), %%% diff wrt param(diff) = - log(invRho(diff-2)) ind = diff - 2; if compute_Kx_cache || isempty (Kx_cache) Kx_cache = 1./(D+eps) .* (Sigma2 * stk_sf_matern (Nu, D, 2)); compute_Kx_cache = false; end if pairwise, k = (xs(:, ind) - ys(:, ind)) .^ 2 .* Kx_cache; else k = (bsxfun (@minus, xs(:, ind), ys(:, ind)')) .^ 2 .* Kx_cache; end else stk_error ('Incorrect value for the ''diff'' parameter.', ... 'InvalidArgument'); end end % function stk_materncov_aniso %% % 1D, 5x5 %!shared param, x, y %! dim = 1; %! param = log ([1.0; 1.5; 2.8]); %! x = stk_sampling_randunif(5, dim); %! y = stk_sampling_randunif(5, dim); %!error stk_materncov_aniso(); %!error stk_materncov_aniso(param); %!error stk_materncov_aniso(param, x); %!test stk_materncov_aniso(param, x, y); %!test stk_materncov_aniso(param, x, y, -1); %!test stk_materncov_aniso(param, x, y, -1, false); %!error stk_materncov_aniso(param, x, y, -1, false, pi^2); %!error stk_materncov_aniso(param, x, y, -2); %!test stk_materncov_aniso(param, x, y, -1); %!error stk_materncov_aniso(param, x, y, 0); %!test stk_materncov_aniso(param, x, y, 1); %!test stk_materncov_aniso(param, x, y, 2); %!test stk_materncov_aniso(param, x, y, 3); %!error stk_materncov_aniso(param, x, y, 4); %!error stk_materncov_aniso(param, x, y, nan); %!error stk_materncov_aniso(param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 1.5; 2.8; 2.7; 2.9]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif(nx, dim); %! y = stk_sampling_randunif(ny, dim); %!test %! K1 = stk_materncov_aniso(param, x, y); %! K2 = stk_materncov_aniso(param, x, y, -1); %! assert(isequal(size(K1), [nx ny])); %! assert(stk_isequal_tolabs(K1, K2)); %!test %! for i = 1:(dim+2), %! dK = stk_materncov_aniso(param, x, y, i); %! assert(isequal(size(dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif(n, dim); %! y = stk_sampling_randunif(n, dim); %! %! K1 = stk_materncov_aniso(param, x, y); %! K2 = stk_materncov_aniso(param, x, y, -1, true); %! assert(isequal(size(K1), [n n])); %! assert(stk_isequal_tolabs(K2, diag(K1))); %! %! for i = 1:(dim+2), %! dK1 = stk_materncov_aniso(param, x, y, i); %! dK2 = stk_materncov_aniso(param, x, y, i, true); %! assert(isequal(size(dK1), [n n])); %! assert(stk_isequal_tolabs(dK2, diag(dK1))); %! end stk/inst/covfcs/stk_materncov52_aniso.m0000664000175000017500000001475112617165717017157 0ustar bectbect% STK_MATERNCOV52_ANISO computes the anisotropic Matern covariance with nu=5/2 % % CALL: K = stk_materncov52_aniso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and Y, % using the anisotropic Matern covariance kernel with nu=5/2 and % parameters PARAM. The output matrix K has size NX x NY, where NX is the % number of rows in X and NY the number of rows in Y. The vector of % parameters must have DIM + 1 elements, where DIM is the common number % of columns of X and Y: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(1+i) = - log (RHO(i)), where RHO(i) is the range parameter for % the i-th dimension. % % CALL: dK = stk_materncov52_aniso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to % PARAM(DIFF) if DIFF~= -1, or the covariance matrix itself if DIFF is % equal to -1 (in which case this is equivalent to stk_materncov_aniso % (PARAM, X, Y)). % % CALL: K = stk_materncov52_aniso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) % between the sets of locations X and Y. The output K is a vector of % length N, where N is the common number of rows of X and Y. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Paul Feliot % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_materncov52_aniso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 xs ys param0 pairwise0 D Kx_cache compute_Kx_cache % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % check consistency for the number of factors dim = size (x, 2); if (size (y, 2) ~= dim), stk_error ('xi and yi have incompatible sizes.', 'InvalidArgument'); end % check param nb_params = dim + 1; if (numel (param) ~= nb_params) stk_error ('xi and param have incompatible sizes.', 'InvalidArgument'); else param = reshape (param, 1, nb_params); % row vector end % extract parameters from the "param" vector Sigma2 = exp (param(1)); invRho = exp (param(2:end)); % check parameter values if ~ (Sigma2 > 0) || ~ all (invRho >= 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) ... || ~ isequal ({x, y, param}, {x0, y0, param0}) ... || ~ isequal (pairwise, pairwise0) % compute the distance matrix xs = bsxfun (@times, x, invRho); ys = bsxfun (@times, y, invRho); D = stk_dist (xs, ys, pairwise); % save arguments for the next call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; % recomputation of Kx_cache is required compute_Kx_cache = true; end if diff == -1, %%% compute the value (not a derivative) k = Sigma2 * stk_sf_matern52 (D, -1); elseif diff == 1, %%% diff wrt param(1) = log(Sigma2) k = Sigma2 * stk_sf_matern52 (D, -1); elseif (diff >= 2) && (diff <= nb_params), %%% diff wrt param(diff) = - log(invRho(diff-1)) ind = diff - 1; if compute_Kx_cache || isempty (Kx_cache) Kx_cache = 1 ./ (D + eps) .* (Sigma2 * stk_sf_matern52 (D, 1)); compute_Kx_cache = false; end if pairwise, k = (xs(:, ind) - ys(:, ind)).^2 .* Kx_cache; else k = (bsxfun (@minus, xs(:, ind), ys(:, ind)')) .^ 2 .* Kx_cache; end else stk_error ('Incorrect value for the ''diff'' parameter.', ... 'InvalidArgument'); end end % function stk_materncov52_aniso %% % 1D, 5x5 %!shared param, x, y %! dim = 1; %! param = log ([1.0; 2.5]); %! x = stk_sampling_randunif (5, dim); %! y = stk_sampling_randunif (5, dim); %!error stk_materncov52_aniso (); %!error stk_materncov52_aniso (param); %!error stk_materncov52_aniso (param, x); %!test stk_materncov52_aniso (param, x, y); %!test stk_materncov52_aniso (param, x, y, -1); %!test stk_materncov52_aniso (param, x, y, -1, false); %!error stk_materncov52_aniso (param, x, y, -1, false, pi^2); %!error stk_materncov52_aniso (param, x, y, -2); %!test stk_materncov52_aniso (param, x, y, -1); %!error stk_materncov52_aniso (param, x, y, 0); %!test stk_materncov52_aniso (param, x, y, 1); %!test stk_materncov52_aniso (param, x, y, 2); %!error stk_materncov52_aniso (param, x, y, 3); %!error stk_materncov52_aniso (param, x, y, nan); %!error stk_materncov52_aniso (param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 2.5; 2.4; 2.6]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif (nx, dim); %! y = stk_sampling_randunif (ny, dim); %!test %! K1 = stk_materncov52_aniso (param, x, y); %! K2 = stk_materncov52_aniso (param, x, y, -1); %! assert (isequal (size (K1), [nx ny])); %! assert (stk_isequal_tolabs (K1, K2)); %!test %! for i = 1:(dim + 1), %! dK = stk_materncov52_aniso (param, x, y, i); %! assert (isequal (size (dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif (n, dim); %! y = stk_sampling_randunif (n, dim); %! %! K1 = stk_materncov52_aniso (param, x, y); %! K2 = stk_materncov52_aniso(param, x, y, -1, true); %! assert (isequal (size (K1), [n n])); %! assert (stk_isequal_tolabs (K2, diag (K1))); %! %! for i = 1:(dim + 1), %! dK1 = stk_materncov52_aniso (param, x, y, i); %! dK2 = stk_materncov52_aniso (param, x, y, i, true); %! assert (isequal (size (dK1), [n n])); %! assert (stk_isequal_tolabs (dK2, diag (dK1))); %! end stk/inst/covfcs/stk_materncov32_iso.m0000664000175000017500000001254512617165717016635 0ustar bectbect% STK_MATERNCOV32_ISO computes the isotropic Matern covariance with nu=3/2 % % CALL: K = stk_materncov32_iso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and % Y, using the isotropic Matern covariance kernel with nu=3/2 and % parameters PARAM. The output matrix K has size NX x NY, where NX is % the number of rows in X and NY the number of rows in Y. The vector of % parameters must have two elements: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(2) = - log (RHO), where RHO is the range parameter. % % CALL: dK = stk_materncov32_iso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to % PARAM(DIFF) if DIFF~= -1, or the covariance matrix itself if DIFF is % equal to -1 (in which case this is equivalent to stk_materncov_iso % (PARAM, X, Y)). % % CALL: K = stk_materncov32_iso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) % between the sets of locations X and Y. The output K is a vector of % length N, where N is the common number of rows of X and Y. % Copyright Notice % % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Paul Feliot % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_materncov32_iso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 param0 pairwise0 D % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % extract parameters from the "param" vector Sigma2 = exp (param(1)); invRho = exp (param(2)); % check parameter values if ~ (Sigma2 > 0) || ~ (invRho >= 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) ... || ~ isequal ({x, y, param}, {x0, y0, param0}) ... || ~ isequal (pairwise, pairwise0) % compute the distance matrix D = invRho * stk_dist (x, y, pairwise); % save arguments for the nex call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; end if diff == -1, %%% compute the value (not a derivative) k = Sigma2 * stk_sf_matern32 (D, -1); elseif diff == 1, %%% diff wrt param(1) = log(Sigma2) k = Sigma2 * stk_sf_matern32 (D, -1); elseif diff == 2, %%% diff wrt param(3) = - log(invRho) k = D .* (Sigma2 * stk_sf_matern32 (D, 1)); else error ('there must be something wrong here !'); end end % function stk_materncov32_iso %% % 1D, 5x5 %!shared param, x, y %! dim = 1; %! param = log ([1.0; 2.5]); %! x = stk_sampling_randunif (5, dim); %! y = stk_sampling_randunif (5, dim); %!error stk_materncov32_iso (); %!error stk_materncov32_iso (param); %!error stk_materncov32_iso (param, x); %!test stk_materncov32_iso (param, x, y); %!test stk_materncov32_iso (param, x, y, -1); %!test stk_materncov32_iso (param, x, y, -1, false); %!error stk_materncov32_iso (param, x, y, -1, false, pi^2); %!error stk_materncov32_iso (param, x, y, -2); %!test stk_materncov32_iso (param, x, y, -1); %!error stk_materncov32_iso (param, x, y, 0); %!test stk_materncov32_iso (param, x, y, 1); %!test stk_materncov32_iso (param, x, y, 2); %!error stk_materncov32_iso (param, x, y, 3); %!error stk_materncov32_iso (param, x, y, nan); %!error stk_materncov32_iso (param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 2.5]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif (nx, dim); %! y = stk_sampling_randunif (ny, dim); %!test %! K1 = stk_materncov32_iso (param, x, y); %! K2 = stk_materncov32_iso (param, x, y, -1); %! assert (isequal (size (K1), [nx ny])); %! assert (stk_isequal_tolabs (K1, K2)); %!test %! for i = 1:2, %! dK = stk_materncov32_iso (param, x, y, i); %! assert (isequal (size (dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif (n, dim); %! y = stk_sampling_randunif (n, dim); %! %! K1 = stk_materncov32_iso (param, x, y); %! K2 = stk_materncov32_iso (param, x, y, -1, true); %! assert (isequal (size (K1), [n n])); %! assert (stk_isequal_tolabs (K2, diag (K1))); %! %! for i = 1:2, %! dK1 = stk_materncov32_iso (param, x, y, i); %! dK2 = stk_materncov32_iso (param, x, y, i, true); %! assert (isequal (size (dK1), [n n])); %! assert (stk_isequal_tolabs (dK2, diag (dK1))); %! end stk/inst/covfcs/stk_discretecov.m0000664000175000017500000000725512617165716016133 0ustar bectbect% STK_DISCRETECOV computes a covariance matrix for a discrete model % % CALL: K = stk_discretecov (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and % Y, using the discrete model (a kriging model on a discrete space) % parameters PARAM. The inputs arguments X and Y are expected to be % vectors of indices. The output matrix K has size NX x NY, where NX is % the length of X and NY the length of Y. PARAM must contain a field % PARAM.K which is the full covariance matrix on the discrete input % space. % % CALL: K = stk_discretecov (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance *vector* between the sets of locations X and % Y if PAIRWISE is TRUE, and the covariance *matrix* otherwise. In the % first case, the output K is a vector of length N, where N is the % common number of rows of X and Y. In the second, it is an NX x NY % matrix as above. The argument DIFF has no effect, but must be equal % to -1 since this is not a parametric model. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2013, 2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function K = stk_discretecov (param, x, y, diff, pairwise) %--- process input arguments --------------------------------------------------- x = double (x); y = double (y); if (nargin >= 4) && (diff ~= -1), stk_error ('diff should be equal to -1', 'InvalidArgument'); end if nargin < 5, pairwise = false; end %--- compute covariance matrix ------------------------------------------------- if ~pairwise, K = param.K(x, y); else idx = sub2ind (size (param.K), x, y); K = param.K(idx); end end % function stk_discretecov %!shared model, model2, x0 %! n0 = 20; n1 = 10; dim = 4; %! x0 = stk_sampling_randunif (n0, dim); %! x1 = stk_sampling_randunif (n1, dim); %! model = stk_model ('stk_materncov52_aniso', dim); %! model.order = 1; %! model.param = log ([1.0; 2.1; 2.2; 2.3; 2.4]); %!test % without noise, pairwise = false %! model.lognoisevariance = - inf; %! model2 = stk_model ('stk_discretecov', model, x0); %! idx = [1 4 9]; %! [K1, P1] = stk_make_matcov (model, x0(idx, :)); %! [K2, P2] = stk_make_matcov (model2, idx'); %! assert (stk_isequal_tolrel (K1, K2)); %! assert (stk_isequal_tolrel (P1, P2)); %!test % without noise, pairwise = true %! K1 = stk_make_matcov (model, x0([2 5 6], :), [], true); %! K2 = stk_make_matcov (model2, [2 5 6]', [], true); %! assert (stk_isequal_tolrel (K1, K2)); %!test % with noise, pairwise = false %! model.lognoisevariance = log (0.01); %! model2 = stk_model ('stk_discretecov', model, x0); %! idx = [1 4 9]; %! [K1, P1] = stk_make_matcov (model, x0(idx, :)); %! [K2, P2] = stk_make_matcov (model2, idx'); %! assert (stk_isequal_tolrel (K1, K2)); %! assert (stk_isequal_tolrel (P1, P2)); stk/inst/covfcs/stk_materncov32_aniso.m0000664000175000017500000001565612617165717017162 0ustar bectbect% STK_MATERNCOV32_ANISO computes the anisotropic Matern covariance with nu=3/2 % % CALL: K = stk_materncov32_aniso (PARAM, X, Y) % % computes the covariance matrix K between the sets of locations X and Y, % using the anisotropic Matern covariance kernel with nu=3/2 and % parameters PARAM. The output matrix K has size NX x NY, where NX is the % number of rows in X and NY the number of rows in Y. The vector of % parameters must have DIM + 1 elements, where DIM is the common number % of columns of X and Y: % % * PARAM(1) = log (SIGMA ^ 2), where SIGMA is the standard deviation, % % * PARAM(1+i) = - log (RHO(i)), where RHO(i) is the range parameter % for the ith dimension. % % CALL: dK = stk_materncov32_aniso (PARAM, X, Y, DIFF) % % computes the derivative of the covariance matrix with respect to % PARAM(DIFF) if DIFF~= -1, or the covariance matrix itself if DIFF is % equal to -1 (in which case this is equivalent to stk_materncov_aniso % (PARAM, X, Y)). % % CALL: K = stk_materncov32_aniso (PARAM, X, Y, DIFF, PAIRWISE) % % computes the covariance vector (or a derivative of it if DIFF > 0) % between the sets of locations X and Y. The output K is a vector of % length N, where N is the common number of rows of X and Y. % Copyright Notice % % Copyright (C) 2015 CentraleSupelec % Copyright (C) 2011-2014 SUPELEC % % Authors: Julien Bect % Emmanuel Vazquez % Paul Feliot % Copying Permission Statement % % This file is part of % % STK: a Small (Matlab/Octave) Toolbox for Kriging % (http://sourceforge.net/projects/kriging) % % STK is free software: you can redistribute it and/or modify it under % the terms of the GNU General Public License as published by the Free % Software Foundation, either version 3 of the License, or (at your % option) any later version. % % STK 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 STK. If not, see . function k = stk_materncov32_aniso (param, x, y, diff, pairwise) if nargin > 5, stk_error ('Too many input arguments.', 'TooManyInputArgs'); end persistent x0 y0 xs ys param0 pairwise0 D Kx_cache compute_Kx_cache % process input arguments x = double (x); y = double (y); if nargin < 4, diff = -1; end if nargin < 5, pairwise = false; end % check consistency for the number of factors dim = size (x, 2); if (size (y, 2) ~= dim), stk_error ('xi and yi have incompatible sizes.', 'InvalidArgument'); end % check param nb_params = dim + 1; if (numel (param) ~= nb_params) stk_error ('xi and param have incompatible sizes.', 'InvalidArgument'); else param = reshape (param, 1, nb_params); % row vector end % extract parameters from the "param" vector Sigma2 = exp (param(1)); invRho = exp (param(2:end)); % check parameter values if ~ (Sigma2 > 0) || ~ all (invRho >= 0), error ('Incorrect parameter value.'); end % check if all input arguments are the same as before % (or if this is the first call to the function) if isempty (x0) || isempty (y0) || isempty (param0) ... || ~ isequal ({x, y, param}, {x0, y0, param0}) ... || ~ isequal (pairwise, pairwise0) % compute the distance matrix xs = bsxfun (@times, x, invRho); ys = bsxfun (@times, y, invRho); D = stk_dist (xs, ys, pairwise); % save arguments for the next call x0 = x; y0 = y; param0 = param; pairwise0 = pairwise; % recomputation of Kx_cache is required compute_Kx_cache = true; end if diff == -1, %%% compute the value (not a derivative) k = Sigma2 * stk_sf_matern32 (D, -1); elseif diff == 1, %%% diff wrt param(1) = log(Sigma2) k = Sigma2 * stk_sf_matern32 (D, -1); elseif (diff >= 2) && (diff <= nb_params), %%% diff wrt param(diff) = - log(invRho(diff-1)) ind = diff - 1; if compute_Kx_cache || isempty (Kx_cache) Kx_cache = 1 ./ (D + eps) .* (Sigma2 * stk_sf_matern32 (D, 1)); compute_Kx_cache = false; end if pairwise, k = (xs(:, ind) - ys(:, ind)).^2 .* Kx_cache; else k = (bsxfun (@minus, xs(:, ind), ys(:, ind)')) .^ 2 .* Kx_cache; end else stk_error ('Incorrect value for the ''diff'' parameter.', ... 'InvalidArgument'); end end % function stk_materncov32_aniso %% % 1D, 5x5 %!shared param, x, y, K1, K2, K3 %! dim = 1; %! param = log ([1.0; 2.5]); %! x = stk_sampling_randunif (5, dim); %! y = stk_sampling_randunif (6, dim); %!error K0 = stk_materncov32_aniso (); %!error K0 = stk_materncov32_aniso (param); %!error K0 = stk_materncov32_aniso (param, x); %!test K1 = stk_materncov32_aniso (param, x, y); %!test K2 = stk_materncov32_aniso (param, x, y, -1); %!test K3 = stk_materncov32_aniso (param, x, y, -1, false); %!error K0 = stk_materncov32_aniso (param, x, y, -1, false, pi^2); %!assert (isequal (K1, K2)); %!assert (isequal (K1, K3)); %!test % various types of input arguments %! u = double (x); v = double (y); %! K1 = stk_materncov32_aniso (param, u, v, -1); %! K2 = stk_materncov32_aniso (param, struct ('a', u), struct ('a', v), -1); %! K3 = stk_materncov32_aniso (param, stk_dataframe (u), stk_dataframe (v), -1); %! assert (isequal (K1, K2)); %! assert (isequal (K1, K3)); %!error stk_materncov32_aniso (param, x, y, -2); %!test stk_materncov32_aniso (param, x, y, -1); %!error stk_materncov32_aniso (param, x, y, 0); %!test stk_materncov32_aniso (param, x, y, 1); %!test stk_materncov32_aniso (param, x, y, 2); %!error stk_materncov32_aniso (param, x, y, 3); %!error stk_materncov32_aniso (param, x, y, nan); %!error stk_materncov32_aniso (param, x, y, inf); %% % 3D, 4x10 %!shared dim, param, x, y, nx, ny %! dim = 3; %! param = log ([1.0; 2.5; 2.4; 2.6]); %! nx = 4; ny = 10; %! x = stk_sampling_randunif (nx, dim); %! y = stk_sampling_randunif (ny, dim); %!test %! K1 = stk_materncov32_aniso (param, x, y); %! K2 = stk_materncov32_aniso (param, x, y, -1); %! assert (isequal (size(K1), [nx ny])); %! assert (stk_isequal_tolabs (K1, K2)); %!test %! for i = 1:(dim + 1), %! dK = stk_materncov32_aniso (param, x, y, i); %! assert (isequal (size (dK), [nx ny])); %! end %!test %! n = 7; %! x = stk_sampling_randunif (n, dim); %! y = stk_sampling_randunif (n, dim); %! %! K1 = stk_materncov32_aniso (param, x, y); %! K2 = stk_materncov32_aniso (param, x, y, -1, true); %! assert (isequal (size (K1), [n n])); %! assert (stk_isequal_tolabs (K2, diag (K1))); %! %! for i = 1:(dim + 1), %! dK1 = stk_materncov32_aniso (param, x, y, i); %! dK2 = stk_materncov32_aniso (param, x, y, i, true); %! assert (isequal (size (dK1), [n n])); %! assert (stk_isequal_tolabs (dK2, diag (dK1))); %! end stk/post_install.m0000664000175000017500000000237012617165721013200 0ustar bectbect# POST_INSTALL is run after the installation of the package # Copyright Notice # # Copyright (C) 2014 SUPELEC # Copyright (C) 2015 CentraleSupelec # # Author: Julien Bect # Copying Permission Statement # # This file is part of # # STK: a Small (Matlab/Octave) Toolbox for Kriging # (http://sourceforge.net/projects/kriging) # # STK is free software: you can redistribute it and/or modify it under # the terms of the GNU General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your # option) any later version. # # STK 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 STK. If not, see . function post_install (desc) root = desc.dir; config = fullfile (root, "config"); # Prune unused functions from the MOLE addpath (config); stk_config_mole (root, false, true); rmpath (config); endfunction stk/DESCRIPTION0000664000175000017500000000167312617165721012022 0ustar bectbectName: STK # Version: 2.3.4 # Date: 06-Nov-2015 # Title: STK: A Small Toolbox for Kriging # Author: See AUTHORS file # Maintainer: Julien BECT and Emmanuel VAZQUEZ # Description: The STK is a (not so) Small Toolbox for Kriging. Its primary focus is on the interpolation/regression technique known as kriging, which is very closely related to Splines and Radial Basis Functions, and can be interpreted as a non-parametric Bayesian method using a Gaussian Process (GP) prior. The STK also provides tools for the sequential and non-sequential design of experiments. Even though it is, currently, mostly geared towards the Design and Analysis of Computer Experiments (DACE), the STK can be useful for other applications areas (such as Geostatistics, Machine Learning, Non-parametric Regression, etc.). # Url: https://sourceforge.net/projects/kriging/ # Depends: octave (>= 3.2.2) # Autoload: no