gsl-1.15.3/0000755000175000017500000000000012220252463011742 5ustar boutilboutilgsl-1.15.3/COPYING0000644000175000017500000004307612220252463013007 0ustar boutilboutil GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) 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 this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. 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. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the 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 a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE 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. END OF TERMS AND CONDITIONS Appendix: 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 convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision 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, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This 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 Library General Public License instead of this License. gsl-1.15.3/README0000644000175000017500000000145612220252463012630 0ustar boutilboutil=begin == Description Ruby/GSL, a ruby interface to GSL (GNU Scientific library) == Installation (0) Make sure the command "gsl-config" is in search path. (1) % ruby setup.rb config (2) % ruby setup.rb setup (3) % ruby setup.rb install (as root) See also html/index.html. == Reference See (()). == Licence Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. == Bug Report Any bug reports are welcome. If you encounter bugs in Ruby/GSL, please e-mail to me, or submit reports from http://rubyforge.org/projects/rb-gsl/. == Author Yoshiki Tsunesada y-tsunesada at mm dot em-net dot ne dot jp =end gsl-1.15.3/include/0000755000175000017500000000000012220252463013365 5ustar boutilboutilgsl-1.15.3/include/rb_gsl_integration.h0000644000175000017500000000074712220252463017421 0ustar boutilboutil/* rb_gsl_integration.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNUintegration General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_INTEGRATION_H___ #define ___RB_GSL_INTEGRATION_H___ #include "gsl/gsl_integration.h" #endif gsl-1.15.3/include/rb_gsl_tensor.h0000644000175000017500000000202212220252463016374 0ustar boutilboutil#ifndef ___RB_TENSOR_H___ #define ___RB_TENSOR_H___ #ifdef HAVE_TENSOR_TENSOR_H #include "rb_gsl.h" #include "rb_gsl_common.h" //#include #include EXTERN VALUE cgsl_tensor, cgsl_tensor_int; enum { TENSOR_ADD, TENSOR_SUB, TENSOR_MUL_ELEMENTS, TENSOR_DIV_ELEMENTS, TENSOR_SCALE, TENSOR_ADD_CONSTANT, TENSOR_ADD_DIAGONAL, TENSOR_PRODUCT, TENSOR_CONTRACT, }; typedef gsl_permutation tensor_indices; typedef struct __rbgsl_tensor { /* tensor *tensor; tensor_indices *indices;*/ tensor *tensor; tensor_indices *indices; } rbgsl_tensor; typedef struct __rbgsl_tensor_int { /* tensor_int *tensor; tensor_indices *indices;*/ tensor_int *tensor; tensor_indices *indices; } rbgsl_tensor_int; rbgsl_tensor* rbgsl_tensor_alloc(const unsigned int rank, const size_t dimension); rbgsl_tensor_int* rbgsl_tensor_int_alloc(const unsigned int rank, const size_t dimension); void rbgsl_tensor_free(rbgsl_tensor*); void rbgsl_tensor_int_free(rbgsl_tensor_int*); #endif #endif gsl-1.15.3/include/templates_on.h0000644000175000017500000001413612220252463016235 0ustar boutilboutil/* If BASE is undefined we use function names like gsl_name() and assume that we are using doubles. If BASE is defined we used function names like gsl_BASE_name() and use BASE as the base datatype */ #if defined(BASE_GSL_COMPLEX_LONG) #define BASE gsl_complex_long_double #define SHORT complex_long_double #define SHORT_REAL long_double #define ATOMIC long double #define USES_LONGDOUBLE 1 #define MULTIPLICITY 2 #define IN_FORMAT "%Lg" #define OUT_FORMAT "%Lg" #define ATOMIC_IO ATOMIC #define ZERO {{0.0L,0.0L}} #define ONE {{1.0L,0.0L}} #define BASE_EPSILON GSL_DBL_EPSILON #elif defined(BASE_GSL_COMPLEX) #define BASE gsl_complex #define SHORT complex #define SHORT_REAL #define ATOMIC double #define MULTIPLICITY 2 #define IN_FORMAT "%lg" #define OUT_FORMAT "%g" #define ATOMIC_IO ATOMIC #define ZERO {{0.0,0.0}} #define ONE {{1.0,0.0}} #define BASE_EPSILON GSL_DBL_EPSILON #elif defined(BASE_GSL_COMPLEX_FLOAT) #define BASE gsl_complex_float #define SHORT complex_float #define SHORT_REAL float #define ATOMIC float #define MULTIPLICITY 2 #define IN_FORMAT "%g" #define OUT_FORMAT "%g" #define ATOMIC_IO ATOMIC #define ZERO {{0.0F,0.0F}} #define ONE {{1.0F,0.0F}} #define BASE_EPSILON GSL_FLT_EPSILON #elif defined(BASE_LONG_DOUBLE) #define BASE long double #define SHORT long_double #define ATOMIC long double #define USES_LONGDOUBLE 1 #define MULTIPLICITY 1 #define IN_FORMAT "%Lg" #define OUT_FORMAT "%Lg" #define ATOMIC_IO ATOMIC #define ZERO 0.0L #define ONE 1.0L #define BASE_EPSILON GSL_DBL_EPSILON #elif defined(BASE_DOUBLE) #define BASE double #define SHORT #define ATOMIC double #define MULTIPLICITY 1 #define IN_FORMAT "%lg" #define OUT_FORMAT "%g" #define ATOMIC_IO ATOMIC #define ZERO 0.0 #define ONE 1.0 #define BASE_EPSILON GSL_DBL_EPSILON #elif defined(BASE_FLOAT) #define BASE float #define SHORT float #define ATOMIC float #define MULTIPLICITY 1 #define IN_FORMAT "%g" #define OUT_FORMAT "%g" #define ATOMIC_IO ATOMIC #define ZERO 0.0F #define ONE 1.0F #define BASE_EPSILON GSL_FLT_EPSILON #elif defined(BASE_ULONG) #define BASE unsigned long #define SHORT ulong #define ATOMIC unsigned long #define MULTIPLICITY 1 #define IN_FORMAT "%lu" #define OUT_FORMAT "%lu" #define ATOMIC_IO ATOMIC #define ZERO 0UL #define ONE 1UL #elif defined(BASE_LONG) #define BASE long #define SHORT long #define ATOMIC long #define MULTIPLICITY 1 #define IN_FORMAT "%ld" #define OUT_FORMAT "%ld" #define ATOMIC_IO ATOMIC #define ZERO 0L #define ONE 1L #elif defined(BASE_UINT) #define BASE unsigned int #define SHORT uint #define ATOMIC unsigned int #define MULTIPLICITY 1 #define IN_FORMAT "%u" #define OUT_FORMAT "%u" #define ATOMIC_IO ATOMIC #define ZERO 0U #define ONE 1U #elif defined(BASE_INT) #define BASE int #define SHORT int #define ATOMIC int #define MULTIPLICITY 1 #define IN_FORMAT "%d" #define OUT_FORMAT "%d" #define ATOMIC_IO ATOMIC #define ZERO 0 #define ONE 1 #elif defined(BASE_USHORT) #define BASE unsigned short #define SHORT ushort #define ATOMIC unsigned short #define MULTIPLICITY 1 #define IN_FORMAT "%hu" #define OUT_FORMAT "%hu" #define ATOMIC_IO ATOMIC #define ZERO 0U #define ONE 1U #elif defined(BASE_SHORT) #define BASE short #define SHORT short #define ATOMIC short #define MULTIPLICITY 1 #define IN_FORMAT "%hd" #define OUT_FORMAT "%hd" #define ATOMIC_IO ATOMIC #define ZERO 0 #define ONE 1 #elif defined(BASE_UCHAR) #define BASE unsigned char #define SHORT uchar #define ATOMIC unsigned char #define MULTIPLICITY 1 #define IN_FORMAT "%u" #define OUT_FORMAT "%u" #define ATOMIC_IO unsigned int #define ZERO 0U #define ONE 1U #elif defined(BASE_CHAR) #define BASE char #define SHORT char #define ATOMIC char #define MULTIPLICITY 1 #define IN_FORMAT "%d" #define OUT_FORMAT "%d" #define ATOMIC_IO int #define ZERO 0 #define ONE 1 #else #error unknown BASE_ directive in source.h #endif #define CONCAT2x(a,b) a ## _ ## b #define CONCAT2(a,b) CONCAT2x(a,b) #define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c #define CONCAT3(a,b,c) CONCAT3x(a,b,c) #define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d #define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) #ifndef USE_QUALIFIER #define QUALIFIER #endif #ifdef USE_QUALIFIER #if defined(BASE_DOUBLE) #define FUNCTION(dir,name) CONCAT3(dir,QUALIFIER,name) #define GSL_TYPE(dir) dir #define VIEW(dir,name) CONCAT2(dir,name) #define QUALIFIED_GSL_TYPE(dir) QUALIFIER dir #define QUALIFIED_VIEW(dir,name) CONCAT3(dir,QUALIFIER,name) #else #define FUNCTION(a,c) CONCAT4(a,SHORT,QUALIFIER,c) #define GSL_TYPE(dir) CONCAT2(dir,SHORT) #define VIEW(dir,name) CONCAT3(dir,SHORT,name) #define QUALIFIED_GSL_TYPE(dir) QUALIFIER CONCAT2(dir,SHORT) #define QUALIFIED_VIEW(dir,name) CONCAT4(dir,SHORT,QUALIFIER,name) #endif #if defined(BASE_GSL_COMPLEX) #define REAL_GSL_TYPE(dir) dir #define REAL_VIEW(dir,name) CONCAT2(dir,name) #define QUALIFIED_REAL_GSL_TYPE(dir) QUALIFIER dir #define QUALIFIED_REAL_VIEW(dir,name) CONCAT3(dir,QUALIFIER,name) #else #define REAL_GSL_TYPE(dir) CONCAT2(dir,SHORT_REAL) #define REAL_VIEW(dir,name) CONCAT3(dir,SHORT_REAL,name) #define QUALIFIED_REAL_GSL_TYPE(dir) QUALIFIER CONCAT2(dir,SHORT_REAL) #define QUALIFIED_REAL_VIEW(dir,name) CONCAT4(dir,SHORT_REAL,QUALIFIER,name) #endif #else #if defined(BASE_DOUBLE) #define FUNCTION(dir,name) CONCAT2(dir,name) #define GSL_TYPE(dir) dir #define VIEW(dir,name) CONCAT2(dir,name) #define QUALIFIED_GSL_TYPE(dir) GSL_TYPE(dir) #define QUALIFIED_VIEW(dir,name) CONCAT2(dir,name) #else #define FUNCTION(a,c) CONCAT3(a,SHORT,c) #define GSL_TYPE(dir) CONCAT2(dir,SHORT) #define VIEW(dir,name) CONCAT3(dir,SHORT,name) #define QUALIFIED_GSL_TYPE(dir) GSL_TYPE(dir) #define QUALIFIED_VIEW(dir,name) CONCAT3(dir,SHORT,name) #endif #if defined(BASE_GSL_COMPLEX) #define REAL_GSL_TYPE(dir) dir #define REAL_VIEW(dir,name) CONCAT2(dir,name) #define QUALIFIED_REAL_GSL_TYPE(dir) dir #define QUALIFIED_REAL_VIEW(dir,name) CONCAT2(dir,name) #else #define REAL_GSL_TYPE(dir) CONCAT2(dir,SHORT_REAL) #define REAL_VIEW(dir,name) CONCAT3(dir,SHORT_REAL,name) #define QUALIFIED_REAL_GSL_TYPE(dir) CONCAT2(dir,SHORT_REAL) #define QUALIFIED_REAL_VIEW(dir,name) CONCAT3(dir,SHORT_REAL,name) #endif #endif #define STRING(x) #x #define EXPAND(x) STRING(x) #define NAME(x) EXPAND(GSL_TYPE(x)) gsl-1.15.3/include/rb_gsl_eigen.h0000644000175000017500000000070412220252463016156 0ustar boutilboutil/* rb_gsl_eigen.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_EIGEN_H___ #define ___RB_GSL_EIGEN_H___ #include "gsl/gsl_eigen.h" #endif gsl-1.15.3/include/rb_gsl_dirac.h0000644000175000017500000000036512220252463016154 0ustar boutilboutil#ifndef ___RB_GSL_DIRAC_H___ #define ___RB_GSL_DIRAC_H___ #include "rb_gsl.h" #include "rb_gsl_common.h" #include "rb_gsl_complex.h" #include "rb_gsl_array.h" #include #include #include #include #endif gsl-1.15.3/include/rb_gsl_rational.h0000644000175000017500000000206212220252463016677 0ustar boutilboutil/* rb_gsl_rational.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or POLYNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_RATIONAL_H___ #define ___RB_GSL_RATIONAL_H___ #include "ruby.h" #include #include #include #include #include "rb_gsl_complex.h" #include "rb_gsl_array.h" #include "rb_gsl_poly.h" typedef struct ___gsl_rational { VALUE num, den; gsl_poly *pnum; gsl_poly *pden; } gsl_rational; gsl_rational* gsl_rational_alloc(); gsl_rational* gsl_rational_new(const gsl_poly *num, const gsl_poly *den); gsl_rational* gsl_rational_new2(const gsl_poly *num, const gsl_poly *den); void gsl_rational_free(gsl_rational *r); #endif gsl-1.15.3/include/rb_gsl_graph.h0000644000175000017500000000246412220252463016175 0ustar boutilboutil/* rb_gsl_graph.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or CHEBNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_GRAPH_H___ #define ___RB_GSL_GRAPH_H___ #include "rb_gsl.h" #include "rb_gsl_array.h" #include "rb_gsl_common.h" typedef struct __rb_gsl_plot { VALUE xdata, ydata; VALUE T; VALUE E; VALUE f; VALUE F; VALUE g; VALUE h; VALUE k; VALUE K; VALUE l; VALUE L; VALUE N; VALUE r; VALUE R; VALUE s; VALUE t; VALUE u; VALUE w; VALUE x; VALUE y; VALUE bg; VALUE bitmap_size; VALUE frame; VALUE frame_line_width; VALUE max_line_length; VALUE page_size; VALUE pen_colors; VALUE rotation; VALUE title_font_name; VALUE title_font_size; VALUE rotate_y_label; VALUE I; VALUE B; VALUE m; VALUE S; VALUE W; VALUE q; VALUE C; VALUE symbol_font_name; VALUE reposition; VALUE blankout; VALUE O; VALUE X, Y; } gsl_graph; gsl_graph* gsl_graph_new(); void gsl_graph_free(gsl_graph *g); #endif gsl-1.15.3/include/rb_gsl_const.h0000644000175000017500000000142312220252463016214 0ustar boutilboutil/* rb_gsl.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_CONST_H___ #define ___RB_GSL_CONST_H___ #include "ruby.h" #include "rb_gsl.h" #ifdef GSL_CONST_OLD #include #include #else #include #include #endif #include EXTERN VALUE mgsl_const_mks, mgsl_const_cgs; #endif gsl-1.15.3/include/rb_gsl_rng.h0000644000175000017500000000077212220252463015662 0ustar boutilboutil/* rb_gsl_rng.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_RNG_H___ #define ___RB_GSL_RNG_H___ #include "ruby.h" #include #include "rb_gsl.h" EXTERN VALUE cgsl_rng; #endif gsl-1.15.3/include/rb_gsl_math.h0000644000175000017500000000136612220252463016025 0ustar boutilboutil/* rb_gsl_math.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_MATH_H___ #define ___RB_GSL_MATH_H___ #include "ruby.h" #include #include "rb_gsl.h" #ifndef GSL_1_3_LATER int gsl_fcmp (const double x1, const double x2, const double epsilon); #endif VALUE rb_gsl_math_complex_eval(gsl_complex (*func)(gsl_complex), VALUE obj); #endif gsl-1.15.3/include/rb_gsl_fit.h0000644000175000017500000000127512220252463015655 0ustar boutilboutil/* rb_gsl_fit.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_FIT_H___ #define ___RB_GSL_FIT_H___ #include "ruby.h" #include #include #include #include #include "rb_gsl_array.h" EXTERN VALUE mgsl_multifit; #endif gsl-1.15.3/include/rb_gsl_common.h0000644000175000017500000002510512220252463016361 0ustar boutilboutil/* rb_gsl_common.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_COMMON_H___ #define ___RB_GSL_COMMON_H___ #include "rb_gsl_config.h" #include "ruby.h" #include #include #include #include #include #include #include #include #include #ifdef HAVE_NARRAY_H #include "narray.h" #include "rb_gsl_with_narray.h" #endif EXTERN ID rb_gsl_id_beg, rb_gsl_id_end, rb_gsl_id_excl, rb_gsl_id_to_a; #ifndef CHECK_FIXNUM #define CHECK_FIXNUM(x) if(!FIXNUM_P(x))rb_raise(rb_eTypeError,"Fixnum expected"); #endif #ifndef Need_Float #define Need_Float(x) (x) = rb_Float(x) #endif #ifndef Need_Float2 #define Need_Float2(x,y) do {\ Need_Float(x);\ Need_Float(y);} while (0) #endif #ifndef COMPLEX_P #define COMPLEX_P(x) (rb_obj_is_kind_of(x,cgsl_complex)) #endif #ifndef CHECK_RNG #define CHECK_RNG(x) if(!rb_obj_is_kind_of(x,cgsl_rng))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Rng expected)"); #endif #ifndef CHECK_COMPLEX #define CHECK_COMPLEX(x) if(!rb_obj_is_kind_of(x,cgsl_complex))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Complex expected)"); #endif #ifndef POLY_P #define POLY_P(x) (rb_obj_is_kind_of(x,cgsl_poly)) #endif #ifndef CHECK_POLY #define CHECK_POLY(x) if(!rb_obj_is_kind_of(x,cgsl_poly))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Poly expected)"); #endif #ifndef CHECK_POLY_INT #define CHECK_POLY_INT(x) if(!rb_obj_is_kind_of(x,cgsl_poly_int))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Poly::Int expected)"); #endif #ifndef RATIONAL_P #define RATIONAL_P(x) (rb_obj_is_kind_of(x,cgsl_rational)) #endif #ifndef CHECK_RATIONAL #define CHECK_RATIONAL(x) if(!rb_obj_is_kind_of(x,cgsl_rational))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Rational expected)"); #endif /*****/ #ifndef BLOCK_P #define BLOCK_P(x) (rb_obj_is_kind_of(x,cgsl_block)) #endif #ifndef CHECK_BLOCK #define CHECK_BLOCK(x) if(!rb_obj_is_kind_of(x,cgsl_block))\ rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Block expected)", rb_class2name(CLASS_OF(x))); #endif #ifndef BLOCK_INT_P #define BLOCK_INT_P(x) (rb_obj_is_kind_of(x,cgsl_block_int)) #endif #ifndef CHECK_BLOCK_INT #define CHECK_BLOCK_INT(x) if(!rb_obj_is_kind_of(x,cgsl_block_int))\ rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Block::Int expected)", rb_class2name(CLASS_OF(x))); #endif #ifndef BLOCK_UCHAR_P #define BLOCK_UCHAR_P(x) (rb_obj_is_kind_of(x,cgsl_block_uchar)) #endif #ifndef CHECK_BLOCK_UCHAR #define CHECK_BLOCK_UCHAR(x) if(!rb_obj_is_kind_of(x,cgsl_block_uchar))\ rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Block::Byte expected)", rb_class2name(CLASS_OF(x))); #endif /*****/ #ifndef VECTOR_P #define VECTOR_P(x) (rb_obj_is_kind_of(x,cgsl_vector)) #endif #ifndef VECTOR_VIEW_P #define VECTOR_VIEW_P(x) ((CLASS_OF(x)==cgsl_vector_view||CLASS_OF(x)==cgsl_vector_col_view||CLASS_OF(x)==cgsl_vector_view_ro||CLASS_OF(x)==cgsl_vector_col_view_ro)) #endif #ifndef VECTOR_ROW_P #define VECTOR_ROW_P(x) ((CLASS_OF(x)==cgsl_vector||CLASS_OF(x)==cgsl_vector_view||CLASS_OF(x)==cgsl_vector_view_ro)) #endif #ifndef VECTOR_COL_P #define VECTOR_COL_P(x) ((CLASS_OF(x)==cgsl_vector_col||CLASS_OF(x)==cgsl_vector_col_view||CLASS_OF(x)==cgsl_vector_col_view_ro)) #endif #ifndef VECTOR_ROW_COL #define VECTOR_ROW_COL(x) ((rb_obj_is_kind_of(x,cgsl_vector_col)||rb_obj_is_kind_of(x,cgsl_vector_int_col))?cgsl_vector_col:cgsl_vector) #endif #ifndef CHECK_VECTOR #define CHECK_VECTOR(x) if(!rb_obj_is_kind_of(x,cgsl_vector))\ rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector expected)", rb_class2name(CLASS_OF(x))); #endif #ifdef HAVE_NARRAY_H #define Data_Get_Vector(obj,sval) do {\ if (NA_IsNArray(obj)) {\ /* Convert obj to GSL::Vector::View */\ obj = rb_gsl_na_to_gsl_vector_view_method(obj);\ }\ CHECK_VECTOR(obj);\ Data_Get_Struct(obj,gsl_vector,sval);\ } while (0) #else #define Data_Get_Vector(obj,sval) do {\ CHECK_VECTOR(obj);\ Data_Get_Struct(obj,gsl_vector,sval);\ } while (0) #endif /******/ #ifndef VECTOR_INT_P #define VECTOR_INT_P(x) (rb_obj_is_kind_of(x,cgsl_vector_int)) #endif #ifndef VECTOR_INT_VIEW_P #define VECTOR_INT_VIEW_P(x) ((CLASS_OF(x)==cgsl_vector_int_view||CLASS_OF(x)==cgsl_vector_int_col_view||CLASS_OF(x)==cgsl_vector_int_view_ro||CLASS_OF(x)==cgsl_vector_int_col_view_ro)) #endif #ifndef VECTOR_INT_ROW_P #define VECTOR_INT_ROW_P(x) ((CLASS_OF(x)==cgsl_vector_int||CLASS_OF(x)==cgsl_vector_int_view||CLASS_OF(x)==cgsl_vector_int_view_ro)) #endif #ifndef VECTOR_INT_COL_P #define VECTOR_INT_COL_P(x) ((CLASS_OF(x)==cgsl_vector_int_col||CLASS_OF(x)==cgsl_vector_int_col_view||CLASS_OF(x)==cgsl_vector_int_col_view_ro)) #endif #ifndef VECTOR_INT_ROW_COL #define VECTOR_INT_ROW_COL(x) (VECTOR_INT_ROW_P(x)?cgsl_vector_int:cgsl_vector_int_col) #endif #ifndef CHECK_VECTOR_INT #define CHECK_VECTOR_INT(x) if(!rb_obj_is_kind_of(x,cgsl_vector_int))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Vector::Int expected)"); #endif /******/ #ifndef VECTOR_COMPLEX_P #define VECTOR_COMPLEX_P(x) (rb_obj_is_kind_of(x,cgsl_vector_complex)) #endif #ifndef VECTOR_COMPLEX_ROW_P #define VECTOR_COMPLEX_ROW_P(x) ((CLASS_OF(x)==cgsl_vector_complex||CLASS_OF(x)==cgsl_vector_complex_view)) #endif #ifndef VECTOR_COMPLEX_COL_P #define VECTOR_COMPLEX_COL_P(x) ((CLASS_OF(x)==cgsl_vector_complex_col||CLASS_OF(x)==cgsl_vector_complex_col_view)) #endif #ifndef VECTOR_COMPLEX_ROW_COL #define VECTOR_COMPLEX_ROW_COL(x) (VECTOR_COMPLEX_ROW_P(x)?cgsl_vector_complex:cgsl_vector_complex_col) #endif #ifndef CHECK_VECTOR_COMPLEX #define CHECK_VECTOR_COMPLEX(x) if(!rb_obj_is_kind_of(x,cgsl_vector_complex))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Vector::Complex expected)"); #endif #ifndef MATRIX_P #define MATRIX_P(x) (rb_obj_is_kind_of(x,cgsl_matrix)) #endif #ifndef CHECK_MATRIX #define CHECK_MATRIX(x) if(!rb_obj_is_kind_of(x,cgsl_matrix))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Matrix expected)"); #endif #define Data_Get_Matrix(obj,sval) do {\ CHECK_MATRIX(obj);\ Data_Get_Struct(obj,gsl_matrix,sval);\ } while (0) #ifndef MATRIX_INT_P #define MATRIX_INT_P(x) (rb_obj_is_kind_of(x,cgsl_matrix_int)) #endif #ifndef CHECK_MATRIX_INT #define CHECK_MATRIX_INT(x) if(!rb_obj_is_kind_of(x,cgsl_matrix_int))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Matrix::Int expected)"); #endif #ifndef MATRIX_COMPLEX_P #define MATRIX_COMPLEX_P(x) (rb_obj_is_kind_of(x,cgsl_matrix_complex)) #endif #ifndef CHECK_MATRIX_COMPLEX #define CHECK_MATRIX_COMPLEX(x) if(!rb_obj_is_kind_of(x,cgsl_matrix_complex))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Matrix::Complex expected)"); #endif #ifndef TENSOR_P #define TENSOR_P(x) ((CLASS_OF(x)==cgsl_tensor)) #endif #ifndef CHECK_TENSOR #define CHECK_TENSOR(x) if(CLASS_OF(x)!=cgsl_tensor)\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Tensor expected)"); #endif #ifndef TENSOR_INT_P #define TENSOR_INT_P(x) ((CLASS_OF(x)==cgsl_tensor_int)) #endif #ifndef CHECK_TENSOR_INT #define CHECK_TENSOR_INT(x) if(CLASS_OF(x)!=cgsl_tensor_int)\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Tensor::Int expected)"); #endif #ifndef PERMUTATION_P #define PERMUTATION_P(x) (rb_obj_is_kind_of(x,cgsl_permutation)) #endif #ifndef CHECK_PERMUTATION #define CHECK_PERMUTATION(x) if(!rb_obj_is_kind_of(x,cgsl_permutation))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Permutation expected)"); #endif #ifndef PROC_P #define PROC_P(x) (rb_obj_is_kind_of(x,rb_cProc)) #endif #ifndef CHECK_PROC #define CHECK_PROC(x) if(!rb_obj_is_kind_of(x,rb_cProc))\ rb_raise(rb_eTypeError, "wrong argument type (Proc expected)"); #endif #ifndef FUNCTION_P #define FUNCTION_P(x) (rb_obj_is_kind_of(x,cgsl_function)) #endif #ifndef CHECK_FUNCTION #define CHECK_FUNCTION(x) if(!rb_obj_is_kind_of(x,cgsl_function))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Function expected)"); #endif #ifndef FUNCTION_FDF_P #define FUNCTION_FDF_P(x) (rb_obj_is_kind_of(x,cgsl_function_fdf)) #endif #ifndef CHECK_FUNCTION_FDF #define CHECK_FUNCTION_FDF(x) if(!rb_obj_is_kind_of(x,cgsl_function_fdf))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Function_fdf expected)"); #endif #ifndef HISTOGRAM_P #define HISTOGRAM_P(x) (rb_obj_is_kind_of(x,cgsl_histogram)) #endif #ifndef CHECK_HISTOGRAM #define CHECK_HISTOGRAM(x) if(!rb_obj_is_kind_of(x,cgsl_histogram))\ rb_raise(rb_eTypeError, "wrong argument type (GSL::Histogram expected)"); #endif void rb_gsl_error_handler(const char *reason, const char *file, int line, int gsl_errno); FILE* rb_gsl_open_writefile(VALUE io, int *flag); FILE* rb_gsl_open_readfile(VALUE io, int *flag); VALUE rb_gsl_obj_read_only(int argc, VALUE *argv, VALUE obj); int str_tail_grep(const char *s0, const char *s1); int str_head_grep(const char *s0, const char *s1); #ifdef RUBY_1_8_LATER #define RB_GSL_MAKE_PROC rb_block_proc() #define STR2CHARPTR StringValuePtr #else #define RB_GSL_MAKE_PROC rb_f_lambda() #define STR2CHARPTR STR2CSTR #endif // Added 2010/Sep/29 #ifdef RUBY_1_9_2_LATER #define STR2CSTR StringValuePtr #endif void make_graphcommand(char *command, VALUE hash); int rbgsl_complex_equal(const gsl_complex *z1, const gsl_complex *z2, double eps); gsl_vector* mygsl_vector_down(gsl_vector *p); void mygsl_vector_up2(gsl_vector *pnew, gsl_vector *p); gsl_vector* mygsl_vector_up(gsl_vector *p); gsl_vector_int* mygsl_vector_int_down(gsl_vector_int *p); void mygsl_vector_int_up2(gsl_vector_int *pnew, gsl_vector_int *p); gsl_vector_int* mygsl_vector_int_up(gsl_vector_int *p); #ifndef GSL_1_3_LATER int gsl_fcmp(const double x1, const double x2, const double epsilon); #endif size_t count_columns(const char *str); char* str_scan_double(const char *str, double *val); char* str_scan_int(const char *str, int *val); double* get_ptr_double3(VALUE obj, size_t *size, size_t *stride, int *flag); gsl_complex ary2complex(VALUE obj); VALUE vector_eval_create(VALUE obj, double (*func)(double)); VALUE matrix_eval_create(VALUE obj, double (*func)(double)); VALUE rb_gsl_ary_eval1(VALUE ary, double (*f)(double)); #ifdef HAVE_NARRAY_H VALUE rb_gsl_nary_eval1(VALUE ary, double (*f)(double)); #endif EXTERN VALUE cGSL_Object; #endif gsl-1.15.3/include/rb_gsl_odeiv.h0000644000175000017500000000114112220252463016171 0ustar boutilboutil/* rb_gsl_odeiv.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_ODEIV_H___ #define ___RB_GSL_ODEIV_H___ #include "ruby.h" #include #include "rb_gsl.h" #include "rb_gsl_array.h" #endif gsl-1.15.3/include/rb_gsl_histogram3d.h0000644000175000017500000001106412220252463017314 0ustar boutilboutil#ifndef ___RB_GSL_HISTOGRAM3D_H___ #define ___RB_GSL_HISTOGRAM3D_H___ typedef struct { size_t nx, ny, nz; double * xrange ; double * yrange ; double * zrange ; double * bin ; } mygsl_histogram3d ; typedef struct { gsl_histogram2d h; } mygsl_histogram3d_view; mygsl_histogram3d* mygsl_histogram3d_alloc(const size_t nx, const size_t ny, const size_t nz); void mygsl_histogram3d_free (mygsl_histogram3d * h); mygsl_histogram3d* mygsl_histogram3d_calloc_uniform(const size_t nx, const size_t ny, const size_t nz, const double xmin, const double xmax, const double ymin, const double ymax, const double zmin, const double zmax); mygsl_histogram3d* mygsl_histogram3d_calloc(const size_t nx, const size_t ny, const size_t nz); int mygsl_histogram3d_set_ranges_uniform (mygsl_histogram3d * h, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax); int mygsl_histogram3d_set_ranges (mygsl_histogram3d * h, const double xrange[], size_t xsize, const double yrange[], size_t ysize, const double zrange[], size_t zsize); int mygsl_histogram3d_memcpy(mygsl_histogram3d * dest, const mygsl_histogram3d * src); mygsl_histogram3d* mygsl_histogram3d_clone(const mygsl_histogram3d * src); int mygsl_histogram3d_fread(FILE * stream, mygsl_histogram3d * h); int mygsl_histogram3d_fwrite(FILE * stream, const mygsl_histogram3d * h); int mygsl_histogram3d_increment(mygsl_histogram3d * h, double x, double y, double z); int mygsl_histogram3d_accumulate (mygsl_histogram3d * h, double x, double y, double z, double weight); int mygsl_histogram3d_increment2(mygsl_histogram3d * h, double x, double y, double z); int mygsl_histogram3d_accumulate2(mygsl_histogram3d * h, double x, double y, double z, double weight); double mygsl_histogram3d_get (const mygsl_histogram3d * h, const size_t i, const size_t j, const size_t k); int mygsl_histogram3d_get_xrange(const mygsl_histogram3d * h, const size_t i, double *xlower, double *xupper); int mygsl_histogram3d_get_yrange(const mygsl_histogram3d * h, const size_t j, double *ylower, double *yupper); int mygsl_histogram3d_get_zrange(const mygsl_histogram3d * h, const size_t k, double *zlower, double *zupper); int mygsl_histogram3d_find (const mygsl_histogram3d * h, const double x, const double y, const double z, size_t * i, size_t * j, size_t *k); gsl_histogram2d* mygsl_histogram3d_xyproject(const mygsl_histogram3d * h3, size_t kstart, size_t kend); gsl_histogram2d* mygsl_histogram3d_xzproject(const mygsl_histogram3d * h3, size_t jstart, size_t jend); gsl_histogram2d* mygsl_histogram3d_yzproject(const mygsl_histogram3d * h3, size_t istart, size_t iend); int mygsl_histogram3d_scale(mygsl_histogram3d * h, double scale); int mygsl_histogram3d_shift(mygsl_histogram3d * h, double shift); double mygsl_histogram3d_xmax(const mygsl_histogram3d * h); double mygsl_histogram3d_xmin(const mygsl_histogram3d * h); double mygsl_histogram3d_ymax(const mygsl_histogram3d * h); double mygsl_histogram3d_ymin(const mygsl_histogram3d * h); double mygsl_histogram3d_zmax(const mygsl_histogram3d * h); double mygsl_histogram3d_zmin(const mygsl_histogram3d * h); double mygsl_histogram3d_max_val(const mygsl_histogram3d * h); void mygsl_histogram3d_max_bin(const mygsl_histogram3d * h, size_t *imax_out, size_t *jmax_out, size_t *kmax_out); double mygsl_histogram3d_min_val(const mygsl_histogram3d * h); void mygsl_histogram3d_min_bin(const mygsl_histogram3d * h, size_t *imin_out, size_t *jmin_out, size_t *kmin_out); double mygsl_histogram3d_sum (const mygsl_histogram3d * h); double mygsl_histogram3d_xmean (const mygsl_histogram3d * h); double mygsl_histogram3d_ymean (const mygsl_histogram3d * h); double mygsl_histogram3d_zmean (const mygsl_histogram3d * h); double mygsl_histogram3d_xsigma(const mygsl_histogram3d * h); double mygsl_histogram3d_ysigma(const mygsl_histogram3d * h); double mygsl_histogram3d_zsigma(const mygsl_histogram3d * h); void mygsl_histogram3d_reset(mygsl_histogram3d * h); int mygsl_histogram3d_equal_bins_p(const mygsl_histogram3d * h1, const mygsl_histogram3d * h2); int mygsl_histogram3d_add(mygsl_histogram3d * h1, const mygsl_histogram3d * h2); int mygsl_histogram3d_sub(mygsl_histogram3d * h1, const mygsl_histogram3d * h2); int mygsl_histogram3d_mul(mygsl_histogram3d * h1, const mygsl_histogram3d * h2); int mygsl_histogram3d_div(mygsl_histogram3d * h1, const mygsl_histogram3d * h2); #endif gsl-1.15.3/include/rb_gsl_poly.h0000644000175000017500000000472412220252463016060 0ustar boutilboutil/* rb_gsl_poly.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or POLYNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_POLY_H___ #define ___RB_GSL_POLY_H___ #include "ruby.h" #include #include #include #include #include "rb_gsl_complex.h" #include "rb_gsl_array.h" EXTERN VALUE cgsl_poly; EXTERN VALUE cgsl_poly_int; EXTERN VALUE cgsl_poly_dd; EXTERN VALUE cgsl_poly_taylor; EXTERN VALUE cgsl_poly_workspace; EXTERN VALUE cgsl_rational; typedef gsl_vector gsl_poly; typedef gsl_vector_int gsl_poly_int; /* typedef struct ___gsl_rational { VALUE num, den; gsl_poly *pnum; gsl_poly *pden; } gsl_rational; */ int gsl_poly_conv(const double *a, size_t na, const double *b, size_t nb, double *c, size_t *nc); gsl_vector* gsl_poly_deconv_vector(const gsl_vector *c, const gsl_vector *a, gsl_vector **r); gsl_vector* gsl_poly_deriv(const gsl_vector *v); gsl_vector* gsl_poly_integ(const gsl_vector *v); gsl_vector* gsl_poly_reduce(const gsl_vector *v); VALUE rb_gsl_poly_complex_solve(int argc, VALUE *argv, VALUE obj); gsl_vector* gsl_poly_conv_vector(const gsl_vector *v1, const gsl_vector *v2); gsl_poly* gsl_poly_add(const gsl_poly *a, const gsl_poly *b); VALUE rb_gsl_poly_deconv(VALUE obj, VALUE bb); VALUE rb_gsl_poly_complex_solve2(int argc, VALUE *argv, VALUE obj); int gsl_poly_int_conv(const int *a, size_t na, const int *b, size_t nb, int *c, size_t *nc); gsl_vector_int* gsl_poly_int_deconv_vector(const gsl_vector_int *c, const gsl_vector_int *a, gsl_vector_int **r); gsl_vector_int* gsl_poly_int_deriv(const gsl_vector_int *v); gsl_vector_int* gsl_poly_int_integ(const gsl_vector_int *v); gsl_vector_int* gsl_poly_int_reduce(const gsl_vector_int *v); VALUE rb_gsl_poly_int_complex_solve(int argc, VALUE *argv, VALUE obj); gsl_vector_int* gsl_poly_int_conv_vector(const gsl_vector_int *v1, const gsl_vector_int *v2); gsl_poly_int* gsl_poly_int_add(const gsl_poly_int *a, const gsl_poly_int *b); VALUE rb_gsl_poly_int_deconv(VALUE obj, VALUE bb); gsl_poly* get_poly_get(VALUE obj, int *flag); gsl_poly_int* get_poly_int_get(VALUE obj, int *flag); #endif gsl-1.15.3/include/rb_gsl_fft.h0000644000175000017500000000262312220252463015650 0ustar boutilboutil/* rb_gsl_fft.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FFTNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_FFT_H___ #define ___RB_GSL_FFT_H___ #include #include #include "ruby.h" #include #include #include #include #include #include #include "rb_gsl_array.h" #include "rb_gsl.h" #include "rb_gsl_complex.h" #include "rb_gsl_array.h" #ifdef HAVE_NARRAY_H #include "narray.h" #endif typedef struct { size_t n; size_t nf; size_t factor[64]; gsl_complex *twiddle[64]; gsl_complex *trig; } GSL_FFT_Wavetable; typedef struct { size_t n; double *scratch; } GSL_FFT_Workspace; enum { RB_GSL_FFT_INPLACE, RB_GSL_FFT_COPY, }; EXTERN VALUE mgsl_fft; EXTERN VALUE cgsl_fft_wavetable; EXTERN VALUE cgsl_fft_wavetable_factor; EXTERN VALUE cgsl_fft_complex_wavetable, cgsl_fft_complex_workspace; EXTERN VALUE cgsl_fft_real_wavetable, cgsl_fft_halfcomplex_wavetable; EXTERN VALUE cgsl_fft_real_workspace; #endif gsl-1.15.3/include/rb_gsl_complex.h0000644000175000017500000000141012220252463016531 0ustar boutilboutil/* rb_gsl_complex.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_COMPLEX_H___ #define ___RB_GSL_COMPLEX_H___ #include #include "ruby.h" #include #include EXTERN VALUE cgsl_complex; VALUE rb_gsl_complex_pow(int argc, VALUE *argv, VALUE obj); VALUE rb_gsl_complex_pow_real(int argc, VALUE *argv, VALUE obj); #endif gsl-1.15.3/include/rb_gsl_histogram.h0000644000175000017500000000343712220252463017072 0ustar boutilboutil/* rb_gsl_histogram.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_HISTOGRAM_H___ #define ___RB_GSL_HISTOGRAM_H___ #include #include #include #include "rb_gsl.h" EXTERN VALUE cgsl_histogram; EXTERN VALUE cgsl_histogram_range; EXTERN VALUE cgsl_histogram_bin; EXTERN VALUE cgsl_histogram2d; EXTERN VALUE cgsl_histogram2d_view; typedef struct { gsl_histogram h; } mygsl_histogram2d_view; #ifndef HISTOGRAM2D_P #define HISTOGRAM2D_P(x) (rb_obj_is_kind_of(x,cgsl_histogram2d)?1:0) #endif #ifndef CHECK_HISTOGRAM2D #define CHECK_HISTOGRAM2D(x) if(!rb_obj_is_kind_of(x,cgsl_histogram2d))\ rb_raise(rb_eTypeError, "wrong type (Histogram2d expected)"); #endif #ifndef HISTOGRAM3D_P #define HISTOGRAM3D_P(x) (rb_obj_is_kind_of(x,cgsl_histogram3d)?1:0) #endif #ifndef CHECK_HISTOGRAM3D #define CHECK_HISTOGRAM3D(x) if(!rb_obj_is_kind_of(x,cgsl_histogram3d))\ rb_raise(rb_eTypeError, "wrong type (Histogram3d expected)"); #endif #include "rb_gsl_histogram3d.h" int mygsl_histogram_equal_bins_p (const gsl_histogram * h1, const gsl_histogram * h2); int mygsl_histogram_add (gsl_histogram * h1, const gsl_histogram * h2); int mygsl_histogram_sub (gsl_histogram * h1, const gsl_histogram * h2); int mygsl_histogram_mul (gsl_histogram * h1, const gsl_histogram * h2); int mygsl_histogram_div (gsl_histogram * h1, const gsl_histogram * h2); #endif gsl-1.15.3/include/rb_gsl_interp.h0000644000175000017500000000201112220252463016361 0ustar boutilboutil/* rb_gsl_interp.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or INTERPOLATIONNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_INTERP_H___ #define ___RB_GSL_INTERP_H___ #include "ruby.h" #include "rb_gsl.h" #include #include #ifdef HAVE_NARRAY_H #include "narray.h" #endif typedef struct { gsl_interp *p; gsl_interp_accel *a; } rb_gsl_interp; typedef struct { gsl_spline *s; gsl_interp_accel *a; } rb_gsl_spline; enum { GSL_INTERP_LINEAR, GSL_INTERP_POLYNOMIAL, GSL_INTERP_CSPLINE, GSL_INTERP_CSPLINE_PERIODIC, GSL_INTERP_AKIMA, GSL_INTERP_AKIMA_PERIODIC, }; const gsl_interp_type* get_interp_type(VALUE t); #endif gsl-1.15.3/include/rb_gsl_linalg.h0000644000175000017500000000126312220252463016336 0ustar boutilboutil/* rb_gsl_linalg.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_LINALG_H___ #define ___RB_GSL_LINALG_H___ #include "gsl/gsl_linalg.h" #include "gsl/gsl_math.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif VALUE rb_gsl_linalg_complex_LU_decomp(int argc, VALUE *argv, VALUE obj); VALUE rb_gsl_linalg_complex_LU_decomp2(int argc, VALUE *argv, VALUE obj); #endif gsl-1.15.3/include/rb_gsl_cheb.h0000644000175000017500000000115612220252463015772 0ustar boutilboutil/* rb_gsl_cheb.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or CHEBNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_CHEB_H___ #define ___RB_GSL_CHEB_H___ #include "rb_gsl.h" #include "rb_gsl_function.h" #include #include #endif gsl-1.15.3/include/rb_gsl_sf.h0000644000175000017500000001202212220252463015473 0ustar boutilboutil/* rb_gsl_sf.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_SF_H___ #define ___RB_GSL_SF_H___ #include "ruby.h" #include #include #include #include #include #include "rb_gsl_config.h" #include "rb_gsl.h" EXTERN VALUE cgsl_sf_result, cgsl_sf_result_e10; VALUE rb_gsl_sf_result_new(VALUE klass); VALUE rb_gsl_sf_eval1(double (*func)(double), VALUE argv); VALUE rb_gsl_sf_eval_int_double(double (*func)(int, double), VALUE jj, VALUE argv); VALUE rb_gsl_sf_eval_double_double(double (*func)(double, double), VALUE ff, VALUE argv); VALUE rb_gsl_sf_eval1_uint(double (*func)(unsigned int), VALUE argv); VALUE rb_gsl_sf_eval_double_m(double (*func)(double, gsl_mode_t), VALUE argv, VALUE m);; VALUE rb_gsl_sf_eval_int_double_double(double (*func)(int, double, double), VALUE jj, VALUE ff, VALUE argv); VALUE rb_gsl_sf_eval_int_int_double(double (*func)(int, int, double), VALUE jj, VALUE jj2, VALUE argv); VALUE rb_gsl_sf_eval_double3(double (*func)(double, double, double), VALUE ff, VALUE ff2, VALUE argv); VALUE rb_gsl_sf_eval_double4(double (*func)(double, double, double, double), VALUE ff, VALUE ff2, VALUE ff3, VALUE argv); VALUE rb_gsl_sf_eval_double_int(double (*func)(double, int), VALUE argv, VALUE jj); VALUE rb_gsl_sf_eval1_int(double (*func)(int), VALUE argv); VALUE rb_gsl_sf_eval_e(int (*func)(double, gsl_sf_result*), VALUE x); VALUE rb_gsl_sf_eval_e_int_double(int (*func)(int, double, gsl_sf_result*), VALUE n, VALUE x); VALUE rb_gsl_sf_eval_e_int_int_double(int (*func)(int, int, double, gsl_sf_result*), VALUE n1, VALUE n2, VALUE x); VALUE rb_gsl_sf_eval_e_double2(int (*func)(double, double, gsl_sf_result*), VALUE x1, VALUE x2); VALUE rb_gsl_sf_eval_e_uint(int (*func)(unsigned int, gsl_sf_result*), VALUE x); VALUE rb_gsl_sf_eval_e_int_uint(int (*func)(int, unsigned int, gsl_sf_result*), VALUE n, VALUE x); VALUE rb_gsl_sf_eval_e_double_uint(int (*func)(double, unsigned int, gsl_sf_result*), VALUE y, VALUE x); VALUE rb_gsl_sf_eval_e_m(int (*func)(double, gsl_mode_t, gsl_sf_result*), VALUE x, VALUE m); VALUE rb_gsl_sf_eval_e_double2_m(int (*func)(double, double, gsl_mode_t, gsl_sf_result*), VALUE x1, VALUE x2, VALUE m); VALUE rb_gsl_sf_eval_e_double3_m(int (*func)(double, double, double, gsl_mode_t, gsl_sf_result*), VALUE x1, VALUE x2, VALUE x3, VALUE m); VALUE rb_gsl_sf_eval_double2_m(double (*func)(double, double, gsl_mode_t), VALUE argv, VALUE x2, VALUE m); VALUE rb_gsl_sf_eval_double3_m(double (*func)(double, double, double, gsl_mode_t), VALUE argv, VALUE x2, VALUE x3, VALUE m); VALUE rb_gsl_sf_eval_e_double4_m(int (*func)(double, double, double, double, gsl_mode_t, gsl_sf_result*), VALUE x1, VALUE x2, VALUE x3, VALUE x4, VALUE m); VALUE rb_gsl_sf_eval_e_int(int (*func)(int, gsl_sf_result*), VALUE x); VALUE rb_gsl_sf_eval_e_double3(int (*func)(double, double, double, gsl_sf_result*), VALUE x1, VALUE x2, VALUE x3); VALUE rb_gsl_sf_eval_e_int_double2(int (*func)(int, double, double, gsl_sf_result*), VALUE n, VALUE x1, VALUE x2); VALUE rb_gsl_sf_eval_e_double2(int (*func)(double, double, gsl_sf_result*), VALUE x1, VALUE x2); VALUE eval_sf(double (*func)(double, gsl_mode_t), VALUE argv); VALUE rb_gsl_sf_eval_double4_m(double (*func)(double, double, double, double, gsl_mode_t), VALUE argv, VALUE x2, VALUE x3, VALUE x4, VALUE m); VALUE rb_gsl_sf_eval_complex(double (*f)(double), VALUE obj); void Init_gsl_sf_airy(VALUE module); void Init_gsl_sf_bessel(VALUE module); void Init_gsl_sf_clausen(VALUE module); void Init_gsl_sf_coulomb(VALUE module); void Init_gsl_sf_coupling(VALUE module); void Init_gsl_sf_dawson(VALUE module); void Init_gsl_sf_debye(VALUE module); void Init_gsl_sf_dilog(VALUE module); void Init_gsl_sf_elementary(VALUE module); void Init_gsl_sf_ellint(VALUE module); void Init_gsl_sf_elljac(VALUE module); void Init_gsl_sf_erfc(VALUE module); void Init_gsl_sf_exp(VALUE module); void Init_gsl_sf_expint(VALUE module); void Init_gsl_sf_fermi_dirac(VALUE module); void Init_gsl_sf_gamma(VALUE module); void Init_gsl_sf_gegenbauer(VALUE module); void Init_gsl_sf_hyperg(VALUE module); void Init_gsl_sf_laguerre(VALUE module); void Init_gsl_sf_lambert(VALUE module); void Init_gsl_sf_legendre(VALUE module); void Init_gsl_sf_log(VALUE module); void Init_gsl_sf_power(VALUE module); void Init_gsl_sf_psi(VALUE module); void Init_gsl_sf_synchrotron(VALUE module); void Init_gsl_sf_transport(VALUE module); void Init_gsl_sf_trigonometric(VALUE module); void Init_gsl_sf_zeta(VALUE module); #ifdef GSL_1_9_LATER #include void Init_sf_mathieu(VALUE module); #endif #endif gsl-1.15.3/include/rb_gsl_function.h0000644000175000017500000000150312220252463016712 0ustar boutilboutil/* rb_gsl_function.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ___RB_GSL_FUNCTION_H___ #define ___RB_GSL_FUNCTION_H___ #include "ruby.h" #include #include #include #include "rb_gsl.h" EXTERN VALUE cgsl_function; EXTERN VALUE cgsl_function_fdf; extern ID RBGSL_ID_call, RBGSL_ID_arity; void gsl_function_mark(gsl_function *f); void gsl_function_free(gsl_function *f); #endif gsl-1.15.3/include/rb_gsl_with_narray.h0000644000175000017500000000161112220252463017414 0ustar boutilboutil#ifndef RB_GSL_WITH_NARRAY_H #define RB_GSL_WITH_NARRAY_H #ifdef HAVE_NARRAY_H #include "narray.h" #include "gsl/gsl_vector.h" gsl_vector* make_cvector_from_narray(VALUE); void cvector_set_from_narray(gsl_vector*, VALUE); void carray_set_from_narray(double*, VALUE); VALUE rb_gsl_na_to_gsl_vector_view_method(VALUE na); VALUE rb_gsl_na_to_gsl_matrix(VALUE obj, VALUE nna); gsl_vector_view* na_to_gv_view(VALUE na); gsl_matrix_view* na_to_gm_view(VALUE nna); gsl_vector_int_view* na_to_gv_int_view(VALUE na); gsl_matrix_int_view* na_to_gm_int_view(VALUE nna); gsl_vector* na_to_gv(VALUE na); gsl_vector_int* na_to_gv_int(VALUE na); gsl_matrix* na_to_gm(VALUE nna); gsl_matrix_int* na_to_gm_int(VALUE nna); extern VALUE cNVector, cNMatrix; gsl_vector_complex* na_to_gv_complex(VALUE na); gsl_vector_complex_view* na_to_gv_complex_view(VALUE na); #endif // HAVE_NARRAY_H #endif // RB_GSL_WITH_NARRAY_H gsl-1.15.3/include/rb_gsl.h0000644000175000017500000000717612220252463015021 0ustar boutilboutil/* rb_gsl.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_H___ #define ___RB_GSL_H___ #include #include #include #include #include #include "rb_gsl_common.h" #include "rb_gsl_math.h" #include "rb_gsl_complex.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #include "rb_gsl_poly.h" #include "rb_gsl_sf.h" #include "rb_gsl_linalg.h" #include "rb_gsl_eigen.h" #include "rb_gsl_fft.h" #include "rb_gsl_integration.h" #include "rb_gsl_rng.h" #include "rb_gsl_statistics.h" #include "rb_gsl_histogram.h" #include "rb_gsl_odeiv.h" #include "rb_gsl_interp.h" #include "rb_gsl_cheb.h" #include "rb_gsl_root.h" #include "rb_gsl_fit.h" #include "rb_gsl_const.h" #include "rb_gsl_config.h" #include "ruby.h" #ifdef RUBY_1_9_LATER #include "ruby/io.h" #else #include "rubyio.h" #endif void Init_gsl_error(VALUE module); void Init_gsl_math(VALUE module); void Init_gsl_complex(VALUE module); void Init_gsl_array(VALUE module); void Init_gsl_blas(VALUE module); void Init_gsl_sort(VALUE module); void Init_gsl_poly(VALUE module); void Init_gsl_poly_int(VALUE module); void Init_gsl_poly2(VALUE module); void Init_gsl_rational(VALUE module); void Init_gsl_sf(VALUE module); void Init_gsl_linalg(VALUE module); void Init_gsl_eigen(VALUE module); void Init_gsl_fft(VALUE module); void Init_gsl_signal(VALUE module); void Init_gsl_function(VALUE module); void Init_gsl_integration(VALUE module); void Init_gsl_rng(VALUE module); void Init_gsl_qrng(VALUE module); void Init_gsl_ran(VALUE module); void Init_gsl_cdf(VALUE module); void Init_gsl_stats(VALUE module); void Init_gsl_histogram(VALUE module); void Init_gsl_histogram2d(VALUE module); void Init_gsl_histogram3d(VALUE module); void Init_gsl_ntuple(VALUE module); void Init_gsl_monte(VALUE module); void Init_gsl_siman(VALUE module); void Init_gsl_odeiv(VALUE module); void Init_gsl_interp(VALUE module); void Init_gsl_spline(VALUE module); void Init_gsl_diff(VALUE module); #ifdef GSL_1_4_9_LATER void Init_gsl_deriv(VALUE module); #endif void Init_gsl_cheb(VALUE module); void Init_gsl_sum(VALUE module); void Init_gsl_dht(VALUE module); void Init_gsl_root(VALUE module); void Init_gsl_multiroot(VALUE module); void Init_gsl_min(VALUE module); void Init_gsl_multimin(VALUE module); void Init_gsl_fit(VALUE module); void Init_gsl_multifit(VALUE module); void Init_gsl_const(VALUE module); void Init_gsl_ieee(VALUE module); #ifdef HAVE_NARRAY_H void Init_gsl_narray(VALUE module); #endif void Init_wavelet(VALUE module); void Init_gsl_graph(VALUE module); #ifdef HAVE_TENSOR_TENSOR_H void Init_tensor_init(VALUE module); void Init_tensor_int_init(VALUE module); #endif void Init_gsl_dirac(VALUE module); EXTERN VALUE cGSL_Object; void Init_tamu_anova(VALUE module); #ifdef HAVE_TAMU_ANOVA_TAMU_ANOVA_H #include "tamu_anova/tamu_anova.h" #endif #ifdef HAVE_OOL_OOL_VERSION_H void Init_ool(VALUE module); #endif #ifdef HAVE_JACOBI_H void Init_jacobi(VALUE module); #endif #ifdef HAVE_GSL_GSL_CQP_H void Init_cqp(VALUE module); #endif void Init_fresnel(VALUE module); #ifdef GSL_1_9_LATER void Init_bspline(VALUE module); #endif #ifdef HAVE_ALF_ALF_H #include "alf/alf.h" #endif void Init_alf(VALUE module); void Init_geometry(VALUE module); #ifdef GSL_1_14_LATER #include extern VALUE cMultiset; void Init_multiset(VALUE module); #endif #endif gsl-1.15.3/include/rb_gsl_config.h0000644000175000017500000000207012220252463016332 0ustar boutilboutil#ifndef ___RB_GSL_CONFIG_H___ #define ___RB_GSL_CONFIG_H___ #ifndef GSL_VERSION #define GSL_VERSION "1.15" #endif #ifndef GSL_0_9_4_LATER #define GSL_0_9_4_LATER #endif #ifndef GSL_1_0_LATER #define GSL_1_0_LATER #endif #ifndef GSL_1_1_LATER #define GSL_1_1_LATER #endif #ifndef GSL_1_1_1_LATER #define GSL_1_1_1_LATER #endif #ifndef GSL_1_2_LATER #define GSL_1_2_LATER #endif #ifndef GSL_1_3_LATER #define GSL_1_3_LATER #endif #ifndef GSL_1_4_LATER #define GSL_1_4_LATER #endif #ifndef GSL_1_4_9_LATER #define GSL_1_4_9_LATER #endif #ifndef GSL_1_6_LATER #define GSL_1_6_LATER #endif #ifndef GSL_1_8_LATER #define GSL_1_8_LATER #endif #ifndef GSL_1_9_LATER #define GSL_1_9_LATER #endif #ifndef GSL_1_10_LATER #define GSL_1_10_LATER #endif #ifndef GSL_1_11_LATER #define GSL_1_11_LATER #endif #ifndef GSL_1_13_LATER #define GSL_1_13_LATER #endif #ifndef GSL_1_14_LATER #define GSL_1_14_LATER #endif #ifndef GSL_1_15_LATER #define GSL_1_15_LATER #endif #ifndef RUBY_GSL_VERSION #define RUBY_GSL_VERSION "1.15.0" #endif #ifndef RUBY_1_8_LATER #define RUBY_1_8_LATER #endif #endif gsl-1.15.3/include/templates_off.h0000644000175000017500000000202512220252463016365 0ustar boutilboutil#ifdef FUNCTION #undef FUNCTION #endif #ifdef CONCAT4 #undef CONCAT4 #endif #ifdef CONCAT4x #undef CONCAT4x #endif #ifdef CONCAT3 #undef CONCAT3 #endif #ifdef CONCAT3x #undef CONCAT3x #endif #ifdef CONCAT2 #undef CONCAT2 #endif #ifdef CONCAT2x #undef CONCAT2x #endif #ifdef GSL_TYPE #undef GSL_TYPE #endif #ifdef REAL_GSL_TYPE #undef REAL_GSL_TYPE #endif #ifdef QUALIFIED_GSL_TYPE #undef QUALIFIED_GSL_TYPE #endif #ifdef VIEW #undef VIEW #endif #ifdef REAL_VIEW #undef REAL_VIEW #endif #ifdef QUALIFIED_VIEW #undef QUALIFIED_VIEW #endif #ifdef QUALIFIED_REAL_GSL_TYPE #undef QUALIFIED_REAL_GSL_TYPE #endif #ifdef QUALIFIED_REAL_VIEW #undef QUALIFIED_REAL_VIEW #endif #ifdef USES_LONGDOUBLE #undef USES_LONGDOUBLE #endif #ifdef SHORT_REAL #undef SHORT_REAL #endif #ifndef USE_QUALIFIER #ifdef QUALIFIER #undef QUALIFIER #endif #endif #undef BASE #undef BASE_EPSILON #undef SHORT #undef ATOMIC #undef MULTIPLICITY #undef IN_FORMAT #undef OUT_FORMAT #undef ATOMIC_IO #undef ZERO #undef ONE #undef NAME #undef STRING #undef EXPAND gsl-1.15.3/include/rb_gsl_root.h0000644000175000017500000000110312220252463016044 0ustar boutilboutil/* rb_gsl_roots.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_ROOT_H___ #define ___RB_GSL_ROOT_H___ #include #include #include #include "rb_gsl.h" EXTERN VALUE cgsl_fsolver; EXTERN VALUE cgsl_fdfsolver; #endif gsl-1.15.3/include/rb_gsl_array.h0000644000175000017500000002227512220252463016214 0ustar boutilboutil/* rb_gsl_array.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_ARRAY_H___ #define ___RB_GSL_ARRAY_H___ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "rb_gsl_config.h" #include "ruby.h" #ifdef RUBY_1_9_LATER #include "ruby/io.h" #else #include "rubyio.h" #endif #include "rb_gsl_common.h" typedef gsl_permutation gsl_index; #ifdef HAVE_NARRAY_H EXTERN VALUE cNArray; #endif EXTERN VALUE cgsl_block, cgsl_block_int; EXTERN VALUE cgsl_block_uchar; EXTERN VALUE cgsl_block_complex; EXTERN VALUE cgsl_vector, cgsl_vector_complex; EXTERN VALUE cgsl_vector_col; EXTERN VALUE cgsl_vector_col_view; EXTERN VALUE cgsl_vector_complex_col; EXTERN VALUE cgsl_vector_complex_col_view; EXTERN VALUE cgsl_vector_view, cgsl_vector_complex_view; EXTERN VALUE cgsl_vector_view_ro, cgsl_vector_col_view_ro; EXTERN VALUE cgsl_vector_complex_view_ro; EXTERN VALUE cgsl_vector_int, cgsl_vector_int_col; EXTERN VALUE cgsl_vector_int_view, cgsl_vector_int_col_view; EXTERN VALUE cgsl_vector_int_view_ro, cgsl_vector_int_col_view_ro; EXTERN VALUE cgsl_matrix, cgsl_matrix_complex; EXTERN VALUE cgsl_matrix_view_ro; EXTERN VALUE cgsl_matrix_complex_view_ro; EXTERN VALUE cgsl_matrix_view, cgsl_matrix_complex_view; EXTERN VALUE cgsl_matrix_int, cgsl_matrix_int_view; EXTERN VALUE cgsl_matrix_int_view_ro; EXTERN VALUE cgsl_permutation; EXTERN VALUE cgsl_index; EXTERN VALUE cgsl_function; EXTERN VALUE mgsl_narray; EXTERN VALUE mDirac; gsl_matrix_view* gsl_matrix_view_alloc(); void gsl_matrix_view_free(gsl_matrix_view * mv); gsl_vector_view* gsl_vector_view_alloc(); void gsl_vector_view_free(gsl_vector_view * v); gsl_vector_complex_view* gsl_vector_complex_view_alloc(); void gsl_vector_complex_view_free(gsl_vector_view * vv); gsl_matrix_complex_view* gsl_matrix_complex_view_alloc(); void gsl_matrix_complex_view_free(gsl_matrix_view * vv); VALUE rb_gsl_vector_new(int argc, VALUE *argv, VALUE klass); gsl_vector* get_cvector(VALUE v); VALUE make_rarray_from_cvector(const gsl_vector *v); VALUE make_rarray_from_cpermutation(const gsl_permutation *v); gsl_vector* make_cvector_from_rarrays(VALUE a); gsl_vector* make_cvector_from_rarray(VALUE a); void cvector_set_from_carray(gsl_vector *v, const double *a); void cvector_set_from_rarrays(gsl_vector *v, VALUE ary); void cvector_set_from_rarray(gsl_vector *v, VALUE ary); void carray_set_from_cvector(double *a, const gsl_vector *v); void carray_set_from_rarrays(double *a, VALUE ary); void carray_set_from_rarray(double *a, VALUE ary); int is_vector_p(VALUE obj); void check_vector(VALUE obj); int is_vector_complex_p(VALUE obj); void check_vector_complex(VALUE obj); int is_matrix_p(VALUE obj); void check_matrix(VALUE obj); int is_matrix_complex_p(VALUE obj); void check_matrix_complex(VALUE obj); gsl_complex* make_complex(double re, double im); int is_permutation_p(VALUE obj); void check_permutation(VALUE obj); int is_combination_p(VALUE obj); void check_combination(VALUE obj); gsl_vector* get_vector(VALUE ary); gsl_matrix* make_matrix_clone(const gsl_matrix *m); gsl_matrix_int* make_matrix_int_clone(const gsl_matrix_int *m); VALUE make_matrix_clone2(VALUE vm); gsl_matrix_complex* make_matrix_complex_clone(const gsl_matrix_complex *m); int is_matrix_complex_p(VALUE obj); void check_matrix_complex(VALUE obj); double* get_vector_ptr(VALUE ary, size_t *stride, size_t *n); gsl_matrix_complex* matrix_to_complex(const gsl_matrix *m); void gsl_matrix_complex_mul(gsl_matrix_complex *mnew, const gsl_matrix_complex *m, const gsl_matrix_complex *mb); void gsl_matrix_mul(gsl_matrix *mnew, gsl_matrix *m, gsl_matrix *b); void gsl_matrix_complex_mul_vector(gsl_vector_complex *vnew, const gsl_matrix_complex *m, const gsl_vector_complex *v); void gsl_matrix_mul_vector(gsl_vector *vnew, const gsl_matrix *m, const gsl_vector *v); gsl_vector_complex* vector_to_complex(const gsl_vector *v); gsl_vector* make_vector_clone(const gsl_vector *v); gsl_vector_complex* make_vector_complex_clone(const gsl_vector_complex *v); int gsl_vector_complex_add(gsl_vector_complex *cv, const gsl_vector_complex *cv2); int gsl_vector_complex_sub(gsl_vector_complex *cv, const gsl_vector_complex *cv2); int gsl_vector_complex_mul(gsl_vector_complex *cv, const gsl_vector_complex *cv2); int gsl_vector_complex_div(gsl_vector_complex *cv, const gsl_vector_complex *cv2); int gsl_vector_complex_add_constant(gsl_vector_complex *cv, gsl_complex b); int gsl_vector_complex_scale(gsl_vector_complex *cv, gsl_complex b); gsl_vector_view* rb_gsl_make_vector_view(double *data, size_t size, size_t stride); gsl_vector_int_view* rb_gsl_make_vector_int_view(int *data, size_t size, size_t stride); void Init_gsl_array_complex(VALUE module); void Init_gsl_vector(VALUE module); void Init_gsl_vector_complex(VALUE module); void Init_gsl_matrix(VALUE module); void Init_gsl_matrix_complex(VALUE module); void Init_gsl_matrix(VALUE module); void Init_gsl_permutation(VALUE module); void Init_gsl_combination(VALUE module); void Init_gsl_matrix_int(VALUE module); VALUE rb_gsl_range2ary(VALUE obj); void Init_gsl_vector_int(); gsl_vector_int_view* rb_gsl_vector_int_view_alloc(size_t n); void rb_gsl_vector_int_view_free(gsl_vector_int_view *v); gsl_vector_int* make_vector_int_clone(const gsl_vector_int *v); gsl_matrix_int_view* rb_gsl_matrix_int_view_alloc(); void rb_gsl_matrix_int_view_free(gsl_matrix_int_view *v); VALUE rb_gsl_matrix_to_i(VALUE obj); VALUE rb_gsl_matrix_int_to_f(VALUE obj); void gsl_matrix_int_mul_vector(gsl_vector_int *vnew, const gsl_matrix_int *m, const gsl_vector_int *v); VALUE rb_gsl_vector_to_i(VALUE obj); VALUE make_rarray_from_cvector_int(const gsl_vector_int *v); VALUE rb_gsl_vector_int_to_f(VALUE obj); VALUE rb_gsl_vector_uminus(VALUE obj); VALUE rb_gsl_vector_print(VALUE obj); void gsl_vector_print(const gsl_vector *v, VALUE klass); int rbgsl_vector_equal(const gsl_vector *v1, const gsl_vector *v2, double eps); #ifndef GSL_1_2_LATER int gsl_matrix_complex_add(gsl_matrix_complex * a, const gsl_matrix_complex * b); int gsl_matrix_complex_sub(gsl_matrix_complex * a, const gsl_matrix_complex * b); int gsl_matrix_complex_mul_elements(gsl_matrix_complex * a, const gsl_matrix_complex * b); int gsl_matrix_complex_div_elements(gsl_matrix_complex * a, const gsl_matrix_complex * b); int gsl_matrix_complex_scale(gsl_matrix_complex * a, const gsl_complex x); int gsl_matrix_complex_add_constant(gsl_matrix_complex * a, const gsl_complex x); int gsl_matrix_complex_add_diagonal(gsl_matrix_complex * a, const gsl_complex x); #endif void Init_gsl_vector_init(VALUE module); void Init_gsl_vector_int_init(VALUE module); void Init_gsl_matrix_init(VALUE module); void Init_gsl_matrix_int_init(VALUE module); gsl_matrix* gsl_matrix_alloc_from_array_sizes(VALUE ary, VALUE nn1, VALUE nn2); gsl_matrix* gsl_matrix_alloc_from_arrays(int argc, VALUE *argv); gsl_matrix* gsl_matrix_alloc_from_vector_sizes(VALUE ary, VALUE nn1, VALUE nn2); gsl_matrix* gsl_matrix_alloc_from_vectors(int argc, VALUE *argv); gsl_matrix_int* gsl_matrix_int_alloc_from_array_sizes(VALUE ary, VALUE nn1, VALUE nn2); gsl_matrix_int* gsl_matrix_int_alloc_from_arrays(int argc, VALUE *argv); gsl_matrix_int* gsl_matrix_int_alloc_from_vector_sizes(VALUE ary, VALUE nn1, VALUE nn2); gsl_matrix_int* gsl_matrix_int_alloc_from_vectors(int argc, VALUE *argv); VALUE rb_gsl_matrix_do_something(VALUE obj, void (*f)(gsl_matrix *)); VALUE rb_gsl_matrix_int_do_something(VALUE obj, void (*f)(gsl_matrix_int *)); VALUE rb_gsl_matrix_power(VALUE a, VALUE b); VALUE rb_gsl_matrix_int_power(VALUE a, VALUE b); void mygsl_vector_shift(gsl_vector *p, size_t n); void mygsl_vector_int_shift(gsl_vector_int *p, size_t n); void mygsl_vector_shift_scale2(gsl_vector *p, size_t n); void mygsl_vector_int_shift_scale2(gsl_vector_int *p, size_t n); VALUE rb_gsl_vector_to_s(VALUE obj); VALUE rb_gsl_vector_int_to_s(VALUE obj); VALUE rb_gsl_vector_add_constant(VALUE obj, VALUE x); VALUE rb_gsl_vector_int_add_constant(VALUE obj, VALUE x); VALUE rb_gsl_vector_scale(VALUE obj, VALUE x); VALUE rb_gsl_vector_scale_bang(VALUE obj, VALUE x); VALUE rb_gsl_vector_int_scale(VALUE obj, VALUE x); VALUE rb_gsl_vector_int_scale_bang(VALUE obj, VALUE x); gsl_vector_int* make_cvector_int_from_rarray(VALUE ary); void cvector_int_set_from_rarray(gsl_vector_int *v, VALUE ary); VALUE rb_gsl_range2vector(VALUE obj); VALUE rb_gsl_range2vector_int(VALUE obj); void Init_gsl_block_init(VALUE module); void Init_gsl_block_int_init(VALUE module); void Init_gsl_block_uchar_init(VALUE module); void Init_gsl_matrix_nmf(void); #endif gsl-1.15.3/include/rb_gsl_statistics.h0000644000175000017500000000073012220252463017260 0ustar boutilboutil/* rb_gsl_statistics.h Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY */ #ifndef ___RB_GSL_STATISTICS_H___ #define ___RB_GSL_STATISTICS_H___ #include "gsl/gsl_statistics.h" #endif gsl-1.15.3/ChangeLog0000644000175000017500000004375012220252463013525 0ustar boutilboutilSat Feb 26 08:18:45 PST 2011 * Ruby/GSL 1.14.7 * Fix conversion of non-DFLOAT NArray to GSL::Vector and GSL::Vector::Complex. Thu Feb 24 10:27:08 PST 2011 * Ruby/GSL 1.14.6 * Add Vector::Complex support to NArray conversions * Raise exception when trying to create View from NArray object of incompatible type. Sun Nov 14 17:01:07 PST 2010 * Ruby/GSL 1.14.5 * Convert docs from rdtool to rdoc * Fix object id handling bugs on 64-bit systems * Fix Vector's handling of Range parameters Wed Sep 29 00:37:44 BOT 2010 * Modification for ruby-1.9.2 * Replaced STR2CSTR to StringValuePtr Mon Mar 22 23:54:07 MDT 2010 * GSL-1.14 support * Added GSL::Multiset class * Added GSL::Function#glfixed(a, b table) Sun Aug 16 19:01:31 BOT 2009 * Added Non-negative Matrix Factorization (NMF) support (by Roman Shterenzon) Sat Aug 8 22:36:24 BOT 2009 * Added GSL-1.13 features: * Added GSL::Monte::Miser#params_get, GSL::Monte::Vegas#params_get * Added GSL::BSpline::greville_abscissa(i) * Added GSL::Poly#eval_derivs(x) * Added a new minimization algorithm "quad_golden" * Added a new multimin algorithm "nmsimplex2rand" Tue Jun 9 10:42:30 JST 2009 * Fixed bug in linalg.c (bug [#25842]) Thu Feb 2 12:16:38 JST 2009 * Fixed a bug in GSL::Histogram.alloc_uniform() (bug [#23040]) * Fixed a bug in GSL::Vector#/ (bug [#23334]) Thu Nov 6 17:34:18 JST 2008 * Match with the tensor extension version 0.99 * now not compatible for the versions older than tensor-0.97. Sat Jul 26 08:23:45 JST 2008 * GSL::Poly.eval now handles complex numbers (GSL-1.11) * Added new quasi-random generators "halton" and "reversehalton" * Added a module function GSL::MultiFit::linear_residuals() (GSL-1.11) * Fixed a bug in ODE solver Mon Jun 30 22:07:24 JST 2008 * Fixed GSL::Vector#normalize (#20865) Mon May 26 19:21:15 JST 2008 * Fixed a bug in GSL::Matrix::to_v (#19757) * Fixed a bug in GSL::Vector::Int multiplication (#19924) Sat Dec 8 23:44:47 2007 * Version 1.10.3 Tue Dec 2 16:30:15 2007 * Improved GSL::Vector#get for a Range arg * Improved GSL::Vector#concat for an Array arg * Fixed a bug in GSL::Matrix.alloc with column vector arguments Thu Dec 2 10:58:37 2007 * Added methods GSL::Vector#pow(p), GSL::Vector#pow!(p) Wed Oct 17 04:04:39 2007 * Fixed a bug in poly_source.c Sun Oct 7 14:18:31 2007 * Version 1.10.0 * ndlinear extension support Sat Sep 22 01:49:57 2007 Added GSL-1.10 features * Added generalized eigensystem methods * Added method GSL::Stats::correlation(v1, v2) to compute Pearson correlation of two datasets * Added methods GSL::Sf::expint_En(n, x), GSL::Sf::expint_En_e(n, x) for computing the n-th order exponential integral. * Added methods GSL::Vector#isnonneg, GSL::Vector#isnonneg?, GSL::Matrix#isnonneg, and GSL::Matrix#isnonneg? * Added methods GSL::Matrix#subrow, GSL::Matrix#subcolumn * Added methods GSL::Linalg::Chomplex::Cholesky::decomp, GSL::Linalg::Chomplex::Cholesky::solve, and GSL::Linalg::Chomplex::Cholesky::svx * Added method GSL::hypot3(x, y, z) Sat Aug 11 00:45:48 2007 * Modified ext/extconf.rb: Check gsl_stats_correlation() Sun Aug 5 15:46:51 2007 * Improved GSL::Vector::filescan() Tue May 15 13:35:49 2007 * Fixed a bug in Vector#get (Thank to Daigo Moriwaki) Sun Feb 18 00:08:15 2007 * Completed GSL-1.8.90 features * Change names "unsymm" ---> "nonsymm" for non-symmetric eigen systems * Added Mathieu functions * Added Vector#ispos, isneg * Added knuthran2002 generator * Added a new minimization method GSL::MultiMin::FdfMinimizer::BFGS2 Sun Dec 31 01:34:29 2006 * Remove the module function GSL::equal?, which breaks the Ruby policy. Sun Dec 24 16:51:34 2006 * Added Basis splines * CQP and Bundle extentions support Wed Dec 13 01:02:09 2006 * OOL extension support (OOL version 0.2) * OOL: Open Optimization Library Mon Dec 11 01:04:19 2006 * Add a quasi-random sequence generator hdsobol (require the qrngextra extension) Tue Sep 26 18:58:26 BOT 2006 * Fixed a bug in GSL::Vector#* Sun Sep 24 10:37:49 BOT 2006 * Fixed a bug in GSL::Matrix.vandermonde() * Added methods GSL::Vector#join, zip, cumsum, cumprod Thu Sep 21 20:03:39 BOT 2006 * Added methods to calculate eigenvectors of nonsymmetric matrices * Added test scripts tests/eigen/unsymm.rb, tests/eigen/unsymmv.rb Wed Aug 23 00:51:12 BOT 2006 * Added methods to calculate eigenvalues of nonsymmetric matrices Fri Aug 18 20:47:05 BOT 2006 * Fixed bug in Sf::hypot Sat Apr 29 12:29:10 JST 2006 * Applied patch provided by Cameron McBride, to fix a bug in randist.c * Applied patched by zunda to fix some test/ scripts. Thu Apr 13 22:21:02 JST 2006 * Version 1.8.0 * Added cumulative distribution functions under the module GSL::Cdf: binomial, poisson, geometric, negative binomial, pascal and hypergeometric. * Added module functions GSL::Cdf::beta_Pinv, beta_Qinv, fdist_Pinv, and fdist_Qinv. * Added the multilinear fit estimator function GSL::MultiFit::linear_est. * Added new random variate generators, GSL::Ran::gaussian_ziggurat and gamma_mt. * Added Debye functions for n=5 and n=6, as GSL::Sf::debye_5 and debye_6. * Added GSL::Spline#min_size * Added the Debye unit to physical constants. Fri Dec 2 19:05:30 JST 2005 * Singleton method "new" ---> "alloc" Sun Nov 27 14:01:12 JST 2005 * Apply patch by zunda to improve multifit. * Fix bug in dirac.c Tue Apr 3 JST 2005 * Added Vector#collect!, Matrix#collect! * Added lib/rbgsl.rb, in which the GSL module is not included by default Wed Apr 27 21:21:58 JST 2005 * The following Linalg methods now can handle NArray objects: * GSL::Linalg:: * LU.decomp(m) * LU.solve(lu, b) * LU.svx(lu, bx) * LU.det(lu, sign) * LU.lndet(lu) * LU.invert(lu, perm) * QR.decomp(m) * QR.solve(qr, tau, b) * QR.svx(qr, tau, bx) * SV.decomp(m) * SV.solve(u, v, s, b) * SV.svx(u, v, s, bx) * Cholesky.decomp(m) * Cholesky.solve(u, v, s, b) * Cholesky.svx(u, v, s, bx) * HH.solve(m, b) * HH.svx(m, bx) Mon Apr 18 23:27:16 JST 2005 * Improved gsl_narray.c (thanks to T. Horinouchi) * Modified extconf.rb * Automatic finding of NArray * Applied a patch by zunda Thu Apr 7 18:26:08 JST 2005 * Modified extconf.rb Mon Mar 21 23:17:56 JST 2005 * Version 1.6.2 Sat Mar 19 01:00:15 JST 2005 * Fixed Blas.dgemm, .zgemm * Fixed method re-definitions Tue Mar 15 23:20:15 JST 2005 * Added class GSL::Block::Byte, GSL::Block::Index * Added NArray-like methods, Vector#eq, ne, gt, where, any? etc. * Added methods Vector#floor, Vector#ceil, and Vector#round (if the system has) Sat Mar 12 14:49:47 JST 2005 * Fixed Vector#get Sat Feb 26 11:18:22 JST 2005 * Ruby 1.9.0 support Sat Feb 5 03:24:28 JST 2005 * Version 1.6.1 Wed Jan 26 23:28:07 JST 2005 * Added in-place FFT methods * Fixed FFT document Thu Jan 20 00:55:26 JST 2005 * Added Vector#decimate, Vector#diff * Added Matrix#rot90 * Fixed Matrix::Complex Thu Jan 06 18:46:02 JST 2005 * Some methods which receive GSL::Vector now can also manipulate NArray objects. * Special functions * Probability distributions * Statistics * FFTs * Wavelet transforms * Interpolations * Serices accelerations * Added method Vector#decimate * Sf::exp now can receive Complex or Vector::Complex Tue Jan 04 * Version 1.6.0 Thu Dec 30 04:34:14 JST 2004 Yoshiki Tsunesada * Update for GSL-1.5.90 * Added Sf::psi_1 * Added ODE stepper rk2simp * Added LQ, PTLQ decompositions * Added methods Cdf::exppow_P, Cdf::exppow_Q Mon Dec 27 22:19:55 JST 2004 Yoshiki Tsunesada * All Ruby/GSL classes are defined as derivatives of the base class GSL::Object. * Defined the method GSL::Object#info * Added Vector#histogram * Added Vector.filescan * Modified the methods Histogram#increment, accumulate * Added methods Poly.fit, Poly.wfit, MultiFit.polyfit * Added methods Vector::Complex#abs2, abs, arg * Modified FFT methods: now they return FFTed data as a new vector, and do not destroy the input vector. Sat Dec 11 21:45:30 JST 2004 Yoshiki Tsunesada * Modified Histogram#integral Fri Dec 10 14:28:38 JST 2004 Yoshiki Tsunesada * Added methods Histogram#reverse, Histogram2d#integrate, Histogram2d#normalize Mon Dec 6 01:15:03 JST 2004 Yoshiki Tsunesada * Version 1.5.4 Fri Dec 3 22:33:46 JST 2004 Yoshiki Tsunesada * Added Histogram#rebin Fri Nov 26 21:17:17 JST 2004 Yoshiki Tsunesada * Added method Vector#to_m * Added methods Matrix#reverse_rows, Matrix#reverse_columns Tue Nov 16 23:35:27 JST 2004 Yoshiki Tsunesada * The method Matrix#** is now obsolete, use "*" for matrix multiplication instead. * Improved Matrix#* and Vetor#* * Added methods Vector#to_m_diagonal, Vector#to_m_circulant, Vector#collect * Added methods Matrix.hilbert, Matrix.invhilbert, Matrix.pascal, Matrix.vandermonde, Matrix.toeplitz, Matrix.circulant * Added methods Vector.indgen, Vector#indgen, Matrix.indgen, Matrix#indgen (mimics NArray) * Added class GSL::Histogram3d * Checked GSL lower version compatibilities * gsl-1.0 ~ gsl-1.5: OK * gsl-0.9.4: OK * gsl-0.9.3 or older: not tested * gsl-1.6 (development version, CVS Nov2004): OK Sun Nov 7 00:56:11 JST 2004 Yoshiki Tsunesada * Support the gsl_tensor package * http://sources.redhat.com/ml/gsl-discuss/2004-q4/msg00053.html * Added class GSL::Tensor, GSL::Tensor::Int * The methods Vector#get, Vector#[] now receive multiple arguments, or an Array, or a Range object. Thu Nov 4 21:13:38 JST 2004 Yoshiki Tsunesada * Added class GSL::Histogram::Integral, which represents the cumulative distribution. * Added method GSL::Histogram#integrate, which creates a GSL::Histogram::Integral object. * Added methods GSL::Histogram2d#xproject, yproject, normalize, increment2. Sun Oct 31 02:34:28 JST 2004 Yoshiki Tsunesada * Fix the document for Polynomials * Added methods Poly::hermite(n), Poly::cheb(n), and Poly::cheb_II(n) etc.. * Added method Poly#compan, which returns the companion matrix. * The method Matrix#/ is improved: if a Vector is given, this method solves the linear system. Mon Oct 25 01:25:12 JST 2004 Yoshiki Tsunesada * Split the source file "randist.c" into "randist.c" and "cdf.c" * Split the source file "diff.c" into "diff.c" and "deriv.c" * Split the source file "interp.c" into "interp.c" and "spline.c" * Added methods Vector#abs, sqrt, square, normalize * Added sample scripts odeiv/frei1.rb, fft/frei2.rb and eigen/qhoscillator.rb, which deal with quantum mechanical calculations. These are translated from the C++ code in the Harald Wiedemann's textbook "Numerische Physik" (Springer 2004, ISBN 3-540-40774-X). Sat Oct 23 19:08:02 JST 2004 Yoshiki Tsunesada * Added a method GSL::Vector#logspace2. The following two are equivalent: v1 = Vector.logspace(1, 3, 5) v2 = Vector.logspace2(10, 1000, 5) Tue Oct 19 23:23:38 JST 2004 Yoshiki Tsunesada * Support the rngextra package * http://www.network-theory.co.uk/download/rngextra/ * Added two random number generators "rngextra_rng1" and "rngextra_rng2" * Fixed a bug in the method Vector#subvector_with_stride Mon Oct 18 22:22:21 JST 2004 Yoshiki Tsunesada * Added a sample script dht.rb Fri Oct 8 23:09:00 JST 2004 Yoshiki Tsunesada * Version 1.5.3 Thu Oct 7 22:47:59 JST 2004 Yoshiki Tsunesada * The methods Vector.graph and GSL::graph improved. * Added sample scripts of special functions and probability distribution functions. Sat Oct 2 23:13:49 JST 2004 Yoshiki Tsunesada * Discrete wavelet transform (experimental) * Presently this is only for CVS trackers, since DWT is not supported in the latest version GSL-1.5. * Added methods Vector.connect, Vector#connect Thu Sep 30 22:56:47 JST 2004 Yoshiki Tsunesada * The methods Vector#[] and Vector#[]= accept an index of negative integer. For example, v[-1] returns the last element of the vector v, v[-2] does the second last, and so on. Fri Sep 24 21:52:06 JST 2004 Yoshiki Tsunesada * Fixed bug in Sf::legendre_Ql Wed Sep 1 19:02:42 JST 2004 Yoshiki Tsunesada * Version 1.5.2 Fri Aug 27 03:18:46 JST 2004 Yoshiki Tsunesada * Experimental implementation of GNU plotutils graph and GNUPLOT interfaces * Added unary minus operators for GSL::Vector, GSL::Matrix Thu Aug 19 14:28:08 JST 2004 Yoshiki Tsunesada * Added class GSL::Matrix::Int * Correct descriptions of GSL::Matrix#get_row, get_col * Changed behaviour of methods NArray#to_gv, NArray#to_gm, added methods NArray#to_gv_view, NArray#to_gm_view Wed Aug 18 02:38:20 JST 2004 * Added method GSL::set_error_handler Tue Aug 17 20:59:39 JST 2004 * Version 1.5.1 Sat Aug 14 16:27:05 JST 2004 Yoshiki Tsunesada * Changed behaviour of the methods Odeiv::Evolve#apply, Odeiv::Solver#apply * Fixed bug in GSL::Histogram#get * Fixed buf in GSL::Vector#matrix_view_with_tda * Added class GSL::Vector::Int * Added test suite Wed Aug 11 14:39:17 JST 2004 Yoshiki Tsunesada * Fixed bug in GSL::Sf::legendle_Ql_e * Fixed bug in GSL::MultiFit.linear Tue Aug 10 10:31:21 JST 2004 Yoshiki Tsunesada * Fixed bugs in GSL::Cdf::gumbel2_P, gumbel2_Q * Version 1.5.0 Fri Aug 6 00:58:29 JST 2004 Yoshiki Tsunesada * Fixed bug in Histogram2d.new_uniform 4.Aug.2004 * Correct source code errors in interp.c, multifit.c 2.Aug.2004 * Added methods GSL::Vector#dot (inner product) * Added classes GSL::Vector::Col < GSL::Vector, GSL::Vector::Col::View < GSL::Vector::Col 1.Aug.2004 * Version 0.9.9 30.Jul.2004 * Added methods GSL::Rng.default_seed, GSL::Rng.default_seed=(seed) 26.Jul.2004 * Cumulative distribution functions * Changed module path GSL::Ran:: ---> GSL::Cdf * Constants GSL::VERSION, GSL::RUBY_GSL_VERSION defined 24.Jul.2004 * Experimental implementation of discrete wavelet transforms (tests/wavelet) 22.Jul.2004 * Elementary functions as GSL::sin now can take argument of Integer, Float, Array, Vector or Matrix. * Strict type check 20.Jul.2004 * Added methods GSL::heapsort, Vector#heapsort, Vector::Complex#heapsort * Added methods GSL::heapsort_index, Vector#heapsort_index, Vector::Complex#heapsort_index * version 0.9.4 18.Jul.2004 * Added missing functions GSL::Sf::legendre_Ql * Added missing functions GSL::Sf::psi_e * Added missing functions GSL::Sf::zetam1, zetam1_int 17.Jul.2004 * Added GSL::Eigen::Symmv::sort, GSL::Eigen::Hermv::sort * Update GSL::Monte 15.Jul.2004 * Version 0.9.2 * Added methods Matrix#each_row, Matrix#each_col * Added methods Matrix::Complex#each_row, Matrix::Complex#each_col * Fixed bug in Complex::polar * Fixed bug in Complex#abs, arg, abs2, logabs 13.Jul.2004 * Added Matrix#trace, Matrix::Complex#trace 11.Jul.2004 * version 0.9.0 * Householder Transformations * LU decomposition for complex matrices * All the GSL functions implemented. 10.Jul.2004 * Blas level 3 * Fixed GSL::Vector::sort_index 8.Jul.2004 * Correct document on random distributions 7.Jul.2004 * Fixed bug in the method GSL::Sf::coulomb_wave_sphF_array 6.Jul.2004 * GSL 1.5 support * Fixed a bug in the method GSL::Sf::bessel_sequence_Jnu_e 5.Jul.2004 * Compile test with -Wall option: * remove unused variables, check missing prototype declarations * Fixed a bug in the method GSL::Multimin::test_size (wrong binding) 30.Jun.2004 * ver 0.4.7 28.Jun.2004 * Switch rb_f_lambda() and rb_block_proc(), for proper ruby version. 20.Jun.2004 * Added Linalg::balance_comlumns(A, D) and Matrix#balance_columns(D) * BLAS support * Level 1 * Level 2 19.Jun.2004 * Support gsl-1.4.90 * Added Stefan-Boltzmann constant, Thomson scattering cross section * Module Deriv 13.Jun.2004 * Fixed a bug in the sample script integration/friedmann.rb * Improved interfaces of polynomial equations * Correct the document on GSL::Complex 10.Jun.2004 * ver 0.4.2 * The module GSL::Math removed * The module name GSL::Const is changed to GSL::CONST 09.Jun.2004 * ver 0.4.1 * Add random number generators borosh13, coveyou, fishman18, fishman20, fishman2x, knuthran, knuthran2, lecuyer21, waterman14. * Correct the documentation on random number generators * Add functions expint_E1_scaled,expint_E2_scaled, and others * Add methods Rng::fwrite, fread * Add function binomial_tpe 05.Jun.2004 * 0.4.0 02.Jun.2004 * rb_gc_mark * Implemented simulated annealing, Ntuples 25.Apr.2004 * Vector, Matrix, Matrix::Complex coerce 24.Apr.2004 version 0.3.11 * GSL::Complex, coerce 22.Apr.2004 version 0.3.10 * polish sources of special functions 18.Apr.2004, version 0.3.9 * bug fix Eigensystems, Interpolation 16.Apr.2004 * bug fix Vector, Matrix, Linalg 14.Apr.2004, version 0.3.8 * N-tuples * Improvement in NArray object conversions (thanks to S. Nishizawa) 13.Apr.2004 * Poly divided-difference reporesentation, Taylor expansion * Apply patch by S. Nishizawa, for type checks in C code, and some modifications in sample scripts 12.Apr.2004, version 0.3.7 * Add mathematical functions ldexp, frexp * Add gsl_sf_hazard function * QRng bug fix * GSL::Stats module version 0.3.6 Monte-Carlo integration version 0.3.5 Multidimensional minimization version 0.3.4 Combinations, One dimensional minimization, Multidimensional root-finding version 0.3.3 Nonlinear least-squared fitting versoin 0.3.2 Least-squared fitting version 0.3.1 One dimensional root-finding version 0.3.0 FFTs, Ordinary differential equations 2002 version 0.2.5 gsl-1.15.3/setup.rb0000644000175000017500000010650212220252463013433 0ustar boutilboutil# # setup.rb # # Copyright (c) 2000-2005 Minero Aoki # # This program is free software. # You can distribute/modify this program under the terms of # the GNU LGPL, Lesser General Public License version 2.1. # unless Enumerable.method_defined?(:map) # Ruby 1.4.6 module Enumerable alias map collect end end unless File.respond_to?(:read) # Ruby 1.6 def File.read(fname) open(fname) {|f| return f.read } end end unless Errno.const_defined?(:ENOTEMPTY) # Windows? module Errno class ENOTEMPTY # We do not raise this exception, implementation is not needed. end end end def File.binread(fname) open(fname, 'rb') {|f| return f.read } end # for corrupted Windows' stat(2) def File.dir?(path) File.directory?((path[-1,1] == '/') ? path : path + '/') end class ConfigTable include Enumerable def initialize(rbconfig) @rbconfig = rbconfig @items = [] @table = {} # options @install_prefix = nil @config_opt = nil @verbose = true @no_harm = false end attr_accessor :install_prefix attr_accessor :config_opt attr_writer :verbose def verbose? @verbose end attr_writer :no_harm def no_harm? @no_harm end def [](key) lookup(key).resolve(self) end def []=(key, val) lookup(key).set val end def names @items.map {|i| i.name } end def each(&block) @items.each(&block) end def key?(name) @table.key?(name) end def lookup(name) @table[name] or setup_rb_error "no such config item: #{name}" end def add(item) @items.push item @table[item.name] = item end def remove(name) item = lookup(name) @items.delete_if {|i| i.name == name } @table.delete_if {|name, i| i.name == name } item end def load_script(path, inst = nil) if File.file?(path) MetaConfigEnvironment.new(self, inst).instance_eval File.read(path), path end end def savefile '.config' end def load_savefile begin File.foreach(savefile()) do |line| k, v = *line.split(/=/, 2) self[k] = v.strip end rescue Errno::ENOENT setup_rb_error $!.message + "\n#{File.basename($0)} config first" end end def save @items.each {|i| i.value } File.open(savefile(), 'w') {|f| @items.each do |i| f.printf "%s=%s\n", i.name, i.value if i.value? and i.value end } end def load_standard_entries standard_entries(@rbconfig).each do |ent| add ent end end def standard_entries(rbconfig) c = rbconfig rubypath = File.join(c['bindir'], c['ruby_install_name'] + c['EXEEXT']) major = c['MAJOR'].to_i minor = c['MINOR'].to_i teeny = c['TEENY'].to_i version = "#{major}.#{minor}" # ruby ver. >= 1.4.4? newpath_p = ((major >= 2) or ((major == 1) and ((minor >= 5) or ((minor == 4) and (teeny >= 4))))) if c['rubylibdir'] # V > 1.6.3 libruby = "#{c['prefix']}/lib/ruby" librubyver = c['rubylibdir'] librubyverarch = c['archdir'] siteruby = c['sitedir'] siterubyver = c['sitelibdir'] siterubyverarch = c['sitearchdir'] elsif newpath_p # 1.4.4 <= V <= 1.6.3 libruby = "#{c['prefix']}/lib/ruby" librubyver = "#{c['prefix']}/lib/ruby/#{version}" librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" siteruby = c['sitedir'] siterubyver = "$siteruby/#{version}" siterubyverarch = "$siterubyver/#{c['arch']}" else # V < 1.4.4 libruby = "#{c['prefix']}/lib/ruby" librubyver = "#{c['prefix']}/lib/ruby/#{version}" librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" siteruby = "#{c['prefix']}/lib/ruby/#{version}/site_ruby" siterubyver = siteruby siterubyverarch = "$siterubyver/#{c['arch']}" end parameterize = lambda {|path| path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix') } if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg } makeprog = arg.sub(/'/, '').split(/=/, 2)[1] else makeprog = 'make' end [ ExecItem.new('installdirs', 'std/site/home', 'std: install under libruby; site: install under site_ruby; home: install under $HOME')\ {|val, table| case val when 'std' table['rbdir'] = '$librubyver' table['sodir'] = '$librubyverarch' when 'site' table['rbdir'] = '$siterubyver' table['sodir'] = '$siterubyverarch' when 'home' setup_rb_error '$HOME was not set' unless ENV['HOME'] table['prefix'] = ENV['HOME'] table['rbdir'] = '$libdir/ruby' table['sodir'] = '$libdir/ruby' end }, PathItem.new('prefix', 'path', c['prefix'], 'path prefix of target environment'), PathItem.new('bindir', 'path', parameterize.call(c['bindir']), 'the directory for commands'), PathItem.new('libdir', 'path', parameterize.call(c['libdir']), 'the directory for libraries'), PathItem.new('datadir', 'path', parameterize.call(c['datadir']), 'the directory for shared data'), PathItem.new('mandir', 'path', parameterize.call(c['mandir']), 'the directory for man pages'), PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']), 'the directory for system configuration files'), PathItem.new('localstatedir', 'path', parameterize.call(c['localstatedir']), 'the directory for local state data'), PathItem.new('libruby', 'path', libruby, 'the directory for ruby libraries'), PathItem.new('librubyver', 'path', librubyver, 'the directory for standard ruby libraries'), PathItem.new('librubyverarch', 'path', librubyverarch, 'the directory for standard ruby extensions'), PathItem.new('siteruby', 'path', siteruby, 'the directory for version-independent aux ruby libraries'), PathItem.new('siterubyver', 'path', siterubyver, 'the directory for aux ruby libraries'), PathItem.new('siterubyverarch', 'path', siterubyverarch, 'the directory for aux ruby binaries'), PathItem.new('rbdir', 'path', '$siterubyver', 'the directory for ruby scripts'), PathItem.new('sodir', 'path', '$siterubyverarch', 'the directory for ruby extentions'), PathItem.new('rubypath', 'path', rubypath, 'the path to set to #! line'), ProgramItem.new('rubyprog', 'name', rubypath, 'the ruby program using for installation'), ProgramItem.new('makeprog', 'name', makeprog, 'the make program to compile ruby extentions'), SelectItem.new('shebang', 'all/ruby/never', 'ruby', 'shebang line (#!) editing mode'), BoolItem.new('without-ext', 'yes/no', 'no', 'does not compile/install ruby extentions') ] end private :standard_entries def load_multipackage_entries multipackage_entries().each do |ent| add ent end end def multipackage_entries [ PackageSelectionItem.new('with', 'name,name...', '', 'ALL', 'package names that you want to install'), PackageSelectionItem.new('without', 'name,name...', '', 'NONE', 'package names that you do not want to install') ] end private :multipackage_entries ALIASES = { 'std-ruby' => 'librubyver', 'stdruby' => 'librubyver', 'rubylibdir' => 'librubyver', 'archdir' => 'librubyverarch', 'site-ruby-common' => 'siteruby', # For backward compatibility 'site-ruby' => 'siterubyver', # For backward compatibility 'bin-dir' => 'bindir', 'bin-dir' => 'bindir', 'rb-dir' => 'rbdir', 'so-dir' => 'sodir', 'data-dir' => 'datadir', 'ruby-path' => 'rubypath', 'ruby-prog' => 'rubyprog', 'ruby' => 'rubyprog', 'make-prog' => 'makeprog', 'make' => 'makeprog' } def fixup ALIASES.each do |ali, name| @table[ali] = @table[name] end @items.freeze @table.freeze @options_re = /\A--(#{@table.keys.join('|')})(?:=(.*))?\z/ end def parse_opt(opt) m = @options_re.match(opt) or setup_rb_error "config: unknown option #{opt}" m.to_a[1,2] end def dllext @rbconfig['DLEXT'] end def value_config?(name) lookup(name).value? end class Item def initialize(name, template, default, desc) @name = name.freeze @template = template @value = default @default = default @description = desc end attr_reader :name attr_reader :description attr_accessor :default alias help_default default def help_opt "--#{@name}=#{@template}" end def value? true end def value @value end def resolve(table) @value.gsub(%r<\$([^/]+)>) { table[$1] } end def set(val) @value = check(val) end private def check(val) setup_rb_error "config: --#{name} requires argument" unless val val end end class BoolItem < Item def config_type 'bool' end def help_opt "--#{@name}" end private def check(val) return 'yes' unless val case val when /\Ay(es)?\z/i, /\At(rue)?\z/i then 'yes' when /\An(o)?\z/i, /\Af(alse)\z/i then 'no' else setup_rb_error "config: --#{@name} accepts only yes/no for argument" end end end class PathItem < Item def config_type 'path' end private def check(path) setup_rb_error "config: --#{@name} requires argument" unless path path[0,1] == '$' ? path : File.expand_path(path) end end class ProgramItem < Item def config_type 'program' end end class SelectItem < Item def initialize(name, selection, default, desc) super @ok = selection.split('/') end def config_type 'select' end private def check(val) unless @ok.include?(val.strip) setup_rb_error "config: use --#{@name}=#{@template} (#{val})" end val.strip end end class ExecItem < Item def initialize(name, selection, desc, &block) super name, selection, nil, desc @ok = selection.split('/') @action = block end def config_type 'exec' end def value? false end def resolve(table) setup_rb_error "$#{name()} wrongly used as option value" end undef set def evaluate(val, table) v = val.strip.downcase unless @ok.include?(v) setup_rb_error "invalid option --#{@name}=#{val} (use #{@template})" end @action.call v, table end end class PackageSelectionItem < Item def initialize(name, template, default, help_default, desc) super name, template, default, desc @help_default = help_default end attr_reader :help_default def config_type 'package' end private def check(val) unless File.dir?("packages/#{val}") setup_rb_error "config: no such package: #{val}" end val end end class MetaConfigEnvironment def initialize(config, installer) @config = config @installer = installer end def config_names @config.names end def config?(name) @config.key?(name) end def bool_config?(name) @config.lookup(name).config_type == 'bool' end def path_config?(name) @config.lookup(name).config_type == 'path' end def value_config?(name) @config.lookup(name).config_type != 'exec' end def add_config(item) @config.add item end def add_bool_config(name, default, desc) @config.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc) end def add_path_config(name, default, desc) @config.add PathItem.new(name, 'path', default, desc) end def set_config_default(name, default) @config.lookup(name).default = default end def remove_config(name) @config.remove(name) end # For only multipackage def packages raise '[setup.rb fatal] multi-package metaconfig API packages() called for single-package; contact application package vendor' unless @installer @installer.packages end # For only multipackage def declare_packages(list) raise '[setup.rb fatal] multi-package metaconfig API declare_packages() called for single-package; contact application package vendor' unless @installer @installer.packages = list end end end # class ConfigTable # This module requires: #verbose?, #no_harm? module FileOperations def mkdir_p(dirname, prefix = nil) dirname = prefix + File.expand_path(dirname) if prefix $stderr.puts "mkdir -p #{dirname}" if verbose? return if no_harm? # Does not check '/', it's too abnormal. dirs = File.expand_path(dirname).split(%r<(?=/)>) if /\A[a-z]:\z/i =~ dirs[0] disk = dirs.shift dirs[0] = disk + dirs[0] end dirs.each_index do |idx| path = dirs[0..idx].join('') Dir.mkdir path unless File.dir?(path) end end def rm_f(path) $stderr.puts "rm -f #{path}" if verbose? return if no_harm? force_remove_file path end def rm_rf(path) $stderr.puts "rm -rf #{path}" if verbose? return if no_harm? remove_tree path end def remove_tree(path) if File.symlink?(path) remove_file path elsif File.dir?(path) remove_tree0 path else force_remove_file path end end def remove_tree0(path) Dir.foreach(path) do |ent| next if ent == '.' next if ent == '..' entpath = "#{path}/#{ent}" if File.symlink?(entpath) remove_file entpath elsif File.dir?(entpath) remove_tree0 entpath else force_remove_file entpath end end begin Dir.rmdir path rescue Errno::ENOTEMPTY # directory may not be empty end end def move_file(src, dest) force_remove_file dest begin File.rename src, dest rescue File.open(dest, 'wb') {|f| f.write File.binread(src) } File.chmod File.stat(src).mode, dest File.unlink src end end def force_remove_file(path) begin remove_file path rescue end end def remove_file(path) File.chmod 0777, path File.unlink path end def install(from, dest, mode, prefix = nil) $stderr.puts "install #{from} #{dest}" if verbose? return if no_harm? realdest = prefix ? prefix + File.expand_path(dest) : dest realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest) str = File.binread(from) if diff?(str, realdest) verbose_off { rm_f realdest if File.exist?(realdest) } File.open(realdest, 'wb') {|f| f.write str } File.chmod mode, realdest File.open("#{objdir_root()}/InstalledFiles", 'a') {|f| if prefix f.puts realdest.sub(prefix, '') else f.puts realdest end } end end def diff?(new_content, path) return true unless File.exist?(path) new_content != File.binread(path) end def command(*args) $stderr.puts args.join(' ') if verbose? system(*args) or raise RuntimeError, "system(#{args.map{|a| a.inspect }.join(' ')}) failed" end def ruby(*args) command config('rubyprog'), *args end def make(task = nil) command(*[config('makeprog'), task].compact) end def extdir?(dir) File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb") end def files_of(dir) Dir.open(dir) {|d| return d.select {|ent| File.file?("#{dir}/#{ent}") } } end DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn ) def directories_of(dir) Dir.open(dir) {|d| return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT } end end # This module requires: #srcdir_root, #objdir_root, #relpath module HookScriptAPI def get_config(key) @config[key] end alias config get_config # obsolete: use metaconfig to change configuration def set_config(key, val) @config[key] = val end # # srcdir/objdir (works only in the package directory) # def curr_srcdir "#{srcdir_root()}/#{relpath()}" end def curr_objdir "#{objdir_root()}/#{relpath()}" end def srcfile(path) "#{curr_srcdir()}/#{path}" end def srcexist?(path) File.exist?(srcfile(path)) end def srcdirectory?(path) File.dir?(srcfile(path)) end def srcfile?(path) File.file?(srcfile(path)) end def srcentries(path = '.') Dir.open("#{curr_srcdir()}/#{path}") {|d| return d.to_a - %w(. ..) } end def srcfiles(path = '.') srcentries(path).select {|fname| File.file?(File.join(curr_srcdir(), path, fname)) } end def srcdirectories(path = '.') srcentries(path).select {|fname| File.dir?(File.join(curr_srcdir(), path, fname)) } end end class ToplevelInstaller Version = '3.4.1' Copyright = 'Copyright (c) 2000-2005 Minero Aoki' TASKS = [ [ 'all', 'do config, setup, then install' ], [ 'config', 'saves your configurations' ], [ 'show', 'shows current configuration' ], [ 'setup', 'compiles ruby extentions and others' ], [ 'install', 'installs files' ], [ 'test', 'run all tests in test/' ], [ 'clean', "does `make clean' for each extention" ], [ 'distclean',"does `make distclean' for each extention" ] ] def ToplevelInstaller.invoke config = ConfigTable.new(load_rbconfig()) config.load_standard_entries config.load_multipackage_entries if multipackage? config.fixup klass = (multipackage?() ? ToplevelInstallerMulti : ToplevelInstaller) klass.new(File.dirname($0), config).invoke end def ToplevelInstaller.multipackage? File.dir?(File.dirname($0) + '/packages') end def ToplevelInstaller.load_rbconfig if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg } ARGV.delete(arg) load File.expand_path(arg.split(/=/, 2)[1]) $".push 'rbconfig.rb' else require 'rbconfig' end ::Config::CONFIG end def initialize(ardir_root, config) @ardir = File.expand_path(ardir_root) @config = config # cache @valid_task_re = nil end def config(key) @config[key] end def inspect "#<#{self.class} #{__id__()}>" end def invoke run_metaconfigs case task = parsearg_global() when nil, 'all' parsearg_config init_installers exec_config exec_setup exec_install else case task when 'config', 'test' ; when 'clean', 'distclean' @config.load_savefile if File.exist?(@config.savefile) else @config.load_savefile end __send__ "parsearg_#{task}" init_installers __send__ "exec_#{task}" end end def run_metaconfigs @config.load_script "#{@ardir}/metaconfig" end def init_installers @installer = Installer.new(@config, @ardir, File.expand_path('.')) end # # Hook Script API bases # def srcdir_root @ardir end def objdir_root '.' end def relpath '.' end # # Option Parsing # def parsearg_global while arg = ARGV.shift case arg when /\A\w+\z/ setup_rb_error "invalid task: #{arg}" unless valid_task?(arg) return arg when '-q', '--quiet' @config.verbose = false when '--verbose' @config.verbose = true when '--help' print_usage $stdout exit 0 when '--version' puts "#{File.basename($0)} version #{Version}" exit 0 when '--copyright' puts Copyright exit 0 else setup_rb_error "unknown global option '#{arg}'" end end nil end def valid_task?(t) valid_task_re() =~ t end def valid_task_re @valid_task_re ||= /\A(?:#{TASKS.map {|task,desc| task }.join('|')})\z/ end def parsearg_no_options unless ARGV.empty? task = caller(0).first.slice(%r<`parsearg_(\w+)'>, 1) setup_rb_error "#{task}: unknown options: #{ARGV.join(' ')}" end end alias parsearg_show parsearg_no_options alias parsearg_setup parsearg_no_options alias parsearg_test parsearg_no_options alias parsearg_clean parsearg_no_options alias parsearg_distclean parsearg_no_options def parsearg_config evalopt = [] set = [] @config.config_opt = [] while i = ARGV.shift if /\A--?\z/ =~ i @config.config_opt = ARGV.dup break end name, value = *@config.parse_opt(i) if @config.value_config?(name) @config[name] = value else evalopt.push [name, value] end set.push name end evalopt.each do |name, value| @config.lookup(name).evaluate value, @config end # Check if configuration is valid set.each do |n| @config[n] if @config.value_config?(n) end end def parsearg_install @config.no_harm = false @config.install_prefix = '' while a = ARGV.shift case a when '--no-harm' @config.no_harm = true when /\A--prefix=/ path = a.split(/=/, 2)[1] path = File.expand_path(path) unless path[0,1] == '/' @config.install_prefix = path else setup_rb_error "install: unknown option #{a}" end end end def print_usage(out) out.puts 'Typical Installation Procedure:' out.puts " $ ruby #{File.basename $0} config" out.puts " $ ruby #{File.basename $0} setup" out.puts " # ruby #{File.basename $0} install (may require root privilege)" out.puts out.puts 'Detailed Usage:' out.puts " ruby #{File.basename $0} " out.puts " ruby #{File.basename $0} [] []" fmt = " %-24s %s\n" out.puts out.puts 'Global options:' out.printf fmt, '-q,--quiet', 'suppress message outputs' out.printf fmt, ' --verbose', 'output messages verbosely' out.printf fmt, ' --help', 'print this message' out.printf fmt, ' --version', 'print version and quit' out.printf fmt, ' --copyright', 'print copyright and quit' out.puts out.puts 'Tasks:' TASKS.each do |name, desc| out.printf fmt, name, desc end fmt = " %-24s %s [%s]\n" out.puts out.puts 'Options for CONFIG or ALL:' @config.each do |item| out.printf fmt, item.help_opt, item.description, item.help_default end out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's" out.puts out.puts 'Options for INSTALL:' out.printf fmt, '--no-harm', 'only display what to do if given', 'off' out.printf fmt, '--prefix=path', 'install path prefix', '' out.puts end # # Task Handlers # def exec_config @installer.exec_config @config.save # must be final end def exec_setup @installer.exec_setup end def exec_install @installer.exec_install end def exec_test @installer.exec_test end def exec_show @config.each do |i| printf "%-20s %s\n", i.name, i.value if i.value? end end def exec_clean @installer.exec_clean end def exec_distclean @installer.exec_distclean end end # class ToplevelInstaller class ToplevelInstallerMulti < ToplevelInstaller include FileOperations def initialize(ardir_root, config) super @packages = directories_of("#{@ardir}/packages") raise 'no package exists' if @packages.empty? @root_installer = Installer.new(@config, @ardir, File.expand_path('.')) end def run_metaconfigs @config.load_script "#{@ardir}/metaconfig", self @packages.each do |name| @config.load_script "#{@ardir}/packages/#{name}/metaconfig" end end attr_reader :packages def packages=(list) raise 'package list is empty' if list.empty? list.each do |name| raise "directory packages/#{name} does not exist"\ unless File.dir?("#{@ardir}/packages/#{name}") end @packages = list end def init_installers @installers = {} @packages.each do |pack| @installers[pack] = Installer.new(@config, "#{@ardir}/packages/#{pack}", "packages/#{pack}") end with = extract_selection(config('with')) without = extract_selection(config('without')) @selected = @installers.keys.select {|name| (with.empty? or with.include?(name)) \ and not without.include?(name) } end def extract_selection(list) a = list.split(/,/) a.each do |name| setup_rb_error "no such package: #{name}" unless @installers.key?(name) end a end def print_usage(f) super f.puts 'Inluded packages:' f.puts ' ' + @packages.sort.join(' ') f.puts end # # Task Handlers # def exec_config run_hook 'pre-config' each_selected_installers {|inst| inst.exec_config } run_hook 'post-config' @config.save # must be final end def exec_setup run_hook 'pre-setup' each_selected_installers {|inst| inst.exec_setup } run_hook 'post-setup' end def exec_install run_hook 'pre-install' each_selected_installers {|inst| inst.exec_install } run_hook 'post-install' end def exec_test run_hook 'pre-test' each_selected_installers {|inst| inst.exec_test } run_hook 'post-test' end def exec_clean rm_f @config.savefile run_hook 'pre-clean' each_selected_installers {|inst| inst.exec_clean } run_hook 'post-clean' end def exec_distclean rm_f @config.savefile run_hook 'pre-distclean' each_selected_installers {|inst| inst.exec_distclean } run_hook 'post-distclean' end # # lib # def each_selected_installers Dir.mkdir 'packages' unless File.dir?('packages') @selected.each do |pack| $stderr.puts "Processing the package `#{pack}' ..." if verbose? Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}") Dir.chdir "packages/#{pack}" yield @installers[pack] Dir.chdir '../..' end end def run_hook(id) @root_installer.run_hook id end # module FileOperations requires this def verbose? @config.verbose? end # module FileOperations requires this def no_harm? @config.no_harm? end end # class ToplevelInstallerMulti class Installer FILETYPES = %w( bin lib ext data conf man ) include FileOperations include HookScriptAPI def initialize(config, srcroot, objroot) @config = config @srcdir = File.expand_path(srcroot) @objdir = File.expand_path(objroot) @currdir = '.' end def inspect "#<#{self.class} #{File.basename(@srcdir)}>" end def noop(rel) end # # Hook Script API base methods # def srcdir_root @srcdir end def objdir_root @objdir end def relpath @currdir end # # Config Access # # module FileOperations requires this def verbose? @config.verbose? end # module FileOperations requires this def no_harm? @config.no_harm? end def verbose_off begin save, @config.verbose = @config.verbose?, false yield ensure @config.verbose = save end end # # TASK config # def exec_config exec_task_traverse 'config' end alias config_dir_bin noop alias config_dir_lib noop def config_dir_ext(rel) extconf if extdir?(curr_srcdir()) end alias config_dir_data noop alias config_dir_conf noop alias config_dir_man noop def extconf ruby "#{curr_srcdir()}/extconf.rb", *@config.config_opt end # # TASK setup # def exec_setup exec_task_traverse 'setup' end def setup_dir_bin(rel) files_of(curr_srcdir()).each do |fname| update_shebang_line "#{curr_srcdir()}/#{fname}" end end alias setup_dir_lib noop def setup_dir_ext(rel) make if extdir?(curr_srcdir()) end alias setup_dir_data noop alias setup_dir_conf noop alias setup_dir_man noop def update_shebang_line(path) return if no_harm? return if config('shebang') == 'never' old = Shebang.load(path) if old $stderr.puts "warning: #{path}: Shebang line includes too many args. It is not portable and your program may not work." if old.args.size > 1 new = new_shebang(old) return if new.to_s == old.to_s else return unless config('shebang') == 'all' new = Shebang.new(config('rubypath')) end $stderr.puts "updating shebang: #{File.basename(path)}" if verbose? open_atomic_writer(path) {|output| File.open(path, 'rb') {|f| f.gets if old # discard output.puts new.to_s output.print f.read } } end def new_shebang(old) if /\Aruby/ =~ File.basename(old.cmd) Shebang.new(config('rubypath'), old.args) elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby' Shebang.new(config('rubypath'), old.args[1..-1]) else return old unless config('shebang') == 'all' Shebang.new(config('rubypath')) end end def open_atomic_writer(path, &block) tmpfile = File.basename(path) + '.tmp' begin File.open(tmpfile, 'wb', &block) File.rename tmpfile, File.basename(path) ensure File.unlink tmpfile if File.exist?(tmpfile) end end class Shebang def Shebang.load(path) line = nil File.open(path) {|f| line = f.gets } return nil unless /\A#!/ =~ line parse(line) end def Shebang.parse(line) cmd, *args = *line.strip.sub(/\A\#!/, '').split(' ') new(cmd, args) end def initialize(cmd, args = []) @cmd = cmd @args = args end attr_reader :cmd attr_reader :args def to_s "#! #{@cmd}" + (@args.empty? ? '' : " #{@args.join(' ')}") end end # # TASK install # def exec_install rm_f 'InstalledFiles' exec_task_traverse 'install' end def install_dir_bin(rel) install_files targetfiles(), "#{config('bindir')}/#{rel}", 0755 end def install_dir_lib(rel) install_files libfiles(), "#{config('rbdir')}/#{rel}", 0644 end def install_dir_ext(rel) return unless extdir?(curr_srcdir()) install_files rubyextentions('.'), "#{config('sodir')}/#{File.dirname(rel)}", 0555 end def install_dir_data(rel) install_files targetfiles(), "#{config('datadir')}/#{rel}", 0644 end def install_dir_conf(rel) # FIXME: should not remove current config files # (rename previous file to .old/.org) install_files targetfiles(), "#{config('sysconfdir')}/#{rel}", 0644 end def install_dir_man(rel) install_files targetfiles(), "#{config('mandir')}/#{rel}", 0644 end def install_files(list, dest, mode) mkdir_p dest, @config.install_prefix list.each do |fname| install fname, dest, mode, @config.install_prefix end end def libfiles glob_reject(%w(*.y *.output), targetfiles()) end def rubyextentions(dir) ents = glob_select("*.#{@config.dllext}", targetfiles()) if ents.empty? setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first" end ents end def targetfiles mapdir(existfiles() - hookfiles()) end def mapdir(ents) ents.map {|ent| if File.exist?(ent) then ent # objdir else "#{curr_srcdir()}/#{ent}" # srcdir end } end # picked up many entries from cvs-1.11.1/src/ignore.c JUNK_FILES = %w( core RCSLOG tags TAGS .make.state .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb *~ *.old *.bak *.BAK *.orig *.rej _$* *$ *.org *.in .* ) def existfiles glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.'))) end def hookfiles %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt| %w( config setup install clean ).map {|t| sprintf(fmt, t) } }.flatten end def glob_select(pat, ents) re = globs2re([pat]) ents.select {|ent| re =~ ent } end def glob_reject(pats, ents) re = globs2re(pats) ents.reject {|ent| re =~ ent } end GLOB2REGEX = { '.' => '\.', '$' => '\$', '#' => '\#', '*' => '.*' } def globs2re(pats) /\A(?:#{ pats.map {|pat| pat.gsub(/[\.\$\#\*]/) {|ch| GLOB2REGEX[ch] } }.join('|') })\z/ end # # TASK test # TESTDIR = 'test' def exec_test unless File.directory?('test') $stderr.puts 'no test in this package' if verbose? return end $stderr.puts 'Running tests...' if verbose? begin require 'test/unit' rescue LoadError setup_rb_error 'test/unit cannot loaded. You need Ruby 1.8 or later to invoke this task.' end runner = Test::Unit::AutoRunner.new(true) runner.to_run << TESTDIR runner.run end # # TASK clean # def exec_clean exec_task_traverse 'clean' rm_f @config.savefile rm_f 'InstalledFiles' end alias clean_dir_bin noop alias clean_dir_lib noop alias clean_dir_data noop alias clean_dir_conf noop alias clean_dir_man noop def clean_dir_ext(rel) return unless extdir?(curr_srcdir()) make 'clean' if File.file?('Makefile') end # # TASK distclean # def exec_distclean exec_task_traverse 'distclean' rm_f @config.savefile rm_f 'InstalledFiles' end alias distclean_dir_bin noop alias distclean_dir_lib noop def distclean_dir_ext(rel) return unless extdir?(curr_srcdir()) make 'distclean' if File.file?('Makefile') end alias distclean_dir_data noop alias distclean_dir_conf noop alias distclean_dir_man noop # # Traversing # def exec_task_traverse(task) run_hook "pre-#{task}" FILETYPES.each do |type| if type == 'ext' and config('without-ext') == 'yes' $stderr.puts 'skipping ext/* by user option' if verbose? next end traverse task, type, "#{task}_dir_#{type}" end run_hook "post-#{task}" end def traverse(task, rel, mid) dive_into(rel) { run_hook "pre-#{task}" __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '') directories_of(curr_srcdir()).each do |d| traverse task, "#{rel}/#{d}", mid end run_hook "post-#{task}" } end def dive_into(rel) return unless File.dir?("#{@srcdir}/#{rel}") dir = File.basename(rel) Dir.mkdir dir unless File.dir?(dir) prevdir = Dir.pwd Dir.chdir dir $stderr.puts '---> ' + rel if verbose? @currdir = rel yield Dir.chdir prevdir $stderr.puts '<--- ' + rel if verbose? @currdir = File.dirname(rel) end def run_hook(id) path = [ "#{curr_srcdir()}/#{id}", "#{curr_srcdir()}/#{id}.rb" ].detect {|cand| File.file?(cand) } return unless path begin instance_eval File.read(path), path, 1 rescue raise if $DEBUG setup_rb_error "hook #{path} failed:\n" + $!.message end end end # class Installer class SetupError < StandardError; end def setup_rb_error(msg) raise SetupError, msg end if $0 == __FILE__ begin ToplevelInstaller.invoke rescue SetupError raise if $DEBUG $stderr.puts $!.message $stderr.puts "Try 'ruby #{$0} --help' for detailed usage." exit 1 end end gsl-1.15.3/THANKS0000644000175000017500000000107112220252463012654 0ustar boutilboutilTakeshi Horinouchi Masahide Kikkawa Seiya Nishizawa (Patches, NArray supports) Arno Erpenbeck (ruby-gsl project) Austin Newton Jordi Burguet Castell (gsl_tensor) Cameron McBride (Patches, vector/block manipulations) KOSHIRO Tsuyoshi (patches) GSL development team zunda (patches) Christopher Butler Andrea Censi (Bug report on Vector#*) Daigo Moriwaki (Bug report) Joe Wölfel (Ruby-1.9 support) Cyrus Hall (patch for Ruby-1.9) Dave MacMahon (patch for FFT and interface refinements) Roman Shterenzon (Non-negative Matrix Factorization) gsl-1.15.3/examples/0000755000175000017500000000000012220252463013560 5ustar boutilboutilgsl-1.15.3/examples/multiroot/0000755000175000017500000000000012220252463015616 5ustar boutilboutilgsl-1.15.3/examples/multiroot/fsolver3.rb0000755000175000017500000000134012220252463017707 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math # Expected: x0 ~ 0.57983, x1 ~ 2.54621 func = GSL::MultiRoot::Function.alloc(2) { |x, f| x0 = x[0] x1 = x[1] f[0] = -2.0*x0*x0 + 3.0*x0*x1 + 4.0*sin(x1) - 6.0 f[1] = 3.0*x0*x0 - 2.0*x0*x1*x1 + 3.0*cos(x0) + 4.0 } p func.solve([1.0, 2.0].to_gv, 1000, 1e-7, "hybrids") p func.solve([1.0, 2.0].to_gv, 1000, "broyden") p func.solve([1.0, 2.0], "hybrid") p func.solve([1.0, 2.0], 2000, "hybrid") p func.solve([1.0, 2.0]) #fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2) fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2) x = GSL::Vector.alloc([1.0, 2.0]) fsolver.set(func, x) p ans = fsolver.solve() #ans = MultiRoot::FSolver.solve(fsolver) gsl-1.15.3/examples/multiroot/fdfsolver.rb0000755000175000017500000000203112220252463020134 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 2 procf = Proc.new { |x, params, f| a = params[0] b = params[1] x0 = x[0] x1 = x[1] f[0] = a*(1 - x0) f[1] = b*(x1 - x0*x0) } procdf = Proc.new { |x, params, jac| a = params[0] b = params[1] jac[0,0] = -a jac[0,1] = 0 jac[1,0] = -2*b*x[0] jac[1,1] = b } params = [1.0, 10.0] f = GSL::MultiRoot::Function_fdf.alloc(procf, procdf, n, params) fdfsolver = GSL::MultiRoot::FdfSolver.alloc("gnewton", n) #fdfsolver = GSL::MultiRoot::FdfSolver.alloc("newton", n) #fdfsolver = GSL::MultiRoot::FdfSolver.alloc("hybridj", n) #fdfsolver = GSL::MultiRoot::FdfSolver.alloc("hybridsj", n) p fdfsolver.name #x = GSL::Vector.alloc(-10.0, -5.0) x = [-10.0, -5.0] #p fdfsolver.x fdfsolver.set(f, x) iter = 0 begin iter += 1 status = fdfsolver.iterate root = fdfsolver.root f = fdfsolver.f printf("iter = %3u x = % .3f % .3f f(x) = % .3e % .3e\n", iter, root[0], root[1], f[0], f[1]) status = fdfsolver.test_residual(1e-7) end while status == GSL::CONTINUE and iter < 1000 gsl-1.15.3/examples/multiroot/fsolver2.rb0000755000175000017500000000132012220252463017704 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math # Expected: x0 ~ 0.57983, x1 ~ 2.54621 # (by Octave) func = GSL::MultiRoot::Function.alloc(2) { |x, f| x0 = x[0] x1 = x[1] f[0] = -2.0*x0*x0 + 3.0*x0*x1 + 4.0*sin(x1) - 6.0 f[1] = 3.0*x0*x0 - 2.0*x0*x1*x1 + 3.0*cos(x0) + 4.0 } #fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2) fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2) p fsolver.name x = GSL::Vector.alloc([1.0, 2.0]) fsolver.set(func, x) iter = 0 begin iter += 1 status = fsolver.iterate root = fsolver.root f = fsolver.f status = fsolver.test_residual(1e-6) end while status == GSL::CONTINUE and iter < 1000 x0 = fsolver.root[0] x1 = fsolver.root[1] printf("%f %f\n", x0, x1) gsl-1.15.3/examples/multiroot/fsolver.rb0000755000175000017500000000146412220252463017633 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") params = [1.0, 10.0] func = GSL::MultiRoot::Function.alloc(2, params) { |x, params, f| a = params[0] b = params[1] x0 = x[0] x1 = x[1] f[0] = a*(1 - x0) f[1] = b*(x1 - x0*x0) } #fsolver = GSL::MultiRoot::FSolver.alloc("hybrids", 2) #fsolver = GSL::MultiRoot::FSolver.alloc("hybrid", 2) #fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2) fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2) x = GSL::Vector.alloc(-10.0, -5.0) fsolver.set(func, x) #p fsolver.name #p fsolver.x iter = 0 begin iter += 1 status = fsolver.iterate root = fsolver.root f = fsolver.f printf("iter = %3u x = % .3f % .3f f(x) = % .3e % .3e\n", iter, root[0], root[1], f[0], f[1]) status = fsolver.test_residual(1e-7) end while status == GSL::CONTINUE and iter < 1000 gsl-1.15.3/examples/multiroot/demo.rb0000755000175000017500000000165712220252463017103 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") params = [1.0, 10.0] func = GSL::MultiRoot::Function.alloc(2, params) { |x, params, f| a = params[0] b = params[1] x0 = x[0] x1 = x[1] f[0] = a*(1 - x0) f[1] = b*(x1 - x0*x0) } fsolver = GSL::MultiRoot::FSolver.alloc("hybrids", 2) #fsolver = GSL::MultiRoot::FSolver.alloc("hybrid", 2) #fsolver = GSL::MultiRoot::FSolver.alloc("dallocton", 2) #fsolver = GSL::MultiRoot::FSolver.alloc("broyden", 2) x = GSL::Vector.alloc(-10.0, -5.0) fsolver.set(func, x) #p fsolver.name #p fsolver.x iter = 0 IO.popen("graph -T X -C -g 3 -X x -Y y -S 4", "w") do |io| begin iter += 1 status = fsolver.iterate root = fsolver.root f = fsolver.f printf("iter = %3u x = % .3f % .3f f(x) = % .3e % .3e\n", iter, root[0], root[1], f[0], f[1]) io.printf("%e %e\n", root[0], root[1]) status = fsolver.test_residual(1e-7) end while status == GSL::CONTINUE and iter < 1000 end gsl-1.15.3/examples/random/0000755000175000017500000000000012220252463015040 5ustar boutilboutilgsl-1.15.3/examples/random/generator.rb0000755000175000017500000000154012220252463017356 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL names = ["default", "mt19937", "mt19937_1999", "mt19937_1998", "ranlxs0", "ranlxs1", "ranlxs2", "ranlxd1", "ranlxd2", "ranlux", "ranlux389", "cmrg", "mrg", "taus", "taus2", "gfsr4", "rand", "random_bsd", "random8_bsd", "random32_bsd", "random64_bsd", "random128_bsd", "random256_bsd", "random_libc5", "random_glibc2", "rand48", "ran0", "ran1", "ran2", "ran3", "ranf", "ranmar", "r250", "tt800", "vax", "transputer", "randu", "minstd", "uni", "uni32", "slatec", "zuf", "borosh13", "coveyou", "fishman18", "fishman20", "fishman2x", "knuthran2", "knuthran", "lecuyer21", "waterman14"] names.each do |name| r = Rng.alloc(name) printf("%s %s\n", name, r.name) end names.each do |name| name2 = "gsl_rng_" + name r = Rng.alloc(name) printf("%s %s\n", name, r.name) end r = Rng.alloc(Rng::KNUTHRAN) p r.name gsl-1.15.3/examples/random/gaussian.rb0000755000175000017500000000017312220252463017203 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 r = GSL::Rng.alloc v = r.gaussian(1, N) h = v.histogram(100, -4, 4) h.graph gsl-1.15.3/examples/random/poisson.rb0000755000175000017500000000017112220252463017061 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 r = GSL::Rng.alloc v = r.poisson(5, N) h = v.histogram(20, 0, 20) h.graph gsl-1.15.3/examples/random/rngextra.rb0000755000175000017500000000032512220252463017222 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") r1 = GSL::Rng.alloc(GSL::Rng::RNGEXTRA_RNG1) p r1.name p r1.uniform p r1.gaussian r2 = GSL::Rng.alloc("rngextra_rng2") p r2.name p r2.get p r2.get p r2.uniform p r2.poisson(3) gsl-1.15.3/examples/random/diffusion.rb0000755000175000017500000000134412220252463017360 0ustar boutilboutil#!/usr/bin/env ruby # 1-dimensional random work: # This demonstrates M = 1000 trials of N = 6, 50 and 100 left-or-right steps. # The distribution of the end points of the trials # will be Gaussian of standard deviation sqrt(N). require("gsl") M = 1000 GSL::Rng.env_setup() T = GSL::Rng::DEFAULT seed = 2 rng = GSL::Rng.alloc(T, seed) h = Array.new(3) h[0] = GSL::Histogram.alloc(61, -30, 30) h[1] = GSL::Histogram.alloc(61, -30, 30) h[2] = GSL::Histogram.alloc(61, -30, 30) i = 0 for n in [6, 50, 100] do M.times do s = 0 n.times do ds = rng.get%2 == 0 ? 1 : -1 s += ds end h[i].increment(s) end i += 1 end #GSL::graph(h[0].shift(250), h[1].shift(100), h[2]) GSL::graph(h[0] + 250, h[1] + 100, h[2]) gsl-1.15.3/examples/random/qrng.rb0000755000175000017500000000106012220252463016334 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL dim = 2 #q = QRng.alloc(QRng::SOBOL, dim) q = QRng.alloc("sobol", dim) #q = QRng.alloc("niederreiter_2", dim) #q = QRng.alloc(QRng::NIEDERREITER_2, dim) v = Vector.alloc(dim) IO.popen("graph -T X -C --title-font-size 0.04 -L 'Distribution of first 1024 points from the quasi-random Sobol sequence' -m -1 -S 2", "w") do |io| for i in 0..1024 do # v = q.get() # by creating a alloc vector q.get(v) # by using an existing vector (efficient) io.printf("%e %e\n", v[0], v[1]) end end gsl-1.15.3/examples/random/randomwalk.rb0000755000175000017500000000162312220252463017531 0ustar boutilboutil#!/usr/bin/env ruby # 1-dimensional random work: # This demonstrates 1000 trials of 50 left-or-right steps. # The distribution of the end points of the trials # will be Gaussian of standard deviation sqrt(50). require("gsl") N = 50 M = 1000 GSL::Rng.env_setup() T = GSL::Rng::DEFAULT seed = 2 rng = GSL::Rng.alloc(T, seed) sigma = Math::sqrt(N).to_i h = GSL::Histogram.alloc(8*sigma+1, [-4*sigma-0.5, 4*sigma+0.5]) M.times do s = 0 N.times do ds = rng.get%2 == 0 ? 1 : -1 s += ds end h.increment(s) end x = GSL::Vector.linspace(-40, 40, 80) y = GSL::Ran::gaussian_pdf(x, sigma)*M*2 # Factor 2 is not important, but necessary # because only the even ranges are filled: # a + b = N a: positive steps, b: negative steps # a - b = s s: the end point after the N steps # Since N = 1000 and a, b, s are integer, s must be even. GSL::graph(h, [x, y], "-C -x #{-4*sigma} #{4*sigma}") gsl-1.15.3/examples/random/rng.rb0000755000175000017500000000054612220252463016163 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") r = GSL::Rng.alloc 10.times { p r.uniform } __END__ #include GSL #require 'gsl/gsl_rng' r = GSL::Random::Rng.alloc r.set(2) p r.get p r.get p r.max p r.get p r.get r2 = GSL::Random::Rng.alloc p r2.uniform p r2.uniform __END__ rf = GSL::Random::Rng.alloc p rf.uniform p rf.uniform p rf.name p gsl_rng_types_setup gsl-1.15.3/examples/random/randomwalk2d.rb0000755000175000017500000000035612220252463017761 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 1000 GSL::Rng.env_setup() T = GSL::Rng::DEFAULT r = GSL::Rng.alloc(T) x = 0.0 y = 0.0 printf("%g %g\n", x, y); N.times do dx, dy = r.dir_2d() x += dx y += dy printf("%g %g\n", x, y); end gsl-1.15.3/examples/random/hdsobol.rb0000755000175000017500000000107612220252463017026 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL dim = 2 q = QRng.alloc(QRng::HDSOBOL, dim) #q = QRng.alloc("sobol", dim) #q = QRng.alloc("niederreiter_2", dim) #q = QRng.alloc(QRng::NIEDERREITER_2, dim) p q.name v = Vector.alloc(dim) IO.popen("graph -T X -C --title-font-size 0.04 -L 'Distribution of first 1024 points from the quasi-random HDSobol sequence' -m -1 -S 2", "w") do |io| for i in 0..1024 do # v = q.get() # by creating a alloc vector q.get(v) # by using an existing vector (efficient) io.printf("%e %e\n", v[0], v[1]) end end gsl-1.15.3/examples/random/rayleigh.rb0000755000175000017500000000121312220252463017171 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") rng = GSL::Rng.alloc() N = 100 XMAX = 5.0 sigma = 1.0 h = GSL::Histogram.alloc(N, 0, XMAX) for i in 0...10000 do x = rng.rayleigh(sigma) h.increment(x) end sig, amp = h.fit_rayleigh p sig p amp v = GSL::Vector.linspace(0, XMAX, N) val = GSL::Ran::rayleigh_pdf(v, sig) val *= amp GSL::graph(h, [v, val], "-T X -C") h2 = GSL::Histogram.alloc(N, 0, XMAX) for i in 0...10000 do x = rng.gaussian(sigma) y = rng.gaussian(sigma) r = Math.sqrt(x*x + y*y) h2.increment(r) end sig2, amp2 = h2.fit_rayleigh p sig2 p amp2 val2 = GSL::Ran::rayleigh_pdf(v, sig2) val2 *= amp2 GSL::graph(h2, [v, val2], "-T X -C") gsl-1.15.3/examples/dirac.rb0000755000175000017500000000143112220252463015171 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::Dirac I = GSL::Complex[0, 1] p Pauli1 p Pauli2 p Pauli3 p (Pauli1*Pauli2 - Pauli2*Pauli1)/I/2 p Dirac.anticommute(Pauli1, Pauli1) p Dirac.anticommute(Pauli1, Pauli2) #p Eye2 #p Eye4 p Beta p Alpha1 p Alpha2 p Alpha3 p Alpha1*Alpha1 p Alpha2*Alpha2 p Alpha3*Alpha3 p GSL::Dirac.anticommute(Alpha1, Alpha1) p GSL::Dirac.anticommute(Alpha1, Alpha2) p GSL::Dirac.anticommute(Gamma0, Gamma0) p GSL::Dirac.anticommute(Gamma1, Gamma1) p GSL::Dirac.anticommute(Gamma2, Gamma2) p GSL::Dirac.anticommute(Gamma3, Gamma3) p GSL::Dirac.anticommute(Gamma3, Gamma0) p IEye4*Gamma0*Gamma1*Gamma2*Gamma3 p Pauli2 p Pauli2.conjugate p Pauli2 p Pauli3 p Pauli3.dagger p Lambda1 p Lambda2 p Lambda3 p Lambda4 p Lambda5 p Lambda6 p Lambda7 p Lambda8 gsl-1.15.3/examples/fresnel.rb0000755000175000017500000000045512220252463015552 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") # Abramovitz & Stegun fc01 = 0.0999975 fs01 = 0.0005236 printf("fresnel_c(0.1):\n") printf("Expect: %2.7f \t Calculated: %2.7f \n ", fc01, GSL::fresnel_c(0.1)) printf("fresnel_s(0.1):\n") printf("Expect: %2.7f \t Calculated: %2.7f \n ", fs01, GSL::fresnel_s(0.1)) gsl-1.15.3/examples/matrix/0000755000175000017500000000000012220252463015064 5ustar boutilboutilgsl-1.15.3/examples/matrix/read.rb0000755000175000017500000000115512220252463016331 0ustar boutilboutil#!/usr/bin/env ruby # Turn on warnings $-w = true require 'irb/xmp' require 'gsl' # Apparently, IRB::Frame has a bug that prevents the defaults from working, so # an XMP instance must be created explicitly this way instead of using the # otherwise convenient xmp method. XMP.new(IRB::Frame.top(-1)).puts < 1.0 sin(tmp*r)/tmp elsif @Omega < 1.0 sinh(tmp*r)/tmp else r end end def luminosity_distance(z) r = self.comoving_distance(z) s = self.conformal_factor(r) [r, (1.0 + z)*s] # comoving distance, luminosity distance end attr_reader :h attr_reader :H0 attr_reader :matter attr_reader :lambda attr_reader :radiation attr_reader :Omega attr_reader :k attr_reader :q end end gsl-1.15.3/examples/integration/friedmann.gp0000644000175000017500000000106712220252463020402 0ustar boutilboutil#set terminal postscript eps enhanced color #set output 'tmp.eps' set xlabel 'Redshift z' set ylabel 'Luminosity Distance [1/H0]' set ytics nomirror set grid set y2tics set yrange [0:13] set y2range [0:54.89] #set logscale xy #set logscale y2 #set yrange [0.01:11] #set y2range [0.04:60] set y2label 'Luminosity Distance [Gpc] (h = 0.71)' plot 'friedmann.dat' u 1:3 title 'Matter = 1, Lambda = 0 (Einstein - de Sitter)' w l lw 3, '' u 1:5 title 'Matter = 0.27, Lambda = 0.73 (WMAP, Lambda-CDM)' w l lw 3, '' u 1:7 title 'Matter = 0, Lambda = 1 (de Sitter)' w l lw 3 gsl-1.15.3/examples/integration/ahmed.rb0000755000175000017500000000055512220252463017516 0ustar boutilboutil#!/usr/bin/env ruby # Ahmed's Integral # See e.g. http://mathworld.wolfram.com/AhmedsIntegral.html # require("gsl") include GSL include Math f = Function.alloc { |x| sqrtx22 = sqrt(x*x + 2) atan(sqrtx22)/(sqrtx22*(x*x + 1)) } val = f.qng(0, 1)[0] puts("Ahmed's integral") puts("Expect: 5pi^2/96 = #{5.0*M_PI*M_PI/96}") puts("QNG result: #{val}") gsl-1.15.3/examples/integration/qawc.rb0000755000175000017500000000055012220252463017366 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' include GSL include Math f459 = Function.alloc { |x| 1.0/(5.0*x*x*x + 6.0) } exp_result = -8.994400695837000137E-02 exp_abserr = 1.185290176227023727E-06 result = f459.qawc([-1.0, 5.0], 0, [0.0, 1e-3]) p result puts("exp_result: #{exp_result}") puts("exp_abserr: #{exp_abserr}") p Integration.qawc(f459, [-1.0, 5.0], 0) gsl-1.15.3/examples/integration/qag3.rb0000755000175000017500000000025612220252463017271 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math f = GSL::Function.alloc { |x| x*sin(1.0/x)*sqrt((1 - x).abs) } w = GSL::Integration::Workspace.alloc(1000) p f.qag(0, 3, w) gsl-1.15.3/examples/integration/qawo.rb0000755000175000017500000000117712220252463017410 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' include GSL include Math f456 = Function.alloc { |x| if x.zero? val = 0.0 else val = log(x) end val } exp_result = -1.281368483991674190E-01 exp_abserr = 6.875028324415666248E-12 table = [10.0*PI, 1.0, GSL::Integration::SINE, 1000] result = f456.qawo(0.0, [0.0, 1e-7], table) p result puts("exp_result: #{exp_result}") puts("exp_abserr: #{exp_abserr}") table = Integration::QAWO_Table.alloc(10.0*PI, 1.0, GSL::Integration::SINE, 1000) p f456.qawo(0.0, [0.0, 1e-7], table) p f456.qawo(0.0, table) p Integration.qawo(f456, 0.0, table) p Integration.qawo(f456, 0.0, [0.0, 1e-7], table) gsl-1.15.3/examples/integration/qag2.rb0000755000175000017500000000033212220252463017263 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") # Singular at x = 0 f = GSL::Function.alloc { |x| 1.0/Math::sqrt(x) } puts("QAG") p f.qag(0, 1) p f.qag([0, 1]) p GSL::Integration.qag(f, 0, 1) p GSL::Integration.qag(f, [0, 1]) gsl-1.15.3/examples/integration/gamma-zeta.rb0000755000175000017500000000117412220252463020461 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Math w = Integration::Workspace.alloc(1000) xmin = 0.0 f = Function.alloc{ |x, n| pow(x, n-1)/(exp(x) - 1.0) } nv = Vector[2..5] y1 = Sf::gamma(nv)*Sf::zeta(nv) y2 = Vector[10] begin file1 = File.open("y1.dat", "w") file2 = File.open("y2.dat", "w") nv.each do |n| f.set_params(n) y2[n.to_i-2] = f.qagiu(xmin, w)[0] file1.printf("%e %e\n", n, y1[n.to_i-2]) file2.printf("%e %e\n", n, y2[n.to_i-2]) end ensure file1.close file2.close end system("graph -T X -C -g 3 -m 1 'y2.dat' -m -2 -S 4 'y1.dat' ") File.delete("y1.dat") File.delete("y2.dat") gsl-1.15.3/examples/integration/qags.rb0000755000175000017500000000033312220252463017365 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL # Singular at x = 0 f = Function.alloc { |x| 1.0/Math::sqrt(x) } puts("QAGS") p f.qags(0, 1) p f.qags([0, 1]) p Integration.qags(f, 0, 1) p Integration.qags(f, [0, 1]) gsl-1.15.3/examples/integration/qagi.rb0000755000175000017500000000127612220252463017362 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Math printf("QAGI (integrate [-infty:+infty])\n\n") w = Integration::Workspace.alloc(1000) f = Function.alloc{ |x, a| cos(x)/(x*x + a*a) } a = 1.0 f.set_params(a) printf("Case 1: f(x; a) = cos(x)/(x^2 + a^2), I(a) = pi/a e^(-a)\n") printf(" Expected: I(1) = %10.9f\n", M_PI*exp(-a)) printf(" QAGI Result: %10.9f\n", f.qagi([0, 1e-4], w)[0]) f = Function.alloc{ |x, a| exp(a*x)/(1 + exp(x)) } a = 0.3 f.set_params(a) printf("Case 2: f(x; a) = e^{ax}/(1 + e^x), I(a) = pi/sin(a pi)\n") printf(" Expected: I(0.3) = %10.9f\n", M_PI/sin(a*M_PI)) printf(" QAGI Result: %10.9f\n", f.qagi([0, 1e-2], w)[0]) gsl-1.15.3/examples/integration/qawf.rb0000755000175000017500000000177712220252463017405 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' include GSL include Math f457 = Function.alloc { |x| if x.zero? val = 0.0 else val = 1.0/sqrt(x) end val } exp_result = 9.999999999279802765E-01 exp_abserr = 1.556289974669056164E-08 table = [PI/2.0, 1.0, GSL::Integration::COSINE, 1000] result = f457.qawf(0.0, 1e-7, table) p result puts("exp_result: #{exp_result}") puts("exp_abserr: #{exp_abserr}") w = Integration::Workspace.alloc wc = Integration::Workspace.alloc limit = 1000 table = Integration::QAWO_Table.alloc(PI/2.0, 1.0, GSL::Integration::COSINE, 1000) p f457.qawf(0.0, table) p f457.qawf(0.0, 1e-7, table) p f457.qawf(0.0, 1e-7, limit, table) p f457.qawf(0.0, limit, table) p f457.qawf(0.0, 1e-7, limit, w, wc, table) p f457.qawf(0.0, w, wc, table) p f457.qawf(0.0, limit, w, wc, table) #p f457.qawf(0.0, limit, w, table) p Integration.qawf(f457, 0.0, table) p Integration.qawf(f457, 0.0, 1e-7, table) p Integration.qawf(f457, 0.0, 1e-7, limit, table) p Integration.qawf(f457, 0.0, limit, w, wc, table) gsl-1.15.3/examples/integration/integration.rb0000755000175000017500000000107112220252463020755 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math proc = Proc.new{ |x, alpha| log(alpha*x)/sqrt(x) } f = GSL::Function.alloc(proc) f.set_params(1.0) expected = -4.0 #result, error, neval = f.integration_qags([0.0, 1.0], 0.0, 1.0e-7, 1000) #result, error, neval = f.integration_qags([0.0, 1.0]) result, error, neval = f.qags([0.0, 1.0]) printf("result = %.18f\n", result); printf("exact result = %.18f\n", expected); printf("estimated error = %.18f\n", error); printf("actual error = %.18f\n", result - expected); printf("intervals = %d\n", neval); gsl-1.15.3/examples/integration/qagiu.rb0000755000175000017500000000131112220252463017535 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Math printf("QAGIU (integrate [0:+infty])\n\n") w = Integration::Workspace.alloc(1000) xmin = 0.0 f1 = Function.alloc{ |x, a| 1.0/(pow_4(x) + pow_4(a)) } printf("Case 1: f(x; a) = 1/(x^4 + a^4), I(a) = pi/2sqrt2/a^3\n") a = 1.0 printf(" Expected: I(1) = %10.9f\n", M_PI/2/M_SQRT2) f1.set_params(a) printf(" QAGIU Result: %10.9f\n\n", f1.qagiu(xmin, w)[0]) f2 = Function.alloc{ |x, a| x*x/(pow_4(x) + pow_4(a)) } printf("Case 2: f(x; a) = 1/(x^4 + a^4), I(a) = pi/2sqrt2/a\n") a = 2.0 printf(" Expected: I(2) = %10.9f\n", M_PI/2/M_SQRT2/a) f2.set_params(a) printf(" QAGIU Result: %10.9f\n\n", f2.qagiu(xmin, w)[0]) gsl-1.15.3/examples/integration/qng.rb0000755000175000017500000000042012220252463017214 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Math f = Function.alloc { |x| Math::sin(x)/x } p f.qng(0, 2.0*Math::PI) # Singular at x = 0 f2 = Function.alloc { |x| exp(-x)/sqrt(x) } # This will fail... #p f2.qng(0, 1) p Integration.qng(f, [0, 2*Math::PI]) gsl-1.15.3/examples/integration/qaws.rb0000755000175000017500000000110612220252463017404 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' include GSL include Math f458 = Function.alloc { |x| if x.zero? val = 0.0 else u = log(x) v = 1.0 + u*u val = 1.0/(v*v) end val } exp_result = -1.892751853489401670E-01 exp_abserr = 1.129133712015747658E-08 table = [0.0, 0.0, 1, 0] result = f458.qaws([0.0, 1.0], table, [0.0, 1e-7]) p result puts("exp_result: #{exp_result}") puts("exp_abserr: #{exp_abserr}") table = Integration::QAWS_Table.alloc(0.0, 0.0, 1, 0) result = f458.qaws([0.0, 1.0], table, [0.0, 1e-7]) p result p Integration.qaws(f458, [0.0, 1.0], table) gsl-1.15.3/examples/integration/qagp.rb0000755000175000017500000000062012220252463017361 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' include GSL include Math f454 = Function.alloc{ |x| x2 = x*x x3 = x2*x x3*log(((x2-1)*(x2-2)).abs) } exp_result = 5.274080611672716401E+01 exp_abserr = 1.755703848687062418E-04 pts = [0, 1, sqrt(2), 3] result = f454.qagp(pts, 0.0, 1e-3) p result puts("exp_result: #{exp_result}") puts("exp_abserr: #{exp_abserr}") p Integration.qagp(f454, pts, [0.0, 1e-3]) gsl-1.15.3/examples/cheb.rb0000755000175000017500000000045012220252463015010 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") f = GSL::Function.alloc { |x| if x < 0.5 0.25 else 0.75 end } n = 1000 order = 40 cs = GSL::Cheb.alloc(order) x = GSL::Vector.linspace(0, 1, n) ff = f.eval(x) cs.init(f, 0, 1) r10 = cs.eval_n(10, x) r40 = cs.eval(x) GSL::graph(x, ff, r10, r40) gsl-1.15.3/examples/eigen/0000755000175000017500000000000012220252463014647 5ustar boutilboutilgsl-1.15.3/examples/eigen/eigen.rb0000755000175000017500000000105312220252463016265 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") m = GSL::Matrix[[1.0, 1/2.0, 1/3.0, 1/4.0], [1/2.0, 1/3.0, 1/4.0, 1/5.0], [1/3.0, 1/4.0, 1/5.0, 1/6.0], [1/4.0, 1/5.0, 1/6.0, 1/7.0]] eigval = m.eigen_symm p eigval eigval, eigvec = m.eigen_symmv p eigval == GSL::Eigen.symm(m) val, vec = GSL::Eigen.symmv(m) p vec i = 0 vec.each_col do |v| a = (m*v)/v if a != val[i] puts("error") end i += 1 end # Diagonalization b = eigvec.inv*m*eigvec b.clean!(1e-10) p b d = b.diagonal p d == eigval prod = eigval.prod p GSL.equal?(prod, m.det, 1e-10) gsl-1.15.3/examples/eigen/qhoscillator.rb0000755000175000017500000000455412220252463017713 0ustar boutilboutil#!/usr/bin/env ruby # Harmonic oscillator in quantum mechanics # # This example is taken from "eigen1.cpp" # in "Numerische Physik" p214-216 (Springer). # # Reference: # "Numerische Physik", by Harald Wiedemann, Springer (2004) # ISBN: 3-540-40774-X # http://www.springeronline.com/sgw/cda/frontpage/0,10735,1-102-22-22345455-0,00.html require("gsl") STDERR.puts("Harmonic oscillator in quantum mechanics:") # Values used in the book: #NMAX = 512 #dx = 0.02 # These are much faster: NMAX = 64 dx = 0.16 # Potential V = GSL::Vector[NMAX] for n in 0...NMAX do x = (n - NMAX/2)*dx V[n] = 0.5*x*x end # Hamiltonian H = GSL::Matrix.calloc(NMAX, NMAX) H.set_diagonal(1.0/dx/dx + V) tmp = -0.5/dx/dx for n1 in 1...NMAX do H[n1-1,n1] = tmp H[n1,n1-1] = tmp end for n1 in 0...(NMAX-1) do H[n1+1,n1] = tmp H[n1,n1+1] = tmp end # Calculate eigen values and eigen vectors STDERR.print(" Solving the eigen system of #{NMAX}X#{NMAX} dimensions...") STDERR.flush eval, evec = H.eigen_symmv GSL::Eigen.symmv_sort(eval, evec, GSL::Eigen::SORT_VAL_ASC) STDERR.puts("OK") STDERR.flush x2 = GSL::Vector[NMAX] for n1 in 0...NMAX do x2[n1] = 0 for n2 in 0...NMAX do x = (n2 - NMAX/2)*dx x2[n1] += GSL::pow_2(evec[n2,n1]*x) end end # Energy eigen values, see p217 "Tabelle 5.1" # The differences with Tabelle 5.1 are from NMAX and dx. # If we use NMAX=512 and dx=0.02, we obtain the same results (but much slower). STDERR.puts(" Eigen values:") STDERR.printf(" %2s Exact %5s %10s | %2s Exact %5s %10s\n", "n", "E", "err\(\%\)", "n", "E", "err\(\%\)") STDERR.print(" -----------------------------------------------------\n") for n1 in 0..6 do exact1 = n1 + 0.5 exact2 = n1 + 7 + 0.5 STDERR.printf(" %2d %4.1f %8.5f %+7.5f | %2d %4.1f %8.5f %+7.5f\n", n1, exact1, eval[n1], (exact1 - eval[n1])/exact1*100, n1+7, exact2, eval[n1+7], (exact2-eval[n1+7])/exact2*100) end STDERR.flush # Eigen vectors of n = 0, 1, 2, 10. See p217 "Abb 5.3" c = Math::sqrt(1.0/dx) vec0 = evec.col(0).scale(c) vec1 = evec.col(1).scale(c) vec2 = evec.col(2).scale(c) vec10 = evec.col(10).scale(c) File.open("qhoscillator.dat", "w") do |fp| for i in 0...NMAX do x = (i - NMAX/2)*dx fp.printf("%e %e %e %e %e\n", x, -vec0[i], vec1[i], -vec2[i], -vec10[i]) end end system("gnuplot -persist qhoscillator.gp") File.delete("qhoscillator.dat") gsl-1.15.3/examples/eigen/vander.rb0000755000175000017500000000136712220252463016465 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") m = GSL::Matrix.vandermonde([1, 2, 3, 4]) p m eval, evec = m.eigen_nonsymmv p eval.real p evec.real GSL::Eigen::nonsymmv_sort(eval, evec, GSL::Eigen::SORT_ABS_ASC) p eval.real p evec.real =begin Octave result: octave:1> m = vander([1 2 3 4]) m = 1 1 1 1 8 4 2 1 27 9 3 1 64 16 4 1 octave:2> [v, d] = eig(m) v = 0.106363 0.137820 -0.129196 0.052254 0.228569 0.036136 0.407586 -0.375568 0.462688 -0.289537 0.376326 0.794157 0.849919 -0.946503 -0.821925 -0.474902 d = 15.48974 0.00000 0.00000 0.00000 0.00000 -7.70629 0.00000 0.00000 0.00000 0.00000 1.29422 0.00000 0.00000 0.00000 0.00000 -0.07768 =end gsl-1.15.3/examples/eigen/nonsymm.rb0000755000175000017500000000063712220252463016705 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") m = GSL::Matrix[[1, 2], [3, 4]] w = GSL::Eigen::Nonsymm::Workspace.alloc(2) v = GSL::Vector::Complex.alloc(2) #w.params(0, 1) #p GSL::Eigen.nonsymm(m) #p GSL::Eigen.nonsymm(m, v, w) p m.eigen_nonsymm #p m.eigen_nonsymm(v, w) #p m.eigen_nonsymm_Z #p m =begin Octave result: octave:1> m = [1 2; 3 4] m = 1 2 3 4 octave:2> eig(m) ans = -0.37228 5.37228 =end gsl-1.15.3/examples/eigen/nonsymmv.rb0000755000175000017500000000157012220252463017070 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") m = GSL::Matrix[[1, 2, 3], [4, 5, 0], [6, 0, 0]] evec, eval = m.eigen_nonsymmv p evec p eval m = GSL::Matrix.vandermonde([-1, -2, 3, 4]) w = GSL::Eigen::Nonsymmv.alloc(4) eval, evec = GSL::Eigen::nonsymmv(m, w) p eval p evec =begin This can be compared with the corresponding output from GNU OCTAVE, octave> [v,d] = eig(vander([-1 -2 3 4])); octave> diag(d) ans = -6.4139 + 0.0000i 5.5456 + 3.0854i 5.5456 - 3.0854i 2.3228 + 0.0000i octave> v v = Columns 1 through 3: -0.09988 + 0.00000i -0.04350 - 0.00755i -0.04350 + 0.00755i -0.11125 + 0.00000i 0.06399 - 0.14224i 0.06399 + 0.14224i 0.29250 + 0.00000i -0.51518 + 0.04142i -0.51518 - 0.04142i 0.94451 + 0.00000i -0.84059 + 0.00000i -0.84059 - 0.00000i Column 4: -0.14493 + 0.00000i 0.35660 + 0.00000i 0.91937 + 0.00000i 0.08118 + 0.00000i =end gsl-1.15.3/examples/eigen/qhoscillator.gp0000644000175000017500000000163012220252463017703 0ustar boutilboutilset multiplot set size 0.5, 0.5 set grid set key box set xrange [-5.5:5.5] # Hermite Polynomials H0(x) = 1 H1(x) = 2*x H2(x) = 4*x*x-2 H10(x) = -30240 + x*(0 + x*(302400 + x*(0 + x*(-403200 + x*(0 + x*(161280 + x*(0 + x*(-23040 + x*(0 + x*1024))))))))) # Normalization constant coef(n) = sqrt(1.0/2**n/gamma(n+1)/sqrt(pi)) psi0(x) = coef(0)*exp(-x*x/2)*H0(x) psi1(x) = coef(1)*exp(-x*x/2)*H1(x) psi2(x) = coef(2)*exp(-x*x/2)*H2(x) psi10(x) = coef(10)*exp(-x*x/2)*H10(x) set ylabel 'psi(x)' set pointsize 1 set origin 0, 0.5 plot psi0(x) title 'Exact: n = 0', "qhoscillator.dat" u 1:2 pt 7 title 'Numerical' set origin 0.5, 0.5 plot psi1(x) title 'Exact: n = 1', "qhoscillator.dat" u 1:3 pt 7 title 'Numerical' set origin 0, 0 plot psi2(x) title 'Exact: n = 2', "qhoscillator.dat" u 1:4 pt 7title 'Numerical' set origin 0.5, 0 plot psi10(x) title 'Exact: n = 10', "qhoscillator.dat" u 1:5 pt 7 title 'Numerical' gsl-1.15.3/examples/eigen/herm.rb0000755000175000017500000000044112220252463016131 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::Eigen m = GSL::Matrix::Complex.alloc(2, 2) m.set(0, 1, [0, -1]) m.set(1, 0, [0, 1]) p m val, vec = m.eigen_hermv p val p vec.unpack m2 = GSL::Matrix.alloc([1, 0, 0], [0, 0, 1], [0, 1, 0]) val, vec = m2.eigen_symmv p val p vec.unpack gsl-1.15.3/examples/eigen/narray.rb0000755000175000017500000000033712220252463016476 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") m = NMatrix[[1.0, 1/2.0, 1/3.0, 1/4.0], [1/2.0, 1/3.0, 1/4.0, 1/5.0], [1/3.0, 1/4.0, 1/5.0, 1/6.0], [1/4.0, 1/5.0, 1/6.0, 1/7.0]] p GSL::Eigen.symm(m) p GSL::Eigen.symmv(m) gsl-1.15.3/examples/dht.rb0000755000175000017500000000164012220252463014670 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math # Function to be expanded G = GSL::Function.alloc { |x| exp(-x*x) } #G = Function.alloc { |x| sin(-x*x) } # Sampling points XMIN = 0.0 XMAX = 3.0 SIZE = 20 x = GSL::Vector.linspace(XMIN, XMAX, SIZE) sample = G.eval(x) # Discrete Hankel transform with the Bessel function J0 dht = GSL::Dht.alloc(SIZE, 0, XMAX) g = dht.apply(sample) num = dht.num den = dht.den coef = dht.coef # Reconstruction y = GSL::Vector[SIZE] for n in 0...SIZE do val = 0.0 for m in 0...SIZE do a = GSL::Sf::bessel_J0(dht.sample(n, m)) val += (2.0/XMAX/XMAX)*a/den[m]*g[m] # val += (2.0/XMAX/XMAX)*num[n][m]/den[m]*g[m] # val += coef[n][m]*g[m] end y[n] = val end x0 = GSL::Vector.linspace(XMIN, XMAX, 100) y0 = G.eval(x0) GSL::graph([x0, y0], [x, sample], [x, y], "-T X -C -g 3 -X t -Y 'f(t)' --toggle-rotate-y-label -L 'Red: f(t), Green: sample, Blue: DHT of size #{SIZE}'") gsl-1.15.3/examples/fft/0000755000175000017500000000000012220252463014337 5ustar boutilboutilgsl-1.15.3/examples/fft/realradix2.rb0000755000175000017500000000066212220252463016730 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 128 data = GSL::Vector.alloc(n) #data = NArray.float(n) data[0] = 1.0 for i in 1..10 do data[i] = 1.0 data[n-i] = 1.0 end #ffted = data.radix2_transform(GSL::FFT:FORWARD) #ffted = data.real_radix2_transform(GSL::FFT::FORWARD) # etc... ffted = data.radix2_transform(GSL::FFT::FORWARD) ffted /= Math::sqrt(n) GSL::graph(nil, data, ffted, "-T X -C -g 3 -L 'Real Radix-2' -x 0 #{data.size}") gsl-1.15.3/examples/fft/radix2.rb0000755000175000017500000000046612220252463016066 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 128 data = GSL::Vector::Complex.alloc(n) data[0] = 1.0 c = GSL::Complex[1, 0] for i in 1..10 do data[i] = c data[n-i] = c end ffted = data.radix2_forward ffted /= Math::sqrt(n) GSL::graph(nil, data.re, ffted.re, "-T X -C -g 3 -L 'Radix-2' -x 0 #{data.size/2}") gsl-1.15.3/examples/fft/fft.rb0000755000175000017500000000063212220252463015447 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 2048 SAMPLING = 1000 # 1 kHz TMAX = 1.0/SAMPLING*N FREQ1 = 50 FREQ2 = 120 t = GSL::Vector.linspace(0, TMAX, N) x = GSL::Sf::sin(2*Math::PI*FREQ1*t) + GSL::Sf::sin(2*Math::PI*FREQ2*t) y = x.fft y2 = y.subvector(1, N-2).to_complex2 mag = y2.abs phase = y2.arg f = GSL::Vector.linspace(0, SAMPLING/2, mag.size) GSL::graph(f, mag, "-C -g 3 -x 0 200 -X 'Frequency [Hz]'") gsl-1.15.3/examples/fft/sunspot.dat0000644000175000017500000000600012220252463016540 0ustar boutilboutil1716 47.0 1717 63.0 1718 60.0 1719 39.0 1720 28.0 1721 26.0 1722 22.0 1723 11.0 1724 21.0 1725 40.0 1726 78.0 1727 122.0 1728 103.0 1729 73.0 1730 47.0 1731 35.0 1732 11.0 1733 5.0 1734 16.0 1735 34.0 1736 70.0 1737 81.0 1738 111.0 1739 101.0 1740 73.0 1741 40.0 1742 20.0 1743 16.0 1744 5.0 1745 11.0 1746 22.0 1747 40.0 1748 60.0 1749 80.9 1750 83.4 1751 47.7 1752 47.8 1753 30.7 1754 12.2 1755 9.6 1756 10.2 1757 32.4 1758 47.6 1759 54.0 1760 62.9 1761 85.9 1762 61.2 1763 45.1 1764 36.4 1765 20.9 1766 11.4 1767 37.8 1768 69.8 1769 106.1 1770 100.8 1771 81.6 1772 66.5 1773 34.8 1774 30.6 1775 7.0 1776 19.8 1777 92.5 1778 154.4 1779 125.9 1780 84.8 1781 68.1 1782 38.5 1783 22.8 1784 10.2 1785 24.1 1786 82.9 1787 132.0 1788 130.9 1789 118.1 1790 89.9 1791 66.6 1792 60.0 1793 46.9 1794 41.0 1795 21.3 1796 16.0 1797 6.4 1798 4.1 1799 6.8 1800 14.5 1801 34.0 1802 45.0 1803 43.1 1804 47.5 1805 42.2 1806 28.1 1807 10.1 1808 8.1 1809 2.5 1810 0.0 1811 1.4 1812 5.0 1813 12.2 1814 13.9 1815 35.4 1816 45.8 1817 41.1 1818 30.1 1819 23.9 1820 15.6 1821 6.6 1822 4.0 1823 1.8 1824 8.5 1825 16.6 1826 36.3 1827 49.6 1828 64.2 1829 67.0 1830 70.9 1831 47.8 1832 27.5 1833 8.5 1834 13.2 1835 56.9 1836 121.5 1837 138.3 1838 103.2 1839 85.7 1840 64.6 1841 36.7 1842 24.2 1843 10.7 1844 15.0 1845 40.1 1846 61.5 1847 98.5 1848 124.7 1849 96.3 1850 66.6 1851 64.5 1852 54.1 1853 39.0 1854 20.6 1855 6.7 1856 4.3 1857 22.7 1858 54.8 1859 93.8 1860 95.8 1861 77.2 1862 59.1 1863 44.0 1864 47.0 1865 30.5 1866 16.3 1867 7.3 1868 37.6 1869 74.0 1870 139.0 1871 111.2 1872 101.6 1873 66.2 1874 44.7 1875 17.0 1876 11.3 1877 12.4 1878 3.4 1879 6.0 1880 32.3 1881 54.3 1882 59.7 1883 63.7 1884 63.5 1885 52.2 1886 25.4 1887 13.1 1888 6.8 1889 6.3 1890 7.1 1891 35.6 1892 73.0 1893 85.1 1894 78.0 1895 64.0 1896 41.8 1897 26.2 1898 26.7 1899 12.1 1900 9.5 1901 2.7 1902 5.0 1903 24.4 1904 42.0 1905 63.5 1906 53.8 1907 62.0 1908 48.5 1909 43.9 1910 18.6 1911 5.7 1912 3.6 1913 1.4 1914 9.6 1915 47.4 1916 57.1 1917 103.9 1918 80.6 1919 63.6 1920 37.6 1921 26.1 1922 14.2 1923 5.8 1924 16.7 1925 44.3 1926 63.9 1927 69.0 1928 77.8 1929 64.9 1930 35.7 1931 21.2 1932 11.1 1933 5.7 1934 8.7 1935 36.1 1936 79.7 1937 114.4 1938 109.6 1939 88.8 1940 67.8 1941 47.5 1942 30.6 1943 16.3 1944 9.6 1945 33.2 1946 92.6 1947 151.6 1948 136.3 1949 134.7 1950 83.9 1951 69.4 1952 31.5 1953 13.9 1954 4.4 1955 38.0 1956 141.7 1957 190.2 1958 184.8 1959 159.0 1960 112.3 1961 53.9 1962 37.5 1963 27.9 1964 10.2 1965 15.1 1966 47.0 1967 93.8 1968 105.9 1969 105.5 1970 104.5 1971 66.6 gsl-1.15.3/examples/fft/fft2.rb0000755000175000017500000000062712220252463015535 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 2048 SAMPLING = 1000 # 1 kHz TMAX = 1.0/SAMPLING*N FREQ1 = 50 FREQ2 = 120 t = GSL::Vector.linspace(0, TMAX, N) x = GSL::Sf::sin(2*Math::PI*FREQ1*t) + GSL::Sf::sin(2*Math::PI*FREQ2*t) x.fft! y2 = x.subvector(1, N-2).to_complex2 mag = y2.abs phase = y2.arg f = GSL::Vector.linspace(0, SAMPLING/2, mag.size) GSL::graph(f, mag, "-C -g 3 -x 0 200 -X 'Frequency [Hz]'") gsl-1.15.3/examples/fft/sunspot.rb0000755000175000017500000000076612220252463016413 0ustar boutilboutil#!/usr/bin/env ruby # Analysis of the solar activity of 11-years cycle # from the number of sunspots. # This example is taken from the MATLAB user's manual Chap 13. require("gsl") year, sunspot = GSL::Vector.filescan("sunspot.dat") N = year.size ffted = sunspot.fft #power = GSL.sqrt(ffted[1..(N-2)].to_complex2.abs2)*2/N power = GSL.sqrt(ffted.to_complex2.abs2)*2/N freq = GSL::Vector.linspace(1, N/2, power.size)/N period = 1.0/freq GSL::graph(period, power, "-C -g 3 -x 0 40 -X 'Period [year]'") gsl-1.15.3/examples/fft/forward2.rb0000755000175000017500000000112312220252463016412 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 630 data = GSL::Vector::Complex.alloc(n) table = GSL::FFT::ComplexWavetable.alloc(n) space = GSL::FFT::ComplexWorkspace.alloc(n) data[0] = 1.0 for i in 1..10 do data[i] = GSL::Complex[1.0, 0.0] data[n-i] = GSL::Complex[1.0, 0.0] end org = data.clone # Select whichever you like #data.forward!(table, space) #data.forward!(table) #data.forward!(space) #data.forward!() #data.transform!(table, space, GSL::FFT::Forward) #data.transform!(GSL::FFT::Forward) data.forward!(table, space) data /= Math::sqrt(n) GSL::graph(nil, org.re, data.re, "-C -g 3") gsl-1.15.3/examples/fft/forward.rb0000755000175000017500000000120012220252463016324 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 630 data = GSL::Vector::Complex::alloc(n) table = GSL::FFT::ComplexWavetable.alloc(n) space = GSL::FFT::ComplexWorkspace.alloc(n) data[0] = 1.0 for i in 1..10 do data[i] = GSL::Complex[1.0, 0.0] data[n-i] = GSL::Complex[1.0, 0.0] end # Select whichever you like #ffted = data.forward(table, space) #ffted = data.forward(table) #ffted = data.forward(space) #ffted = data.forward() #ffted = data.transform(table, space, GSL::FFT::Forward) #ffted = data.transform(GSL::FFT::Forward) ffted = data.transform(GSL::FFT::Forward) ffted /= Math::sqrt(n) GSL::graph(nil, data.re, ffted.re, "-C -g 3") gsl-1.15.3/examples/fft/real-halfcomplex.rb0000755000175000017500000000136312220252463020115 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 data = GSL::Vector.alloc(n) #data = NArray.float(n) for i in (n/3)...(2*n/3) do data[i] = 1.0 end rtable = GSL::FFT::RealWavetable.alloc(n) rwork = GSL::FFT::RealWorkspace.alloc(n) #ffted = data.real_transform(rtable, rwork) #ffted = data.real_transform(rtable) #ffted = data.real_transform(rwork) #ffted = data.real_transform() #ffted = data.fft ffted = data.real_transform() for i in 11...n do ffted[i] = 0.0 end hctable = GSL::FFT::HalfComplexWavetable.alloc(n) #data2 = ffted.halfcomplex_inverse(hctable, rwork) #data2 = ffted.halfcomplex_inverse() #data2 = ffted.ifft data2 = ffted.halfcomplex_inverse() GSL::graph(nil, data, data2, "-T X -C -g 3 -L 'Real-halfcomplex' -x 0 #{data.size}") gsl-1.15.3/examples/fft/real-halfcomplex2.rb0000755000175000017500000000115312220252463020174 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 data = GSL::Vector.alloc(n) #data = NArray.float(n) for i in (n/3)...(2*n/3) do data[i] = 1.0 end org = data.clone rtable = GSL::FFT::RealWavetable.alloc(n) rwork = GSL::FFT::RealWorkspace.alloc(n) data.real_transform!(rtable, rwork) for i in 11...n do data[i] = 0.0 end hctable = GSL::FFT::HalfComplexWavetable.alloc(n) #data.halfcomplex_inverse!(hctable, rwork) #data.halfcomplex_inverse!() #data.ifft! #data.halfcomplex_inverse!(hctable, rwork) data.ifft!(hctable, rwork) GSL::graph(nil, org, data, "-T X -C -g 3 -L 'Real-halfcomplex' -x 0 #{data.size}") gsl-1.15.3/examples/const/0000755000175000017500000000000012220252463014706 5ustar boutilboutilgsl-1.15.3/examples/const/travel.rb0000755000175000017500000000202412220252463016531 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::CONST::MKSA puts("In MKSA unit") c = SPEED_OF_LIGHT; au = ASTRONOMICAL_UNIT; minutes = MINUTE; # distance stored in meters r_earth = 1.00 * au; r_mars = 1.52 * au; t_min = (r_mars - r_earth) / c; t_max = (r_mars + r_earth) / c; printf("light travel time from Earth to Mars:\n"); printf("c = %e [m/s]\n", c) printf("AU = %e [m]\n", au) printf("minutes = %e [s]\n", minutes) printf("minimum = %.1f minutes\n", t_min / minutes); printf("maximum = %.1f minutes\n\n", t_max / minutes); include GSL::CONST::CGSM puts("In CGSM unit") c = SPEED_OF_LIGHT; au = ASTRONOMICAL_UNIT; minutes = MINUTE; # distance stored in meters r_earth = 1.00 * au; r_mars = 1.52 * au; t_min = (r_mars - r_earth) / c; t_max = (r_mars + r_earth) / c; printf("light travel time from Earth to Mars:\n"); printf("c = %e [cm/s]\n", c) printf("AU = %e [cm]\n", au) printf("minutes = %e [s]\n", minutes) printf("minimum = %.1f minutes\n", t_min / minutes); printf("maximum = %.1f minutes\n", t_max / minutes); gsl-1.15.3/examples/const/physconst.rb0000755000175000017500000001003112220252463017263 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("curses") #SUBWIN_H = 20 SUBWIN_W = 50 SUBWIN_Y = 1 SUBWIN_X = 10 print("MKSA/CGSM ? [m/c] : ") sys = gets if /^m/ =~ sys include GSL::CONST::MKSA PREFIX = "MKSA" else include GSL::CONST::CGSM PREFIX = "CGSM" end include GSL::CONST::NUM Curses.init_screen W = Curses.stdscr Curses.refresh MAIN_MENU = ["", "Fundamental Constants", "Astronomy and Astrophysics", "Atomic and Nuclear Physics", "Measurement of Time", "Imperial Units", "Nautical Units", "Printers Units", "Volume", "Mass and Weight", "Thermal Energy and Power", "Pressure", "Viscosity", "Light and Illumination", "Radioactivity", "Force and Energy", "Prefixes"] MENU = Array.new(MAIN_MENU.size) MENU[1] = ["", "SPEED_OF_LIGHT", "VACUUM_PERMEABILITY", "VACUUM_PERMITTIVITY", "PLANCKS_CONSTANT_H", "PLANCKS_CONSTANT_HBAR", "AVOGADRO", "FARADAY", "BOLTZMANN", "MOLAR_GAS", "STANDARD_GAS_VOLUME", "STEFAN_BOLTZMANN_CONSTANT", "GAUSS", "MICRON", "HECTARE", "MILES_PER_HOUR", "KILOMETERS_PER_HOUR"] MENU[2] = ["", "ASTRONOMICAL_UNIT", "GRAVITATIONAL_CONSTANT", "LIGHT_YEAR", "PARSEC", "GRAV_ACCEL", "SOLAR_MASS"] MENU[3] = ["", "ELECTRON_CHARGE", "ELECTRON_VOLT", "UNIFIED_ATOMIC_MASS", "MASS_ELECTRON", "MASS_MUON", "MASS_PROTON", "MASS_NEUTRON", "FINE_STRUCTURE", "RYDBERG", "BOHR_RADIUS", "ANGSTROM", "BARN", "BOHR_MAGNETON", "NUCLEAR_MAGNETON", "ELECTRON_MAGNETIC_MOMENT", "PROTON_MAGNETIC_MOMENT", "THOMSON_CROSS_SECTION"] MENU[4] = ["", "MINUTE", "HOUR", "DAY", "WEEK"] MENU[5] = ["", "INCH", "FOOT", "YARD", "MILE", "MIL"] MENU[6] = ["", "NAUTICAL_MILE", "FATHOM", "KNOT"] MENU[7] = ["", "POINT", "TEXPOINT"] MENU[8] = ["", "ACRE", "LITER", "US_GALLON", "CANADIAN_GALLON", "UK_GALLON", "QUART", "PINT"] MENU[9] = ["", "POUND_MASS", "OUNCE_MASS", "TON", "METRIC_TON", "UK_TON", "TROY_OUNCE", "CARAT", "GRAM_FORCE", "POUND_FORCE", "KILOPOUND_FORCE", "POUNDAL"] MENU[10] = ["", "CALORIE", "BTU", "THERM", "HORSEPOWER"] MENU[11] = ["", "BAR", "STD_ATMOSPHERE", "TORR", "METER_OF_MERCURY", "INCH_OF_MERCURY", "INCH_OF_WATER", "PSI"] MENU[12] = ["", "POISE", "STOKES"] MENU[13] = ["", "STILB", "LUMEN", "LUX", "PHOT", "FOOTCANDLE", "LAMBERT", "FOOTLAMBERT"] MENU[14] = ["", "CURIE", "ROENTGEN", "RAD"] MENU[15] = ["", "NEWTON", "DYNE", "JOULE", "ERG"] MENU[16] = ["", "YOTTA", "ZETTA", "EXA", "PETA", "TERA", "GIGA", "MEGA", "KILO", "MILLI", "MICRO", "NANO", "PICO", "FEMTO", "ATTO", "ZEPTO", "YOCTO"] def mainmenu i = 1 Curses.clear W.setpos(0, 1) W.addstr(" GSL-#{GSL::VERSION} Physical Constants:\n") MAIN_MENU[1..-1].each do |str| W.setpos(i, 1) W.addstr(sprintf(" [%2d] %s\n", i, str)) i+=1 end W.setpos(i, 1) str = " ? ['q' to quit]: " W.addstr(str) W.setpos(i, str.size+1) W.refresh end def show_submenu(ind, w) w.setpos(1, 0) w.addstr(sprintf(" [%2d] %s\n", ind, MAIN_MENU[ind])) i = 1 MENU[ind][1..-1].each do |str| w.setpos(i+1, 1) w.addstr(sprintf(" [%2d] %s\n", i, str)) i+=1 end w.setpos(i+=1, 1) str = " ? ['m' to menu]: " w.addstr(str) w.setpos(i, str.size+1) w.box('|', '-') w.refresh end def show_result(ind, i, w) return if i == 0 return if i > MENU[ind].size-1 w.setpos(MENU[ind].size+2, 0) w.addstr(" #{MENU[ind][i]} = ") begin val = eval("#{MENU[ind][i]}") w.addstr("#{val}\n") rescue NameError w.addstr("not defined.\n") rescue return ensure w.refresh end end def submenu(ind) return unless MENU[ind] w = W.subwin(MENU[ind].size+4, SUBWIN_W, SUBWIN_Y, SUBWIN_X) while true show_submenu(ind, w) i = w.getstr if /^m/ =~ i w.close return end show_result(ind, i.to_i, w) end end ######### while true mainmenu i = W.getstr W.refresh break if /^q/ =~ i i = i.to_i next if i > MAIN_MENU.size or i < 1 submenu(i) end Curses.close_screen exit __END__ gsl-1.15.3/examples/fit/0000755000175000017500000000000012220252463014342 5ustar boutilboutilgsl-1.15.3/examples/fit/expfit.rb0000755000175000017500000000127312220252463016174 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 40 amp0 = 5.0 b0 = 0.1 y0 = 1.0 r = GSL::Rng.alloc() x = GSL::Vector[0...N] sigma = GSL::Vector[N] sigma.set_all(0.1) y = y0 + amp0*GSL::Sf::exp(-b0*x) + 0.1*r.gaussian(1, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, sigma, y, "exponential") y0 = coef[0] amp = coef[1] b = coef[2] p coef p err GSL::graph(x, y, y0+amp*GSL::Sf::exp(-b*x)) # This will result in # [ 1.019e+00 5.045e+00 1.040e-01 ] # [ 3.385e-02 5.395e-02 2.826e-03 ] # GNUPLOT results: # y0 = 1.01925 +/- 0.03383 (3.319%) # A = 5.04536 +/- 0.05396 (1.069%) # b = 0.104049 +/- 0.002826 (2.716%) gsl-1.15.3/examples/fit/hillfit.rb0000755000175000017500000000165412220252463016333 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::MultiFit N = 100 y0 = 1 m = 2.0 xhalf = 5 rr = 4 r = GSL::Rng.alloc() x = GSL::Vector.linspace(0.001, 10, N) y = y0 + (m-y0)/(1.0 + GSL::pow(xhalf/x, rr)) + 0.02*r.gaussian(1, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "hill") y0 = coef[0] m = coef[1] xhalf = coef[2] rr = coef[3] p coef p err GSL::graph(x, y, y0+(m-y0)/(1+GSL::pow(xhalf/x, rr))) =begin Result: GSL::Vector [ 9.959e-01 1.995e+00 4.936e+00 4.035e+00 ] GSL::Vector [ 4.676e-03 1.035e-02 3.779e-02 1.125e-01 ] GNUPLOT result: Final set of parameters Asymptotic Standard Error ======================= ========================== y0 = 0.995858 +/- 0.004676 (0.4695%) m = 1.99465 +/- 0.01034 (0.5184%) xhalf = 4.93605 +/- 0.0378 (0.7658%) r = 4.0346 +/- 0.1124 (2.787%) =end gsl-1.15.3/examples/fit/expdata.dat0000644000175000017500000000043612220252463016465 0ustar boutilboutil0 6.02678 0.2 1 5.50657 0.2 2 5.42854 0.2 3 4.85082 0.2 4 4.55111 0.2 5 3.77715 0.2 6 3.26472 0.2 7 3.34707 0.2 8 3.23883 0.2 9 3.21156 0.2 10 2.83587 0.2 11 2.40504 0.2 12 2.37237 0.2 13 2.399 0.2 14 2.39919 0.2 15 2.006 0.2 16 1.88188 0.2 17 1.91484 0.2 18 1.69252 0.2 19 1.58229 0.2 gsl-1.15.3/examples/fit/sinfit.rb0000755000175000017500000000056712220252463016176 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 100 y0 = 1 A = 1.5 fc = 0.7 phi = 0.2 r = GSL::Rng.alloc() x = GSL::Vector.linspace(0, 12, N) y = y0 + A*GSL::Sf::sin(fc*x+phi) + 0.1*r.gaussian(1, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "sin") y0 = coef[0] amp = coef[1] fc = coef[2] phi = coef[3] p coef p err GSL::graph(x, y, y0+amp*GSL::Sf::sin(fc*x+phi)) gsl-1.15.3/examples/fit/plot.gp0000644000175000017500000000113612220252463015651 0ustar boutilboutil#!/usr/bin/gnuplot set terminal postscript eps enhanced color 18 set pm3d map #set palette gray set palette #set palette gamma 0.5 set xrange [0:3] set yrange [0:3] set cbrange [-4:5] set ytics border nomirror set output "ndlinear.eps" set xlabel "r" set ylabel "{/Symbol \161}" set colorbox horizontal user origin 0.1,0.05 size 1.8,0.05 set size 2.0, 1.1 set multiplot set size 1.0, 1.0 set origin 0, 0.1 set title "Exact solution" unset key splot 'ndlinear.dat' us 1:2:3 unset colorbox set size 1.0, 1.0 set origin 1, 0.1 set title "Model solution" splot 'ndlinear.dat' us 1:2:4 unset multiplot gsl-1.15.3/examples/fit/nonlinearfit.rb0000755000175000017500000000420112220252463017357 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") FFF = GSL::Function.alloc { |t, params| a = params[0]; lambda = params[1]; b = params[2] a*Math::exp(-lambda*t) + b } procf = Proc.new { |x, t, y, sigma, f| a = x[0]; lambda = x[1]; b = x[2] FFF.set_params(x) n = t.size for i in 0...n do yi = FFF.eval(t[i]) f[i] = (yi - y[i])/sigma[i] end } procdf = Proc.new { |x, t, y, sigma, jac| a = x[0]; lambda = x[1] n = t.size for i in 0...n do ti = t[i] si = sigma[i] ei = Math::exp(-lambda*ti) jac[i,0] = ei/si jac[i,1] = -ti*a*ei/si jac[i,2] = 1.0/si end } n = 20 np = 3 f = GSL::MultiFit::Function_fdf.alloc(procf, procdf, np) r = GSL::Rng.alloc() t = GSL::Vector.alloc(n) y = GSL::Vector.alloc(n) sigma = GSL::Vector.alloc(n) File.open("expdata.dat", "w") do |fp| for i in 0...n do t[i] = i y[i] = 1.0 + 5*Math::exp(-0.1*t[i]) + r.gaussian(0.2) sigma[i] = 0.2 fp.printf("%d %g %g\n", t[i], y[i], sigma[i]) # fp.printf("%d %g\n", t[i], y[i]) end end f.set_data(t, y, sigma) x = GSL::Vector.alloc([1.0, 0.0, 0.0]) solver = GSL::MultiFit::FdfSolver.alloc(GSL::MultiFit::FdfSolver::LMSDER, n, np) #solver = GSL::MultiFit::FdfSolver.alloc(GSL::MultiFit::FdfSolver::LMDER, n, np) solver.set(f, x) iter = 0 solver.print_state(iter) begin iter += 1 status = solver.iterate solver.print_state(iter) status = solver.test_delta(1e-4, 1e-4) end while status == GSL::CONTINUE and iter < 500 covar = solver.covar(0.0) position = solver.position chi2 = GSL::pow_2(solver.f.dnrm2) dof = n - np printf("A = %.5f +/- %.5f\n", position[0], Math::sqrt(chi2/dof*covar[0,0])) printf("lambda = %.5f +/- %.5f\n", position[1], Math::sqrt(chi2/dof*covar[1,1])) printf("b = %.5f +/- %.5f\n", position[2], Math::sqrt(chi2/dof*covar[2,2])) str = sprintf("%4.3f*exp(-%4.3f*x)+%4.3f", position[0], position[1], position[2]) FFF.set_params(position) x = 0 File.open("fit.dat", "w") do |f| while x < 40 f.printf("%e %e\n", x, FFF.eval(x)) x += 0.1 end end system("graph -T X -C -g 3 -L '#{str}' -X x -I e -m -1 -S 4 expdata.dat -I a -m 2 -S 0 fit.dat") #File.delete("expdata.dat") #File.delete("fit.dat") gsl-1.15.3/examples/fit/ndlinear.rb0000755000175000017500000000503012220252463016464 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") unless GSL::MultiFit.const_defined?("Ndlinear") puts("The extension library NDLINEAR is not installed.") exit() end N_DIM = 3 N_SUM_R = 10 N_SUM_THETA = 11 N_SUM_PHI = 9 R_MAX = 3.0 def psi_real_exact(k, l, m, r, theta, phi) rr = GSL::pow(r, l)*Math::exp(-r*r)*GSL::Sf::laguerre_n(k, l + 0.5, 2 * r * r) tt = GSL::Sf::legendre_sphPlm(l, m, Math::cos(theta)) pp = Math::cos(m*phi) rr*tt*pp end basis_r = Proc.new { |r, y, params| params.eval(r, y) } basis_theta = Proc.new { |theta, y, params| for i in 0...N_SUM_THETA do y[i] = GSL::Sf::legendre_Pl(i, Math::cos(theta)); end } basis_phi = Proc.new { |phi, y, params| for i in 0...N_SUM_PHI do if i%2 == 0 y[i] = Math::cos(i*0.5*phi) else y[i] = Math::sin((i+1.0)*0.5*phi) end end } GSL::Rng::env_setup() k = 5 l = 4 m = 2 NDATA = 3000 N = [N_SUM_R, N_SUM_THETA, N_SUM_PHI] u = [basis_r, basis_theta, basis_phi] rng = GSL::Rng.alloc() bspline = GSL::BSpline.alloc(4, N_SUM_R - 2) bspline.knots_uniform(0.0, R_MAX) ndlinear = GSL::MultiFit::Ndlinear.alloc(N_DIM, N, u, bspline) multifit = GSL::MultiFit.alloc(NDATA, ndlinear.n_coeffs) vars = GSL::Matrix.alloc(NDATA, N_DIM) data = GSL::Vector.alloc(NDATA) for i in 0...NDATA do r = rng.uniform()*R_MAX theta = rng.uniform()*Math::PI phi = rng.uniform()*2*Math::PI psi = psi_real_exact(k, l, m, r, theta, phi) dpsi = rng.gaussian(0.05*psi) vars[i,0] = r vars[i,1] = theta vars[i,2] = phi data[i] = psi + dpsi end #GSL::MultiFit::Ndlinear::design(vars, X, ndlinear) X = GSL::MultiFit::Ndlinear::design(vars, ndlinear) coeffs, cov, chisq, = GSL::MultiFit::linear(X, data, multifit) rsq = GSL::MultiFit::linear_Rsq(data, chisq) STDERR.printf("chisq = %e, Rsq = %f\n", chisq, rsq) eps_rms = 0.0 volume = 0.0 dr = 0.05; dtheta = 5.0 * Math::PI / 180.0 dphi = 5.0 * Math::PI / 180.0 x = GSL::Vector.alloc(N_DIM) r = 0.01 while r < R_MAX do theta = 0.0 while theta < Math::PI do phi = 0.0 while phi < 2*Math::PI do dV = r*r*Math::sin(theta)*dr*dtheta*dphi x[0] = r x[1] = theta x[2] = phi psi_model, err = GSL::MultiFit::Ndlinear.calc(x, coeffs, cov, ndlinear) psi = psi_real_exact(k, l, m, r, theta, phi) err = psi_model - psi eps_rms += err * err * dV; volume += dV; if phi == 0.0 printf("%e %e %e %e\n", r, theta, psi, psi_model) end phi += dphi end theta += dtheta end printf("\n"); r += dr end eps_rms /= volume eps_rms = Math::sqrt(eps_rms) STDERR.printf("rms error over all parameter space = %e\n", eps_rms) gsl-1.15.3/examples/fit/lognormal.rb0000755000175000017500000000072612220252463016671 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 100 y0 = 1.0 A = 2.0 x0 = 3.0 w = 0.5 r = GSL::Rng.alloc() x = GSL::Vector.linspace(0.01, 10, N) sig = 1 y = y0 + A*GSL::Sf::exp(-GSL::pow_2(GSL::Sf::log(x/x0)/w)) + 0.1*GSL::Ran::gaussian(r, sig, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "lognormal", [0, 3, 2, 1]) y0 = coef[0] amp = coef[1] x0 = coef[2] w = coef[3] p coef p err GSL::graph(x, y, y0+amp*GSL::Sf::exp(-GSL::pow_2(GSL::Sf::log(x/x0)/w))) gsl-1.15.3/examples/fit/lorentzfit.rb0000755000175000017500000000060612220252463017074 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 100 y0 = 1.0 A = 2.0 x0 = 3.0 B = 4.0 r = GSL::Rng.alloc() x = GSL::Vector.linspace(-10, 20, N) y = y0 + A/(GSL::pow_2(x-x0)+B) + 0.03*GSL::Ran::gaussian(r, 1, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "lorentzian") y0 = coef[0] amp = coef[1] x0 = coef[2] b = coef[3] p coef p err GSL::graph(x, y, y0+amp/(GSL::pow_2(x-x0)+b)) gsl-1.15.3/examples/fit/sigmoidfit.rb0000755000175000017500000000161412220252463017032 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 100 y0 = 0.5 m = 1.0 x0 = 1 rr = 0.2 r = GSL::Rng.alloc() x = GSL::Vector.linspace(0, 2, N) y = y0 + m/(1.0 + GSL::Sf::exp((x0-x)/rr)) + 0.02*r.gaussian(1, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "sigmoid") y0 = coef[0] m = coef[1] x0 = coef[2] rr = coef[3] p coef p err GSL::graph(x, y, y0+m/(1+GSL::Sf::exp((x0-x)/rr))) =begin Result: GSL::Vector [ 4.954e-01 1.004e+00 9.916e-01 1.991e-01 ] GSL::Vector [ 5.653e-03 9.100e-03 5.033e-03 4.856e-03 ] GNUPLOT result: Final set of parameters Asymptotic Standard Error ======================= ========================== y0 = 0.495446 +/- 0.005656 (1.142%) m = 1.00422 +/- 0.009105 (0.9067%) x0 = 0.991588 +/- 0.005033 (0.5076%) r = 0.199059 +/- 0.00486 (2.442%) =end gsl-1.15.3/examples/fit/gaussfit.rb0000755000175000017500000000147612220252463016527 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") # Create data r = GSL::Rng.alloc("knuthran") sigma = 1.5 x0 = 1.0 amp = 2.0 y0 = 3.0 N = 100 x = GSL::Vector.linspace(-4, 6, N) y = y0 + amp*GSL::Ran::gaussian_pdf(x - x0, sigma) + 0.02*GSL::Ran::gaussian(r, 1.0, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "gaussian") sigma2 = Math::sqrt(coef[3]) x02 = coef[2] amp2 = coef[1]*Math::sqrt(2*Math::PI)*sigma y02 = coef[0] y2 = y02 + amp2*GSL::Ran::gaussian_pdf(x - x02, sigma2) GSL::graph(x, y, y2, "-C -g 3 -x -4 6") printf("Expect:\n") printf("sigma = #{sigma}, x0 = #{x0}, amp = #{amp}, y0 = #{y0}\n") printf("Result:\n") printf("sigma = %5.4e +/- %5.4e\n", sigma2, err[3]) printf(" x0 = %5.4e +/- %5.4e\n", x02, err[2]) printf(" amp = %5.4e +/- %5.4e\n", amp2, err[1]) printf(" y0 = %5.4e +/- %5.4e\n", y02, err[0]) gsl-1.15.3/examples/fit/powerfit.rb0000755000175000017500000000056012220252463016532 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 100 y0 = 0.1 A = 2 rr = -1.5 r = GSL::Rng.alloc() x = GSL::Vector.linspace(0.1, 1, N) y = y0 + A*GSL::pow(x, rr) + 0.1*r.gaussian(1, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "power") y0 = coef[0] amp = coef[1] rr = coef[2] p coef p err GSL::graph(x, y, y0+amp*GSL::pow(x, rr), "-T X -C -g 3 -l x -l y") gsl-1.15.3/examples/fit/gaussian_2peaks.rb0000755000175000017500000000141512220252463017752 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") # Create data r = GSL::Rng.alloc("knuthran") amp1 = 5.0 x01 = 1.0 sigma1 = 1.5 amp2 = 2.0 x02 = 5.0 sigma2 = 0.5 y0 = 2.0 N = 300 x = GSL::Vector.linspace(-4, 9, N) y = y0 + amp1*GSL::Ran::gaussian_pdf(x - x01, sigma1) + amp2*GSL::Ran::gaussian_pdf(x - x02, sigma2) + 0.05*GSL::Ran::gaussian(r, 1.0, N) coef, err, chi2, dof = GSL::MultiFit::FdfSolver.fit(x, y, "gaussian_2peak", [2, 4, 0.9, 1, 1, 4, 1]) p coef y01 = coef[0] amp1 = coef[1]*Math::sqrt(2*Math::PI)*sigma1 x01 = coef[2] sigma1 = Math::sqrt(coef[3]) amp2 = coef[4]*Math::sqrt(2*Math::PI)*sigma2 x02 = coef[5] sigma2 = Math::sqrt(coef[6]) y2 = y01 + amp1*GSL::Ran::gaussian_pdf(x - x01, sigma1) + amp2*GSL::Ran::gaussian_pdf(x - x02, sigma2) GSL::graph(x, y, y2, "-C -g 3") gsl-1.15.3/examples/fit/multifit.rb0000755000175000017500000000277012220252463016535 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") GSL::Rng.env_setup() r = GSL::Rng.alloc(GSL::Rng::DEFAULT) n = 19 dim = 3 X = GSL::Matrix.alloc(n, dim) y = GSL::Vector.alloc(n) w = GSL::Vector.alloc(n) file0 = "data.dat" file1 = "fit.dat" a = 0.1 File.open(file0, "w") do |f| for i in 0...n y0 = Math::exp(a) sigma = 0.1*y0 val = r.gaussian(sigma) X[i,0] = 1.0 X[i,1] = a X[i,2] = a*a y[i] = y0 + val w[i] = 1.0/(sigma*sigma) f.printf("%g %g %g\n", a, y[i], sigma) a += 0.1 end end c, cov, chisq, status = GSL::MultiFit.wlinear(X, w, y) printf("# best fit: Y = %g + %g X + %g X^2\n", c[0], c[1], c[2]) printf("# covariance matrix:\n") printf("[ %+.5e, %+.5e, %+.5e\n", cov[0,0], cov[0,1], cov[0,2]) printf(" %+.5e, %+.5e, %+.5e\n", cov[1,0], cov[1,1], cov[1,2]) printf(" %+.5e, %+.5e, %+.5e ]\n", cov[2,0], cov[2,1], cov[2,2]) printf("# chisq = %g\n", chisq) str = sprintf("%4.3f", c[0]) if c[1] > 0.0 str += sprintf("+ %4.3f*x", c[1].abs) else str += sprintf("- %4.3f*x", c[1].abs) end if c[2] > 0.0 str += sprintf("+ %4.3f*x*x", c[2].abs) else str += sprintf("- %4.3f*x*x", c[2].abs) end func = GSL::Function.alloc { |x, params| c0 = params[0]; c1 = params[1]; c2 = params[2] c0 + x*(c1 + x*c2) } func.set_params(c) File.open(file1, "w") do |f| x = 0 while x < 2 f.printf("%e %e\n", x, func.eval(x)) x += 0.01 end end system("graph -T X -C -g 3 -y 0 7 -L '#{str}' -I e -m -1 -S 4 data.dat -I a -m 2 -S 0 fit.dat") File.delete(file0) File.delete(file1) gsl-1.15.3/examples/fit/polyfit.rb0000755000175000017500000000045612220252463016365 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector[0.0, 0.3, 0.8, 1.1, 1.6, 2.3] y = GSL::Vector[0.5, 0.82, 1.14, 1.25, 1.35, 1.40] coef, cov, chisq, status = GSL::MultiFit.polyfit(x, y, 2) p coef x2 = GSL::Vector.linspace(0, 2.5, 20) GSL::graph([x, y], [x2, coef.eval(x2)], "-C -g 3 -S 4 -X X -Y Y") gsl-1.15.3/examples/fit/wlinear.rb0000755000175000017500000000224412220252463016335 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 4 x = GSL::Vector[1970.0, 1980, 1990, 2000] y = GSL::Vector[12.0, 11, 14, 13] w = GSL::Vector[0.1, 0.2, 0.3, 0.4] c0, c1, cov00, cov01, cov11, chisq = GSL::Fit::wlinear(x, w, y) printf("# best fit: Y = %g + %g X\n", c0, c1); printf("# covariance matrix:\n"); printf("# [ %g, %g\n# %g, %g]\n", cov00, cov01, cov01, cov11); printf("# chisq = %g\n", chisq); File.open("data.dat", "w") do |f| for i in 0...n do f.printf("%e %e %e\n", x[i], y[i], 1.0/Math::sqrt(w[i])) end end begin ffit = File.open("fit.dat", "w") fhi = File.open("hi.dat", "w") flo = File.open("lo.dat", "w") for i in -30...130 do xf = x[0] + (i/100.0) * (x[n-1] - x[0]) yf, yf_err = GSL::Fit::linear_est(xf, c0, c1, cov00, cov01, cov11) ffit.printf("%g %g\n", xf, yf) fhi.printf("%g %g\n", xf, yf + yf_err) flo.printf("%g %g\n", xf, yf - yf_err) end ensure ffit.close fhi.close flo.close end system("graph -T X -C -g 3 -X x -Y y -x 1960 2010 -y 0 20 -m 0 -S 2 -Ie data.dat -S 0 -I a -m 1 fit.dat -m 2 hi.dat -m 2 lo.dat") File.delete("data.dat") File.delete("fit.dat") File.delete("hi.dat") File.delete("lo.dat") gsl-1.15.3/examples/deriv/0000755000175000017500000000000012220252463014671 5ustar boutilboutilgsl-1.15.3/examples/deriv/diff.rb0000755000175000017500000000127712220252463016140 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") f = GSL::Function.alloc { |x| GSL::pow(x, 1.5) } printf("f(x) = x^(3/2)\n"); x = 2.0 result, abserr,status = f.diff_central(x) printf("x = 2.0\n"); printf("f'(x) = %.10f +/- %.5f\n", result, abserr); printf("exact = %.10f\n\n", 1.5 * Math::sqrt(2.0)); x = 0.0 result, abserr, status = f.diff_forward(x) printf("x = 0.0\n"); printf("f'(x) = %.10f +/- %.5f\n", result, abserr); printf("exact = %.10f\n", 0.0); f2 = GSL::Function.alloc { |x, a| Math::exp(a*x) } f2.set_params(2) p f2.diff_central(0) f2.set_params(3) p f2.diff_central(0) f2.set_params(123) p f2.diff_central(0) p GSL::Diff.central(f2, 0) p GSL::Diff.forward(f2, 0) p GSL::Diff.backward(f2, 0) gsl-1.15.3/examples/deriv/deriv.rb0000755000175000017500000000134212220252463016332 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") f = GSL::Function.alloc { |x| GSL::pow(x, 1.5) } printf("f(x) = x^(3/2)\n"); x = 2.0 h = 1e-8 result, abserr, status = f.deriv_central(x, h) printf("x = 2.0\n"); printf("f'(x) = %.10f +/- %.10f\n", result, abserr); printf("exact = %.10f\n\n", 1.5 * Math::sqrt(2.0)); x = 0.0 result, abserr, status = GSL::Deriv.forward(f, x, h) printf("x = 0.0\n"); printf("f'(x) = %.10f +/- %.10f\n", result, abserr); printf("exact = %.10f\n", 0.0); f2 = GSL::Function.alloc { |x, a| Math::exp(a*x) } f2.set_params(2) p f2.deriv_central(0) f2.set_params(3) p f2.deriv_central(0) f2.set_params(123) p f2.deriv_central(0, h) p GSL::Deriv.central(f2, 0) p GSL::Deriv.forward(f2, 0) p GSL::Deriv.backward(f2, 0) gsl-1.15.3/examples/deriv/demo.rb0000755000175000017500000000046612220252463016153 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") f = GSL::Function.alloc { |x| Math::exp(-x) } puts("f(x) = exp(-x)"); puts("Derivative: -exp(-x)") h = 1e-8 x = GSL::Vector.linspace(0, 5, 50) y = f.eval(x) dy, derr = f.deriv_central(x, h) GSL::graph(x, y, dy, "-T X -C -g 3 -X x -L 'f(x) = exp(-x), and its derivative'") gsl-1.15.3/examples/monte/0000755000175000017500000000000012220252463014702 5ustar boutilboutilgsl-1.15.3/examples/monte/plain.rb0000755000175000017500000000262612220252463016343 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Monte include Math proc_f = Proc.new { |k, dim, params| pi = Math::PI a = 1.0/(pi*pi*pi) a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2])) } def display_results(title, result, error) exact = 1.3932039296856768591842462603255 diff = result - exact printf("%s ==================\n", title); printf("result = % .6f\n", result); printf("sigma = % .6f\n", error); printf("exact = % .6f\n", exact); printf("error = % .6f = %.1g sigma\n", diff, diff.abs/error) end dim = 3 xl = Vector.alloc([0, 0, 0]) xu = Vector.alloc([PI, PI, PI]) G = Monte::Function.alloc(proc_f, dim) calls = 10000 r = GSL::Rng.alloc(Rng::DEFAULT) plain = Monte::Plain.alloc(dim) result, error = Monte::Plain::integrate(G, xl, xu, dim, calls, r, plain) #result, error = Monte::Plain::integrate(G, xl, xu, calls, r, plain) #result, error = Monte::Plain::integrate(G, xl, xu, calls, plain) #result, error = Monte::Plain::integrate(G, xl, xu, dim, calls, r, "plain") #result, error = G.integrate(xl, xu, dim, calls, r, plain) #result, error = G.integrate(xl, xu, calls, r, plain) #result, error = G.integrate(xl, xu, calls, plain) #result, error = plain.integrate(G, xl, xu, dim, calls, r) #result, error = plain.integrate(G, xl, xu, calls, r) #result, error = plain.integrate(G, xl, xu, dim, calls) #result, error = plain.integrate(G, xl, xu, calls) display_results("plain", result, error) gsl-1.15.3/examples/monte/monte.rb0000755000175000017500000000250612220252463016357 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Monte include Math proc_f = Proc.new { |k, dim, params| pi = Math::PI a = 1.0/(pi*pi*pi) a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2])) } def display_results(title, result, error) exact = 1.3932039296856768591842462603255 diff = result - exact printf("%s ==================\n", title); printf("result = % .6f\n", result); printf("sigma = % .6f\n", error); printf("exact = % .6f\n", exact); printf("error = % .6f = %.1g sigma\n", diff, diff.abs/error) end dim = 3 xl = Vector.alloc([0, 0, 0]) xu = Vector.alloc([PI, PI, PI]) G = Monte::Function.alloc(proc_f, dim) calls = 500000 r = GSL::Rng.alloc(Rng::DEFAULT) plain = Monte::Plain.alloc(dim) result, error = G.integrate(xl, xu, dim, calls, r, plain) display_results("plain", result, error) miser = Monte::Miser.alloc(dim) result, error = G.integrate(xl, xu, dim, calls, r, miser) display_results("miser", result, error) vegas = Monte::Vegas.alloc(dim) result, error = G.integrate(xl, xu, dim, 10000, r, vegas) display_results("vegas warm-up", result, error) puts("converging..."); begin result, error = G.integrate(xl, xu, dim, calls/5, r, vegas) printf("result = % .6f sigma = % .6f chisq/dof = %.1f\n", result, error, vegas.chisq) end while (vegas.chisq-1.0).abs > 0.5 display_results("vegas final", result, error) gsl-1.15.3/examples/monte/vegas.rb0000755000175000017500000000262512220252463016344 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Monte include Math proc_f = Proc.new { |k, dim, params| pi = Math::PI a = 1.0/(pi*pi*pi) a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2])) } def display_results(title, result, error) exact = 1.3932039296856768591842462603255 diff = result - exact printf("%s ==================\n", title); printf("result = % .6f\n", result); printf("sigma = % .6f\n", error); printf("exact = % .6f\n", exact); printf("error = % .6f = %.1g sigma\n", diff, diff.abs/error) end dim = 3 xl = Vector.alloc([0, 0, 0]) xu = Vector.alloc([PI, PI, PI]) G = Monte::Function.alloc(proc_f, dim) calls = 10000 r = GSL::Rng.alloc(Rng::DEFAULT) vegas = Monte::Vegas.alloc(dim) result, error = Monte::Vegas::integrate(G, xl, xu, dim, calls, r, vegas) #result, error = Monte::Vegas::integrate(G, xl, xu, calls, r, vegas) #result, error = Monte::Vegas::integrate(G, xl, xu, calls, vegas) #result, error = Monte::Vegas::integrate(G, xl, xu, dim, calls, r, "vegas") #result, error = G.integrate(xl, xu, dim, calls, r, vegas) #result, error = G.integrate(xl, xu, calls, r, vegas) #result, error = G.integrate(xl, xu, calls, vegas) #result, error = vegas.integrate(G, xl, xu, dim, calls, r) #result, error = vegas.integrate(G, xl, xu, calls, r) #result, error = vegas.integrate(G, xl, xu, dim, calls) #result, error = vegas.integrate(G, xl, xu, calls) display_results("vegas", result, error) gsl-1.15.3/examples/monte/miser.rb0000755000175000017500000000262612220252463016357 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Monte include Math proc_f = Proc.new { |k, dim, params| pi = Math::PI a = 1.0/(pi*pi*pi) a/(1.0 - cos(k[0])*cos(k[1])*cos(k[2])) } def display_results(title, result, error) exact = 1.3932039296856768591842462603255 diff = result - exact printf("%s ==================\n", title); printf("result = % .6f\n", result); printf("sigma = % .6f\n", error); printf("exact = % .6f\n", exact); printf("error = % .6f = %.1g sigma\n", diff, diff.abs/error) end dim = 3 xl = Vector.alloc([0, 0, 0]) xu = Vector.alloc([PI, PI, PI]) G = Monte::Function.alloc(proc_f, dim) calls = 10000 r = GSL::Rng.alloc(Rng::DEFAULT) miser = Monte::Miser.alloc(dim) result, error = Monte::Miser::integrate(G, xl, xu, dim, calls, r, miser) #result, error = Monte::Miser::integrate(G, xl, xu, calls, r, miser) #result, error = Monte::Miser::integrate(G, xl, xu, calls, miser) #result, error = Monte::Miser::integrate(G, xl, xu, dim, calls, r, "miser") #result, error = G.integrate(xl, xu, dim, calls, r, miser) #result, error = G.integrate(xl, xu, calls, r, miser) #result, error = G.integrate(xl, xu, calls, miser) #result, error = miser.integrate(G, xl, xu, dim, calls, r) #result, error = miser.integrate(G, xl, xu, calls, r) #result, error = miser.integrate(G, xl, xu, dim, calls) #result, error = miser.integrate(G, xl, xu, calls) display_results("miser", result, error) gsl-1.15.3/examples/tamu_anova.rb0000755000175000017500000000114312220252463016241 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") data = GSL::Vector[88.60,73.20,91.40,68.00,75.20,63.00,53.90,69.20, 50.10,71.50,44.90,59.50,40.20,56.30,38.70,31.00, 39.60,45.30,25.20,22.70] factor = GSL::Vector::Int[1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4] table = GSL::TAMU_ANOVA::Table.oneway(data, factor, 4) table.print data = GSL::Vector[45.50,45.30,45.40,44.40,44.60,43.90,44.60,44.00,44.20, 43.90,44.70,44.20,44.00,43.80,44.60,43.10,46.00,45.90, 44.80,46.20,45.10,45.50] factor = GSL::Vector::Int[1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3] table = GSL::TAMU_ANOVA::Table.oneway(data, factor, 3) table.print gsl-1.15.3/examples/roots/0000755000175000017500000000000012220252463014726 5ustar boutilboutilgsl-1.15.3/examples/roots/newton.rb0000755000175000017500000000153312220252463016572 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math f = Proc.new { |x, params| a = params[0] b = params[1] c = params[2] (a*x + b)*x + c } df = Proc.new { |x, params| a = params[0] b = params[1] 2.0*a*x + b } expected = sqrt(5.0) x = 5.0 function_fdf = GSL::Function_fdf.alloc(f, df) function_fdf.set_params([1.0, 0, -5]) solver = GSL::Root::FdfSolver.alloc(GSL::Root::FdfSolver::NEWTON) puts "using #{solver.name} method" solver.set(function_fdf, x) printf("%-5s %10s %10s %10s\n", "iter", "root", "err", "err(est)") iter = 0 status = nil while status != GSL::SUCCESS iter += 1 status = solver.iterate x0 = x x = solver.root status = GSL::Root::test_delta(x, x0, 0, 1e-3) if status == GSL::SUCCESS printf("Converged:\n") end printf("%5d %10.7f %+10.7f %10.7f\n", iter, x, x - expected, x - x0) end gsl-1.15.3/examples/roots/recombination.rb0000755000175000017500000000310612220252463020107 0ustar boutilboutil#!/usr/bin/env ruby # This solves the Saha's equation, to investigate # 'recombination' of hot cosmic plasma. require("gsl") include GSL include GSL::CONST::CGSM include Math KB = BOLTZMANN HBAR = PLANCKS_CONSTANT_HBAR class Recombination def initialize(t0, bdensity, eion) @t = 2500 @tCMB = t0 # Present temperature of CMB [K] @n0 = bdensity/MASS_PROTON # Barion number density [cm-3] @eion = eion*ELECTRON_VOLT # Hydrogen ionization potential [eV] @saha_equation = Function.alloc { |x| # x: fractional ionization n = @n0*pow_3(@t/@tCMB) tmp1 = pow(MASS_ELECTRON*KB*@t/2.0/PI/HBAR/HBAR, 1.5) tmp2 = exp(-@eion/KB/@t) x*x - (1.0 - x)*tmp1*tmp2/n } end def zplus1() @t/@tCMB end attr_accessor :t attr_reader :saha_equation end ########################### ## Cosmological parameter TCMB = 2.725 # Temperature of cosmic microwave background at present [K] BDENSITY = 1e-29 # Barion density [g cm-3] EIONIZE = 13.6 # Hydrogen ionization potential [eV] unv = Recombination.new(TCMB, BDENSITY, EIONIZE) # FSolver solver = Root::FSolver.alloc(Root::FSolver::BRENT) TMIN = 2500 TMAX = 6500 begin file = File.open("recombination.dat", "w") t = TMIN while t < TMAX unv.t = t # Temperature x, iter, status = solver.solve(unv.saha_equation, [1e-8, 1.0], [0, 1e-4]) file.printf("%e %e %e\n", unv.t, unv.zplus1, x) t *= 1.01 end ensure file.close end system("gnuplot -persist recombination.gp") File.delete("recombination.dat") #puts("Try \"gnuplot -persist recombination.gp\"") gsl-1.15.3/examples/roots/bisection.rb0000755000175000017500000000140012220252463017230 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BISECTION) puts "Using #{solver.name} method" f = GSL::Function.alloc { |x, params| a = params[0]; b = params[1]; c = params[2] (a*x + b)*x + c } f.set_params(1, 0, -5) expected = Math::sqrt(5.0) printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "root", "err", "err(est)") solver.set(f, 0.0, 5.0) iter = 0 status = nil while status != GSL::SUCCESS iter += 1 status = solver.iterate r = solver.root; xl = solver.x_lower; xu = solver.x_upper status = solver.test_interval(0, 0.001) if status == GSL::SUCCESS; printf("Converged:\n"); end printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", iter, xl, xu, r, r - expected, xu - xl) end gsl-1.15.3/examples/roots/recombination.gp0000644000175000017500000000046312220252463020112 0ustar boutilboutilset logscale y set xtics nomirror set yrange [1e-5:1e1] set xrange [2100:900] set x2range [2100*2.725:900*2.725] set x2tics set xlabel '1 + z (Redshift)' set ylabel 'Fractional ionization' set x2label 'Temperature of the Universe [K]' set grid plot 'recombination.dat' u 2:3 title '' w l lw 3, 1 title '' gsl-1.15.3/examples/roots/brent.rb0000755000175000017500000000170712220252463016375 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math #solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BISECTION) #solver = GSL::Root::FSolver.alloc("falsepos") #solver = GSL::Root::FSolver.alloc("brent") solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BRENT) puts "using #{solver.name} method" f = GSL::Function.alloc { |x, params| a = params[0] b = params[1] c = params[2] (a*x + b)*x + c } f.set_params(1, 0, -5) expected = sqrt(5.0) printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "root", "err", "err(est)") solver.set(f, 0.0, 5.0) iter = 0 status = nil while status != GSL::SUCCESS iter += 1 status = solver.iterate r = solver.root xl = solver.x_lower xu = solver.x_upper status = solver.test_interval(0, 0.001) if status == GSL::SUCCESS printf("Converged:\n") end printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", iter, xl, xu, r, r - expected, xu - xl) end p f.fsolve(0, 5) gsl-1.15.3/examples/roots/demo.rb0000755000175000017500000000167612220252463016214 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") solver = GSL::Root::FSolver.alloc(GSL::Root::FSolver::BISECTION) f = GSL::Function.alloc { |x, params| a = params[0]; b = params[1]; c = params[2] (a*x + b)*x + c } f.set_params(1, 0, -5) expected = Math::sqrt(5.0) printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "root", "err", "err(est)") solver.set(f, 0.0, 5.0) iter = 0; status = nil IO.popen("graph -T X -C -g 3 -X Iterations -Y 'Root'\ --toggle-rotate-y-label\ -L 'x^2 - 5 = 0, #{solver.name}' -I e -S 4", "w") do |io| while status != GSL::SUCCESS iter += 1 status = solver.iterate r = solver.root xl = solver.x_lower; xu = solver.x_upper status = solver.test_interval(0, 0.001) if status == GSL::SUCCESS; printf("Converged:\n"); end printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", iter, xl, xu, r, r - expected, xu - xl) io.printf("%d %e %e\n", iter, r, (xu-xl)/2) end end gsl-1.15.3/examples/roots/steffenson.rb0000755000175000017500000000143112220252463017427 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math def f_to_solve(x) x*x - 5.0 end def df_to_solve(x) 2*x end f = Proc.new { |x| f_to_solve(x) } df = Proc.new { |x| df_to_solve(x) } expected = sqrt(5.0) x = 5.0 function_fdf = GSL::Function_fdf.alloc(f, df) solver = GSL::Root::FdfSolver.alloc(GSL::Root::FdfSolver::STEFFENSON) puts "using #{solver.name} method" solver.set(function_fdf, x) printf("%-5s %10s %10s %10s\n", "iter", "root", "err", "err(est)") iter = 0 status = nil while status != GSL::SUCCESS iter += 1 status = solver.iterate x0 = x x = solver.root status = GSL::Root::test_delta(x, x0, 0, 1e-3) if status == GSL::SUCCESS printf("Converged:\n") end printf("%5d %10.7f %+10.7f %10.7f\n", iter, x, x - expected, x - x0) end gsl-1.15.3/examples/ntuple/0000755000175000017500000000000012220252463015067 5ustar boutilboutilgsl-1.15.3/examples/ntuple/create.rb0000755000175000017500000000044112220252463016661 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") v = GSL::Vector.alloc(3) n = GSL::Ntuple.alloc("test.dat", v) GSL::Rng.env_setup() r = GSL::Rng.alloc for i in 0...10000 do for j in 0...3 do v[j] = r.gaussian() end n.write end puts("Data file test.dat is created.") puts("Try project.rb.") gsl-1.15.3/examples/ntuple/project.rb0000755000175000017500000000116012220252463017063 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") sel_func = GSL::Ntuple::SelectFn.alloc { |data, params| x = data[0]; y = data[1]; z = data[2] scale = params e2 = x*x + y*y + z*z e2 > scale } lower = 1.5 sel_func.set_params(lower) val_func = GSL::Ntuple::ValueFn.alloc { |data| x = data[0]; y = data[1]; z = data[2] x*x + y*y + z*z } v = GSL::Vector.alloc(3) n = GSL::Ntuple.open("test.dat", v) h = GSL::Histogram.alloc(100) h.set_ranges_uniform(0, 10.0) #Ntuple.project(h, n, val_func, sel_func) n.project(h, val_func, sel_func) h.graph("-C -X 'E2' -Y 'n' -L 'GSL::Ntuple, Select E2 > 1.5'") File.delete("test.dat") gsl-1.15.3/examples/linalg/0000755000175000017500000000000012220252463015026 5ustar boutilboutilgsl-1.15.3/examples/linalg/SV.rb0000755000175000017500000000042212220252463015704 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") A = GSL::Matrix[[3, 5, 2], [6, 2, 1], [4, 7, 3]] p A u, v, s = A.SV_decomp p u.class p v.class p s.class # u and v are orthonormal p u*u.trans p v*v.trans # Reconstruct the matrix A from u, v, and s. p u*GSL::Matrix.diagonal(s)*v.trans gsl-1.15.3/examples/linalg/chol_narray.rb0000755000175000017500000000035612220252463017663 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Linalg m = NArray[[4.0, 2], [2, 3]] c = Cholesky.decomp(m) p c b = NArray[1.0, 2] p Cholesky.solve(c, b) # Expected [-0.125, 0.75] b = NArray[1.0, 2] Cholesky.svx(c, b) p b gsl-1.15.3/examples/linalg/SV_narray.rb0000755000175000017500000000041212220252463017257 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = NMatrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] u, v, s = Linalg::SV.decomp(m) b = NArray[1.0, 2, 3, 4] p Linalg::SV.solve(u, v, s, b) gsl-1.15.3/examples/linalg/QRPT.rb0000755000175000017500000000145412220252463016150 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) qr, tau = m.QRPT_decomp p qr.class p tau.class b = Vector.alloc([1, 2, 3, 4]) qr, tau, p = m.QRPT_decomp p Linalg::QRPT.solve(qr, tau, p, b) p Linalg::QRPT.solve(m, b) p m.QRPT_solve(b) p qr.QRPT_solve(tau, p, b) p m.QRPT_solve(b) bb = b.clone p Linalg::QRPT.solve(qr, tau, p, bb) bb = b.clone p Linalg::QRPT.solve(m, bb) bb = b.clone p m.QRPT_solve(b) bb = b.clone p qr.QRPT_solve(tau, p, bb) bb = b.clone p m.QRPT_solve(bb) bb = b.clone p qr.class p qr.solve(tau, p, bb) q, r, tau, p = m.QRPT_decomp2 p q.class p r.class p Linalg::QRPT.QRsolve(q, r, p, b) bb = b.clone qr.svx(tau, p, bb) p bb bb = b.clone m.QRPT_svx(bb) p bb gsl-1.15.3/examples/linalg/chol.rb0000755000175000017500000000106112220252463016301 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Linalg m = Matrix.alloc([4, 2], [2, 3]) c = Cholesky.decomp(m) p c.class p c b = Vector[1, 2] p Cholesky.solve(c, b) # Expected [-0.125, 0.75] begin m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) c = Cholesky.decomp(m) b = [1, 2, 3, 4].to_gv p Cholesky.solve(c, b) rescue puts("Matrix must be positive definite.") end m = Matrix.pascal(6) c = m.cholesky_decomp a = c.lower p (a*a.trans) == m gsl-1.15.3/examples/linalg/invert_narray.rb0000755000175000017500000000024112220252463020236 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL na = NArray[[1.0, 4], [2, 3]] lu, perm, signum = Linalg::LU.decomp(na) inv = Linalg::LU.invert(lu, perm) p inv gsl-1.15.3/examples/linalg/QR.rb0000755000175000017500000000046112220252463015701 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] p m qr, tau = m.QR_decomp p qr.class p tau.class q, r = qr.unpack(tau) p q.class p r.class p q*r p q*q.trans # Q: orthonormal gsl-1.15.3/examples/linalg/QR_solve_narray.rb0000755000175000017500000000042412220252463020464 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = NMatrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] qr, tau = Linalg::QR.decomp(m) p qr, tau b = NVector[1.0, 2, 3, 4] p Linalg::QR.solve(qr, tau, b) gsl-1.15.3/examples/linalg/LQ_solve.rb0000755000175000017500000000235712220252463017111 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = GSL::Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) m.transpose! lq, tau = m.LQ_decomp b = Vector[1, 2, 3, 4] lq, tau = m.LQ_decomp p Linalg::LQ.solve_T(lq, tau, b) p Linalg::LQ.solve_T(m, tau, b) p Linalg::LQ.solve_T(m, b) begin p Linalg::LQ.solve_T(lq, b) # Error rescue puts("Error Linalg::LQ.solve_T(lq, b)") end x = Vector.alloc(4) p m.LQ_solve_T(b) p m.LQ_solve_T(tau, b) p lq.LQ_solve_T(tau, b) p lq.class p lq.solve_T(tau, b) m.LQ_solve_T(b, x) p x m.LQ_solve_T(tau, b, x) p x lq.LQ_solve_T(tau, b, x) p x lq.solve_T(tau, b, x) p x bb = b.clone lq.svx_T(tau, bb) p bb bb = b.clone m.LQ_svx_T(bb) p bb bb = b.clone Linalg::LQ.svx_T(m, bb) p bb bb = b.clone Linalg::LQ.svx_T(lq, tau, bb) p bb p m.LQ_lssolve_T(b) p m.LQ_lssolve_T(tau, b) p lq.LQ_lssolve_T(tau, b) p lq.lssolve_T(tau, b) p Linalg::LQ.lssolve_T(m, b) p Linalg::LQ.lssolve_T(lq, tau, b) m3 = Matrix.alloc([5, 4, 1, 1], [4, 5, 1, 1], [1, 1, 4, 2], [1, 1, 2, 4]) m3.transpose! lq, tau = m3.LQ_decomp q, l = lq.unpack(tau) q, l = Linalg::LQ.unpack(lq, tau) lq, tau = m.LQ_decomp q, l = Linalg::LQ.unpack(lq, tau) p Linalg::LQ.LQsolve_T(q, l, b) gsl-1.15.3/examples/linalg/SV_solve.rb0000755000175000017500000000157312220252463017124 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = Matrix[[-2, 1, 1], [1, -2, 1], [1, 1, -2], [-2, 1, 1]] u, v, s = m.SV_decomp p u.class p v.class p s.class m2 = Matrix[[5, 6, 8, 4], [6, 2, 4, 2], [8, 2, 3, 5], [1, 7, 2, 3]] u2, v2, s2 = m2.SV_decomp p u2 p v2 p s2 m = GSL::Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] u, v, s = Linalg::SV.decomp_jacobi(m) b = [1, 2, 3, 4].to_gv p Linalg::SV.solve(u, v, s, b) p Linalg::SV.solve(u, v, s, [1, 2, 3, 4]) puts "OK" p m.SV_solve(b) p Linalg::SV.solve(m, b) #### A = Matrix[1..4, 2, 2] I = Matrix.identity(2) Ainv = A.inv u, v, s = A.SV_decomp sm = s.to_m_diagonal sinv = s.collect { |elm| 1.0/elm }.to_m_diagonal a = u*sm*v.trans ainv = v*sinv*u.trans p a == A p ainv == Ainv p (u.trans*u) == I p (v.trans*v) == I p A*v == u*sm p A.trans*u == v*sm gsl-1.15.3/examples/linalg/QR_solve.rb0000755000175000017500000000230712220252463017112 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] qr, tau = m.QR_decomp b = Vector[1, 2, 3, 4] qr, tau = m.QR_decomp p Linalg::QR.solve(qr, tau, b) p Linalg::QR.solve(m, tau, b) p Linalg::QR.solve(m, b) begin p Linalg::QR.solve(qr, b) # Error rescue puts("Error Linalg::QR.solve(qr, b)") end x = Vector.alloc(4) p m.QR_solve(b) p m.QR_solve(tau, b) p qr.QR_solve(tau, b) p qr.class p qr.solve(tau, b) m.QR_solve(b, x) p x m.QR_solve(tau, b, x) p x qr.QR_solve(tau, b, x) p x qr.solve(tau, b, x) p x bb = b.clone qr.svx(tau, bb) p bb bb = b.clone m.QR_svx(bb) p bb bb = b.clone Linalg::QR.svx(m, bb) p bb bb = b.clone Linalg::QR.svx(qr, tau, bb) p bb p m.QR_lssolve(b) p m.QR_lssolve(tau, b) p qr.QR_lssolve(tau, b) p qr.lssolve(tau, b) p Linalg::QR.lssolve(m, b) p Linalg::QR.lssolve(qr, tau, b) m3 = Matrix.alloc([5, 4, 1, 1], [4, 5, 1, 1], [1, 1, 4, 2], [1, 1, 2, 4]) qr, tau = m3.QR_decomp p qr p tau q, r = qr.unpack(tau) p q p r p q*r q, r = Linalg::QR.unpack(qr, tau) p q p r p q*r qr, tau = m.QR_decomp q, r = Linalg::QR.unpack(qr, tau) p Linalg::QR.QRsolve(q, r, b) exit gsl-1.15.3/examples/linalg/HH_narray.rb0000755000175000017500000000037212220252463017233 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::Linalg m = NMatrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] b = NVector[1.0, 2, 3, 4] p HH.solve(m, b) p b HH.svx(m, b) p b gsl-1.15.3/examples/linalg/LU2.rb0000755000175000017500000000067212220252463015765 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Linalg m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) m.print lu, perm = m.LU_decomp b = [1, 2, 3, 4] x = Vector.alloc(4) p m.class p LU.solve(lu, perm, b) LU.solve(lu, perm, b, x) p x p LU.solve(m, b) LU.solve(m, b, x) p x LU.solve(m, perm, b, x) p x bv = b.to_gv LU.svx(m, perm, bv) p bv m.print gsl-1.15.3/examples/linalg/PTLQ.rb0000755000175000017500000000151412220252463016137 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) m.transpose! lq, tau = m.PTLQ_decomp p lq.class p tau.class b = Vector[1, 2, 3, 4] lq, tau, p = m.PTLQ_decomp p Linalg::PTLQ.solve_T(lq, tau, p, b) p Linalg::PTLQ.solve_T(m, b) p m.PTLQ_solve_T(b) p lq.PTLQ_solve_T(tau, p, b) p m.PTLQ_solve_T(b) bb = b.clone p Linalg::PTLQ.solve_T(lq, tau, p, bb) bb = b.clone p Linalg::PTLQ.solve_T(m, bb) bb = b.clone p m.PTLQ_solve_T(b) bb = b.clone p lq.PTLQ_solve_T(tau, p, bb) bb = b.clone p m.PTLQ_solve_T(bb) bb = b.clone p lq.class p lq.solve_T(tau, p, bb) q, l, tau, p = m.PTLQ_decomp2 p q.class p l.class p Linalg::PTLQ.LQsolve_T(q, l, p, b) bb = b.clone lq.svx_T(tau, p, bb) p bb bb = b.clone m.PTLQ_svx_T(bb) p bb gsl-1.15.3/examples/linalg/complex.rb0000755000175000017500000000222512220252463017026 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Linalg m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) m.inv.print p m.det #lu, perm = m.LU_decomp #LU.invert(lu, perm).print #p lu.det zm = Matrix::Complex.alloc(4, 4) zm.set_row(0, [0.18, 0], [0.60, 0], [0.57, 0], [0.96, 0]) zm.set_row(1, [0.41, 0], [0.24, 0], [0.99, 0], [0.58, 0]) zm.set_row(2, [0.14, 0], [0.30, 0], [0.97, 0], [0.66, 0]) zm.set_row(3, [0.51, 0], [0.13, 0], [0.19, 0], [0.85, 0]) p zm.inv p zm.det b = Vector::Complex.alloc(4) b.set(1.0, 2, 3, 4) #p zm.LU_solve(b) #lu2, perm2, signum = zm.LU_decomp lu2, perm2, signum = LU::decomp(zm) p lu2 p lu2.det(signum) p x = lu2.solve(perm2, b) p zm*x p lu2.LU_invert(perm2) p lu2.LU_det(signum) #p zm.LU_svx(b) p Linalg::Complex::LU_invert(zm) p Linalg::Complex::LU::invert(zm) p Linalg::Complex::LU_invert(lu2, perm2) p Linalg::Complex::LU::invert(lu2, perm2) p zm.invert p lu2.invert(perm2) p Linalg::Complex::LU_det(zm) p Linalg::Complex::LU::det(zm) p Linalg::Complex::LU_det(lu2, signum) p Linalg::Complex::LU::det(lu2, signum) p zm.det p lu2.det(signum) gsl-1.15.3/examples/linalg/LU_narray.rb0000755000175000017500000000065712220252463017262 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Linalg m = NArray[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] b = NArray[1.0, 2, 3, 4] lu, perm, signum = LU.decomp(m) p m p lu x = LU.solve(lu, perm, b) p x p b LU.svx(lu, perm, b) p b m2 = Matrix.alloc([1, 2, 3, 6, 5, 4, 7, 8, 1], 3, 3).to_nmatrix lu, perm, signum = LU.decomp(m2) p LU.det(lu, signum) gsl-1.15.3/examples/linalg/LU.rb0000755000175000017500000000223312220252463015676 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include Linalg m = Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) m.print lu, perm = m.LU_decomp m.print lu.print b = Vector[1, 2, 3, 4] x = LU.solve(lu, perm, b) x = LU.solve(lu, perm, b) p x p m p m.LU_solve(b) p m.LU_solve(perm, b) p m.LU_solve(perm, b, x) p lu.LU_solve(perm, b, x) p x LU.refine(m, lu, perm, b, x) p x #p b #m.LU_svx(b) #p b #LU.svx(lu, perm, b) #p b #p m.LU_solve(perm, b) #p m.LU_solve(perm, b, x) #p lu.LU_solve(perm, b, x) #exit LU.svx(lu, perm, b) p b p m*x.col b = [1, 2, 3, 4].to_gv p LU.solve(m, b) puts("") m2 = Matrix.alloc([1, 2, 3, 6, 5, 4, 7, 8, 1], 3, 3) m2.print lu2, p2, sign = m2.LU_decomp m3 = Matrix.alloc([1, 2, 3, 4, 5, 6, 7, 8, 0], 3, 3) m3.print lu, perm = m3.LU_decomp LU.invert(lu, perm).print p m3.class p lu.class m4 = m3.invert LU.invert(m3).print p m4.invert p m3.invert.invert.invert p m2.det p lu2.det(p2, sign) p m2.det(p2) p LU.det(m2) p LU.lndet(m2) p LU.lndet(lu2) p m2.lndet p lu2.lndet p LU.sgndet(m2) p LU.sgndet(lu2, sign) p m2.sgndet p lu2.sgndet(sign) p m p m/b.col __END__ gsl-1.15.3/examples/linalg/HH.rb0000755000175000017500000000043512220252463015657 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include GSL::Linalg m = GSL::Matrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] b = Vector.alloc(1, 2, 3, 4) p HH.solve(m, b) p m.HH_solve(b) m.HH_svx(b) p b gsl-1.15.3/examples/vector/0000755000175000017500000000000012220252463015062 5ustar boutilboutilgsl-1.15.3/examples/vector/logspace.rb0000755000175000017500000000136612220252463017215 0ustar boutilboutil#!/usr/bin/env ruby # Turn on warnings $-w = true require 'irb/xmp' require 'gsl' # Apparently, IRB::Frame has a bug that prevents the defaults from working, so # an XMP instance must be created explicitly this way instead of using the # otherwise convenient xmp method. XMP.new(IRB::Frame.top(-1)).puts <=" method x.ge(y) # Test element-wise "<" method x.lt(z) END gsl-1.15.3/examples/vector/decimate.rb0000755000175000017500000000164212220252463017170 0ustar boutilboutil#!/usr/bin/env ruby # Turn on warnings $-w = true require 'irb/xmp' require 'gsl' # Apparently, IRB::Frame has a bug that prevents the defaults from working, so # an XMP instance must be created explicitly this way instead of using the # otherwise convenient xmp method. XMP.new(IRB::Frame.top(-1)).puts < 5 } x.any? { |val| val > 2 } # Call x.all? with blocks x.all? { |val| val >= 1 } x.all? { |val| val >= 2 } # Call x.none? with blocks x.none? { |val| val == 1 } x.none? { |val| val == 5 } END gsl-1.15.3/examples/vector/gnuplot.rb0000755000175000017500000000124512220252463017104 0ustar boutilboutil#!/usr/bin/env ruby # Turn on warnings $-w = true require 'gnuplot' require 'gsl' require 'gsl/gnuplot'; # Plot using gnuplot Gnuplot.open do |gp| Gnuplot::Plot.new( gp ) do |plot| plot.xrange "[0:10]" plot.yrange "[-1.5:1.5]" plot.title "Sin Wave Example" plot.xlabel "x" plot.ylabel "sin(x)" plot.pointsize 3 plot.grid x = GSL::Vector[0..10] y = GSL::Sf::sin(x) plot.data = [ Gnuplot::DataSet.new( "sin(x)" ) { |ds| ds.with = "lines" ds.title = "String function" ds.linewidth = 4 }, Gnuplot::DataSet.new( [x, y] ) { |ds| ds.with = "linespoints" ds.title = "Array data" } ] end end gsl-1.15.3/examples/vector/vector.rb0000755000175000017500000000310312220252463016711 0ustar boutilboutil#!/usr/bin/env ruby # Turn on warnings $-w = true require 'irb/xmp' require 'gsl' # Apparently, IRB::Frame has a bug that prevents the defaults from working, so # an XMP instance must be created explicitly this way instead of using the # otherwise convenient xmp method. XMP.new(IRB::Frame.top(-1)).puts <= 2} # #where2 without a block returns ["indices of non-zero elemens", "indices of # zero elements"] z.where2 # #where2 with a block returns ["indices of elements for which block returned # true", "indices of elements for which block returned false"] z.where2 {|e| e >= 2} END gsl-1.15.3/examples/vector/collect.rb0000755000175000017500000000106312220252463017037 0ustar boutilboutil#!/usr/bin/env ruby # Turn on warnings $-w = true require 'irb/xmp' require 'gsl' # Apparently, IRB::Frame has a bug that prevents the defaults from working, so # an XMP instance must be created explicitly this way instead of using the # otherwise convenient xmp method. XMP.new(IRB::Frame.top(-1)).puts < 2) # Show mask.where with no block mask.where # Show mask.where with "true" block mask.where { true } # Show mask.where with "false" block # NB: Returns nil, not empty object! mask.where { false } # Show mask.where with no block mask.where2 # Show mask.where with "true" block mask.where2 { true } # Show mask.where with "false" block mask.where2 { false } # Show mask.where with random block mask.where2 { rand > 0.5 } END gsl-1.15.3/examples/sf/0000755000175000017500000000000012220252463014170 5ustar boutilboutilgsl-1.15.3/examples/sf/legendre_P.rb0000755000175000017500000000053612220252463016570 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(-1, 1, n) y1 = GSL::Sf::legendre_P1(x) y2 = GSL::Sf::legendre_P2(x) y3 = GSL::Sf::legendre_P3(x) y4 = GSL::Sf::legendre_Pl(4, x) y5 = GSL::Sf::legendre_Pl(5, x) GSL::Vector.graph(x, y1, y2, y3, y4, y5, "-T X -C -g 3 -X x -Y 'P(x)' --toggle-rotate-y-label -L 'Legendre P functions'") gsl-1.15.3/examples/sf/lngamma.rb0000755000175000017500000000023012220252463016127 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0.01, 14, 50) y = GSL::Sf::lngamma(x) GSL::graph(x, y, "-T X -C -g 3 -l y -L 'lngamma(x)'") gsl-1.15.3/examples/sf/transport.rb0000755000175000017500000000046612220252463016562 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(0, 2, n) y2 = GSL::Sf::transport_2(x) y3 = GSL::Sf::transport_3(x) y4 = GSL::Sf::transport_4(x) y5 = GSL::Sf::transport_5(x) GSL::Vector.graph(x, y2, y3, y4, y5, "-T X -C -g 3 -X x -Y 'J(x)' --toggle-rotate-y-label -L 'Transport functions'") gsl-1.15.3/examples/sf/dawson.rb0000755000175000017500000000021712220252463016013 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 20, 100) y = GSL::Sf::dawson(x) y.graph(x, "-T X -C -g 3 -L 'Dawson integral'") gsl-1.15.3/examples/sf/hyperg.rb0000755000175000017500000000015012220252463016012 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") p GSL::Sf.hyperg_0F1(2, 3) r = GSL::Sf.hyperg_0F1_e(2, 3) p r.val gsl-1.15.3/examples/sf/debye.rb0000755000175000017500000000040012220252463015602 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(0, 20, n) y1 = GSL::Sf::debye_1(x) y2 = GSL::Sf::debye_2(x) y3 = GSL::Sf::debye_3(x) y4 = GSL::Sf::debye_4(x) GSL::Vector.graph(x, y1, y2, y3, y4, "-T X -C -g 3 -X x -L 'Debye functions'") gsl-1.15.3/examples/sf/bessel_JY.rb0000755000175000017500000000056412220252463016404 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0.01, 20, n) J0 = GSL::Sf::bessel_J0(x) J1 = GSL::Sf::bessel_J1(x) J2 = GSL::Sf::bessel_Jn(2, x) y0 = GSL::Sf::bessel_Y0(x) y1 = GSL::Sf::bessel_Y1(x) y2 = GSL::Sf::bessel_Yn(2, x) GSL::Vector.graph(x, J0, J1, J2, y0, y1, y2, "-T X -C -g 3 -y -2 1.1 -X x -L 'Bessel functions J0, J1, J2, Y0, Y1, Y2'") gsl-1.15.3/examples/sf/lambertW.rb0000755000175000017500000000023612220252463016276 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(-0.35, 10, n) GSL::Sf::lambert_W0(x).graph(x, "-T X -C -g 3 -X x -L 'Lambert W function'") gsl-1.15.3/examples/sf/sphbessel.rb0000755000175000017500000000134212220252463016510 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::Sf l = 2 x = 0.01 File.open("sphbessel.dat", "w") do |file| while x <= 12.0 j0 = bessel_j0(x) j1 = bessel_j1(x) j2 = bessel_jl(2, x) j3 = bessel_jl(3,x) y0 = bessel_y0(x) y1 = bessel_y1(x) y2 = bessel_y2(x) i0 = bessel_i0_scaled(x) i1 = bessel_i1_scaled(x) i2 = bessel_i2_scaled(x) k0 = bessel_k0_scaled(x) k1 = bessel_k1_scaled(x) k2 = bessel_k2_scaled(x) file.printf("%e %e %e %e %e %e %e %e %e %e %e %e %e %e\n", x, j0, j1, j2, j3, y0, y1, y2, i0, i1, i2, k0, k1, k2) x += 0.1 end end #puts("sphbessel.dat created. Try sphbessel.gp.") system("gnuplot -persist sphbessel.gp") File.delete("sphbessel.dat") gsl-1.15.3/examples/sf/psi.rb0000755000175000017500000000202312220252463015310 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") IO.popen("graph -T X -C -g 3 -X x -Y 'psi(x)' --toggle-rotate-y-label -x -3 5 -y -5 15 -L 'Red: Digamma, Green: Trigamma'", "w") do |io| x = -2.999 while x < -2 y = GSL::Sf::psi(x) io.printf("%e %e\n", x, y) x += 0.01 end x = -1.999 while x < -1 y = GSL::Sf::psi(x) io.printf("%e %e\n", x, y) x += 0.01 end x = -0.999 while x < 0 y = GSL::Sf::psi(x) io.printf("%e %e\n", x, y) x += 0.01 end x = 0.001 while x < 5 y = GSL::Sf::psi(x) io.printf("%e %e\n", x, y) x += 0.1 end io.printf("\n") x = -2.999 while x < -2 y = GSL::Sf::psi_1_e(x).val io.printf("%e %e\n", x, y) x += 0.01 end x = -1.999 while x < -1 y = GSL::Sf::psi_1_e(x).val io.printf("%e %e\n", x, y) x += 0.01 end x = -0.999 while x < 0 y = GSL::Sf::psi_1_e(x).val io.printf("%e %e\n", x, y) x += 0.01 end x = 0.001 while x < 5 y = GSL::Sf::psi_1_e(x).val io.printf("%e %e\n", x, y) x += 0.1 end end gsl-1.15.3/examples/sf/clausen.rb0000755000175000017500000000022112220252463016145 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 20, 100) a = GSL::Sf::clausen(x) GSL::graph(x, a, "-C -g 3 -L 'Sf::clausen(x)'") gsl-1.15.3/examples/sf/synchrotron.rb0000755000175000017500000000023212220252463017105 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 5, 100) s = GSL::Sf::synchrotron_1(x) s.graph(x, "-C -g 3 -X x -L 'Sf::synchrotron_1(x)'") gsl-1.15.3/examples/sf/laguerre.rb0000755000175000017500000000051712220252463016331 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 5, 40) e = GSL::Sf::exp(-x/2) a = 0 IO.popen("graph -T X -C -g 3 -L 'Laguerre functions'", "w") do |io| for n in 0..5 do for i in 0...20 do y = GSL::Sf::laguerre_n(n, a, x[i])*e[i] io.printf("%e %e\n", x[i], y) end io.printf("\n") end end gsl-1.15.3/examples/sf/airy_Ai.rb0000755000175000017500000000022412220252463016073 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-10, 10, 100) a = GSL::Sf::airy_Ai(x) a.graph(x, "-C -g 3 -L 'GSL::Sf::airy_Ai(x)'") gsl-1.15.3/examples/sf/ellint.rb0000755000175000017500000000032212220252463016004 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 0.9, 100) k = GSL::Sf::ellint_Kcomp(x) e = GSL::Sf::ellint_Ecomp(x) GSL::Vector.graph(x, k, e, "-T X -g 3 -C -L 'Red: Kcomp(x), Green: Ecomp(x)'") gsl-1.15.3/examples/sf/airy_Bi.rb0000755000175000017500000000021412220252463016073 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-1, 4, 50) a = GSL::Sf::airy_Bi(x) a.graph(x, "-C -g 3 -L 'Sf::airy_Bi(x)'") gsl-1.15.3/examples/sf/ShiChi.rb0000755000175000017500000000035512220252463015672 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0.01, 12, 100) s = GSL::Sf::Shi(x) # s and c are GSL::Vector c = GSL::Sf::Chi(x) GSL::Vector.graph(x, s, c, "-T X -C -g 3 -y -1.5 2 -L 'Hyperbolic integrals Shi(x), Chi(x)'") gsl-1.15.3/examples/sf/gamma_inc_P.rb0000755000175000017500000000046512220252463016717 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(0.01, 14, n) y05 = GSL::Sf::gamma_inc_P(0.5, x) y1 = GSL::Sf::gamma_inc_P(1, x) y3 = GSL::Sf::gamma_inc_P(3, x) y10 = GSL::Sf::gamma_inc_P(10, x) GSL::Vector.graph(x, y05, y1, y3, y10, "-T X -C -g 3 -y 0 1.1 -L 'Incomplete gamma functions'") gsl-1.15.3/examples/sf/bessel_IK.rb0000755000175000017500000000055712220252463016367 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0.01, 4, n) I0 = GSL::Sf::bessel_I0(x) I1 = GSL::Sf::bessel_I1(x) I2 = GSL::Sf::bessel_In(2, x) y0 = GSL::Sf::bessel_K0(x) y1 = GSL::Sf::bessel_K1(x) y2 = GSL::Sf::bessel_Kn(2, x) GSL::Vector.graph(x, I0, I1, I2, y0, y1, y2, "-T X -C -g 3 -y 0 6 -X x -L 'Bessel functions I0, I1, I2, K0, K1, K2'") gsl-1.15.3/examples/sf/fermi.rb0000755000175000017500000000037512220252463015627 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0, 10, n) m1 = GSL::Sf::fermi_dirac_m1(x) IO.popen("graph -T X -C -g 3 -X x -L 'Fermi-Dirac function'", "w") do |io| for i in 0...n do io.printf("%e %e\n", x[i], m1[i]) end end gsl-1.15.3/examples/sf/sphbessel.gp0000644000175000017500000000143512220252463016513 0ustar boutilboutilset multiplot set size 0.5, 0.5 set xrange [0:12] set grid set xlabel 'x' set origin 0, 0.5 set yrange [-0.5:1.2] set ylabel 'j(x)' plot 'sphbessel.dat' u 1:2 title 'j0' w l lw 2, '' u 1:3 title 'j1' w l lw 2, '' u 1:4 title 'j2' w l lw 2, '' u 1:5 title 'j3' w l lw 2 set origin 0.5, 0.5 set ylabel 'y(x)' set yrange [-1:0.6] plot 'sphbessel.dat' u 1:6 title 'y0' w l lw 2, '' u 1:7 title 'y1' w l lw 2, '' u 1:8 title 'y2' w l lw 2 set xrange [0:4] set yrange [0:1] set origin 0, 0 set ylabel 'exp(-|x|) i(x)' plot 'sphbessel.dat' u 1:9 title 'i0' w l lw 2, '' u 1:10 title 'i1' w l lw 2, '' u 1:11 title 'i2' w l lw 2 set origin 0.5, 0 set yrange [0:10] set ylabel 'exp(x) k(x)' plot 'sphbessel.dat' u 1:12 title 'k0' w l lw 2, '' u 1:13 title 'k1' w l lw 2, '' u 1:14 title 'k2' w l lw 2 gsl-1.15.3/examples/sf/dilog.rb0000755000175000017500000000022512220252463015615 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0, 20, n) y = GSL::Sf::dilog(x) y.graph(x, "-T X -C -g 3 -X x -L 'Dilogarithm'") gsl-1.15.3/examples/sf/zetam1.rb0000755000175000017500000000027312220252463015723 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") s = GSL::Vector.linspace(1.05, 13, 100) y = GSL::Sf::zetam1(s) y.graph(s, "-C -l y -L 'Zeta function z(s)-1' -X s -Y 'z(s)-1' --toggle-rotate-y-label") gsl-1.15.3/examples/sf/SiCi.rb0000755000175000017500000000034412220252463015350 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0.1, 12, 100) s = GSL::Sf::Si(x) - Math::PI/2.0 c = GSL::Sf::Ci(x) GSL::Vector.graph(x, s, c, "-T X -C -g 3 -y -1.5 1 -L 'Red: Sine integral, Green: Cosine integral'") gsl-1.15.3/examples/sf/beta_inc.rb0000755000175000017500000000052312220252463016264 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(0.01, 1, n) y1 = GSL::Sf::beta_inc(0.5, 5.0, x) y2 = GSL::Sf::beta_inc(1.0, 3.0, x) y3 = GSL::Sf::beta_inc(8.0, 10.0, x) y4 = GSL::Sf::beta_inc(5.0, 0.5, x) GSL::Vector.graph([x, y1], [x, y2], [x, y3], [x, y4], "-T X -C -g 3 -y 0 1.1 -X x -L 'Incomplete beta functions'") gsl-1.15.3/examples/sf/gegenbauer.rb0000755000175000017500000000037512220252463016631 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0, 5, n) y1 = GSL::Sf::gegenpoly_1(0, x) y2 = GSL::Sf::gegenpoly_2(0, x) y3 = GSL::Sf::gegenpoly_3(0, x) GSL::Vector.graph(x, y1, y2, y3, "-T X -C -g 3 -X x -L 'Gegenbauer functions'") gsl-1.15.3/examples/sf/expint.rb0000755000175000017500000000043612220252463016032 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0.01, 2, n) y1 = GSL::Sf::expint_E1(x) y2 = GSL::Sf::expint_E2(x) yi = GSL::Sf::expint_Ei(x) GSL::Vector.graph(x, y1, y2, yi, "-T X -C -g 3 -X x -Y 'E(x)' --toggle-rotate-y-label -L 'Exponential integral E1, E2, Ei'") gsl-1.15.3/examples/blas/0000755000175000017500000000000012220252463014501 5ustar boutilboutilgsl-1.15.3/examples/blas/level1.rb0000755000175000017500000000200512220252463016216 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include GSL::Blas x = GSL::Vector[1, 2, 3] y = GSL::Vector[4, 5, 6] p x.blas_ddot(y) p GSL::Blas.ddot(x, y) xz = GSL::Vector::Complex.alloc([1, 0], [2, 0], [3, 0]) yz = GSL::Vector::Complex.alloc([4, 0], [5, 0], [6, 0]) p zdotu(xz, yz) p x.nrm2 p GSL::Blas.dnrm2(x) p xz.nrm2 p GSL::Blas.dznrm2(xz) p x.asum p GSL::Blas.dasum(x) p xz.asum p GSL::Blas.dzasum(xz) x.swap(y) p x p y GSL::Blas.dswap(x, y) p x p y xz.swap(yz) p xz p yz GSL::Blas.zswap(xz, yz) p xz p yz p x.axpy(2, y) p y p GSL::Blas.daxpy(2, x, y) p y p x.axpy!(2, y) p y p GSL::Blas.daxpy!(2, x, y) p y y = GSL::Vector[4, 5, 6] az = GSL::Complex.alloc(2, 0) p xz.zaxpy(az, yz) p yz p GSL::Blas.zaxpy(az, xz, yz) p yz az = GSL::Complex[2, 0] p xz.axpy!(az, yz) p yz p GSL::Blas.zaxpy!(az, xz, yz) p yz yz = GSL::Vector::Complex.alloc([4, 0], [5, 0], [6, 0]) p x.scal(2) p x p x.scal!(2) p x x = GSL::Vector[1, 2, 3] p xz.zscal(az) p xz.zdscal(2) p y p GSL::Blas.drot(x, y, 2, 3) p drot(x, y, 2, 3) gsl-1.15.3/examples/blas/dnrm2.rb0000755000175000017500000000041512220252463016053 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math m = GSL::Matrix.alloc(10, 10) for i in 0...10 for j in 0...10 m.set(i, j, sin(i) + cos(j)) end end for j in 0...10 col = m.col(j) d = GSL::Blas.dnrm2(col) printf("matrix column %d, norm = %g\n", j, d) end gsl-1.15.3/examples/blas/level3.rb0000755000175000017500000000036212220252463016224 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::Blas a = GSL::Matrix.alloc([1, 5], [4, 6]) b = GSL::Matrix.alloc([10, 2], [3, 8]) c = GSL::Matrix.alloc(2, 2) p GSL::Blas.dgemm(NoTrans, NoTrans, 1, a, b, 1, c) p GSL::Blas.dgemm(a, b) p a*b gsl-1.15.3/examples/blas/level2.rb0000755000175000017500000000037012220252463016222 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::Blas x = GSL::Vector[1, 2, 3] y = GSL::Vector[4, 5, 6] A = GSL::Matrix.alloc([1, 2, 3], [4, 5, 6], [7, 8, 9]) # [28, 64, 100] p GSL::Blas.dgemv(CblasNoTrans, 2, A, x) p dgemv(CblasNoTrans, 2, A, x) gsl-1.15.3/examples/blas/blas.rb0000755000175000017500000000042612220252463015754 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") a = GSL::Vector[0.11, 0.12, 0.13, 0.21, 0.22, 0.23] b = GSL::Vector[1011, 1012, 1021, 1022, 1031, 1032] A = a.matrix_view(2, 3) B = b.matrix_view(3, 2) C = GSL::Blas.dgemm(GSL::Blas::NoTrans, GSL::Blas::NoTrans, 1.0, A, B, 0.0) p C p A*B gsl-1.15.3/examples/multimin/0000755000175000017500000000000012220252463015416 5ustar boutilboutilgsl-1.15.3/examples/multimin/fdfminimizer.rb0000755000175000017500000000211612220252463020431 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL::MultiMin my_f = Proc.new { |v, params| x = v[0]; y = v[1] p0 = params[0]; p1 = params[1] 10.0*(x - p0)*(x - p0) + 20.0*(y - p1)*(y - p1) + 30.0 } my_df = Proc.new { |v, params, df| x = v[0]; y = v[1] p0 = params[0]; p1 = params[1] df[0] = 20.0*(x-p0) df[1] = 40.0*(y-p1) } my_func = GSL::MultiMin::Function_fdf.alloc(my_f, my_df, 2) my_func.set_params([1.0, 2.0]) # parameters x = GSL::Vector.alloc([5.0, 7.0]) # starting point #minimizer = GSL::MultiMin::FdfMinimizer.alloc("conjugate_fr", 2) minimizer = GSL::MultiMin::FdfMinimizer.alloc(GSL::MultiMin::FdfMinimizer::VECTOR_BFGS, 2) #minimizer = GSL::MultiMin::FdfMinimizer.alloc(GSL::MultiMin::FdfMinimizer::VECTOR_BFGS2, 2) minimizer.set(my_func, x, 0.01, 1e-4) iter = 0 begin iter += 1 status = minimizer.iterate() status = minimizer.test_gradient(1e-3) if status == GSL::SUCCESS puts("Minimum found at") end x = minimizer.x f = minimizer.f printf("%5d %.5f %.5f %10.5f\n", iter, x[0], x[1], f) end while status == GSL::CONTINUE and iter < 100 gsl-1.15.3/examples/multimin/fminimizer.rb0000755000175000017500000000161512220252463020122 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include GSL::MultiMin np = 2 my_f = Proc.new { |v, params| x = v[0]; y = v[1] p0 = params[0]; p1 = params[1] 10.0*(x - p0)*(x - p0) + 20.0*(y - p1)*(y - p1) + 30.0 } my_func = MultiMin::Function.alloc(my_f, np) my_func.set_params([1.0, 2.0]) # parameters x = Vector.alloc([5, 7]) ss = Vector.alloc(np) ss.set_all(1.0) #minimizer = FMinimizer.alloc("nmsimplex", np) minimizer = FMinimizer.alloc(MultiMin::FMinimizer::NMSIMPLEX, np) minimizer.set(my_func, x, ss) iter = 0 begin iter += 1 status = minimizer.iterate() status = minimizer.test_size(1e-2) if status == GSL::SUCCESS puts("converged to minimum at") end x = minimizer.x printf("%5d ", iter); for i in 0...np do printf("%10.3e ", x[i]) end printf("f() = %7.3f size = %.3f\n", minimizer.fval, minimizer.size); end while status == GSL::CONTINUE and iter < 100 gsl-1.15.3/examples/multimin/cqp.rb0000755000175000017500000000647612220252463016546 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") module GSL::CQP class Test_Problem def Test_Problem.gould() cqp_data = GSL::CQP::Data.alloc() cqp_data.Q = GSL::Matrix.eye(2, 2) cqp_data.q = GSL::Vector[-2.0, -1.0] cqp_data.A = GSL::Matrix[[3, 1], 1, 2] cqp_data.b = GSL::Vector.alloc(1); cqp_data.b[0] = 1.5 cqp_data.C = GSL::Matrix[[1, 0, 0, 1], 2, 2] cqp_data.d = GSL::Vector.calloc(2) Test_Problem.new("Goulds's problem", 2, 1, 2, cqp_data, 0.0) end def Test_Problem.betts() cqp_data = GSL::CQP::Data.alloc() cqp_data.Q = GSL::Matrix[[0.02, 0, 0, 2], 2, 2] cqp_data.q = GSL::Vector.calloc(2) cqp_data.A = GSL::Matrix[[10, -1.0], 1, 2] cqp_data.b = GSL::Vector.alloc(1); cqp_data.b[0] = 20 cqp_data.C = GSL::Matrix.calloc(4, 2) cqp_data.C[0,0] = 1.0; cqp_data.C[1,1] = 1.0 cqp_data.C[2,0] = -1.0; cqp_data.C[3,1] = -11.0 cqp_data.d = GSL::Vector[2.0, -50, -50, -50] Test_Problem.new("Betts's problem", 2, 1, 4, cqp_data, 0.04) end def Test_Problem.beale() cqp_data = GSL::CQP::Data.alloc() cqp_data.Q = GSL::Matrix[[4, 2, 2, 2, 4, 0, 2, 0, 2], 3, 3] cqp_data.q = GSL::Vector[-8, -6, -4] cqp_data.A = GSL::Matrix[[-1, -1, -2], 1, 3] cqp_data.b = GSL::Vector.alloc(1); cqp_data.b[0] = -3.0 cqp_data.C = GSL::Matrix.eye(3, 3) cqp_data.d = GSL::Vector.calloc(3) cqp_data.Q[0,0] = 4.0; cqp_data.Q[0,1] = 2.0 cqp_data.Q[1,0] = 2.0; cqp_data.Q[1,1] = 4.0 cqp_data.Q[2,0] = 2.0; cqp_data.Q[2,2] = 2.0 Test_Problem.new("Beale's problem", 3, 1, 3, cqp_data, 9.0+1.0/9.0) end def initialize(name, n, me, mi, cqp, opt_value) @name = name @n = n @me = me @mi = mi @cqp = cqp @opt_value = opt_value end def solve() max_iter = 1000 iter = 1 status = GSL::CONTINUE s = GSL::CQP::Minimizer.alloc("mg_pdip", @n, @me, @mi) s.set(@cqp) printf("******************** %s ********************\n\n", @name) printf("== Itn ======= f ======== ||gap|| ==== ||residual||\n\n") begin status = s.iterate status = s.test_convergence(1e-10, 1e-10) printf("%4d %14.8f %13.6e %13.6e\n", iter, s.f, s.gap, s.residuals_norm) if status == GSL::SUCCESS printf("\nMinimum is found at\n"); x = s.x lm_eq = s.lm_eq lm_ineq = s.lm_ineq for j in 0...x.size do printf("%9.6f ", x[j]) end printf("\n\n") printf("\nLagrange-multipliers for Ax=b\n") for j in 0...lm_eq.size do printf("%9.6f ", lm_eq[j]) end printf("\n\n") printf("\nLagrange-multipliers for Cx>=d\n"); for j in 0...lm_ineq.size do printf("%9.6f ", lm_ineq[j]) end printf("\n\n") else iter += 1 end end while status == GSL::CONTINUE and iter <= max_iter GSL::SUCCESS end attr_accessor :name, :n, :me, :mi attr_accessor :cqp, :opt_value end end tp = Array.new(3) tp[0] = GSL::CQP::Test_Problem.gould() tp[1] = GSL::CQP::Test_Problem.betts() tp[2] = GSL::CQP::Test_Problem.beale() tp.each do |t| t.solve() end gsl-1.15.3/examples/multimin/bundle.rb0000755000175000017500000000267612220252463017232 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") demyanov_f = Proc.new { |x, params| GSL::MAX_DBL(5.0*x[0]+x[1], GSL::MAX_DBL(x[0]*x[0]+x[1]*x[1]+4.0*x[1], -5.0*x[0] + x[1])) } demyanov_sdf = Proc.new { |x, sdf| f = 5.0*x[0] + x[1] ff = x[0]*x[0] + x[1]*x[1] + 4.0*x[1] i_max = 1 if f < ff f = ff i_max = 2 end if f < -5.0*x[0] + x[1] i_max = 3 end case i_max when 1 sdf[0] = 5.0 sdf[1] = 1.0 when 2 sdf[0] = 2.0*x[0] sdf[1] = 2.0*x[1] + 4.0 when 3 sdf[0] = -5.0 sdf[1] = 1.0 end } max_iter = 1000 n = 2 function = GSL::MultiMin::Function_fsdf.alloc(demyanov_f, demyanov_sdf, n) start_point = GSL::Vector.alloc(n) start_point.set_all(1.0) bundle_size_max = n + 3 s = GSL::MultiMin::FsdfMinimizer.alloc("bundle_method", n) s.set(function, start_point, bundle_size_max) printf("******************** %s ********************\n\n","Demyanov function") printf("== k ===== f(x) ===== ||sgr_f(x)|| ======= eps ====== \n"); subgradient = s.subgradient iter = 0; printf("%4d %14.7f %13.8e %13.8e\n", iter, s.f, subgradient.dnrm2, s.eps) begin iter += 1 status = s.iterate status = s.test_convergence(1e-5) printf("%4d %14.7f %13.8e %13.8e\n", iter, s.f, subgradient.dnrm2, s.eps) if status == GSL::SUCCESS printf("\nMinimum is found at\n") x = s.x for j in 0...x.size do printf("%9.6f ", x[j]) end printf("\n\n") end end while status == GSL::CONTINUE and iter <= max_iter gsl-1.15.3/examples/math/0000755000175000017500000000000012220252463014511 5ustar boutilboutilgsl-1.15.3/examples/math/test.rb0000755000175000017500000000074112220252463016022 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") puts("sign of 5.0") p GSL::SIGN(5.0) puts("sign of -2.0") p GSL::SIGN(-2.0) puts("sign of 0: positive") p GSL::SIGN(0) puts("Is 1 odd?") p GSL::IS_ODD(1) p GSL::IS_ODD?(1) puts("Is 1 even?") p GSL::IS_EVEN(1) p GSL::IS_EVEN?(1) puts("Is 4 odd?") p GSL::IS_ODD(4) p GSL::IS_ODD?(4) puts("Is 4 even?") p GSL::IS_EVEN(4) p GSL::IS_EVEN?(4) puts("frcmp") p GSL::fcmp(1.0, 1.0, 1e-10) p GSL::fcmp(1.1, 1.0, 1e-10) p GSL::fcmp(1.0, 1.1, 1e-10) gsl-1.15.3/examples/math/const.rb0000755000175000017500000000145012220252463016167 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL puts("e") p GSL::M_E p Math::exp(1) puts("log10(e)") p GSL::M_LOG10E p Math::log10(M_E) puts("sqrt(2)") p GSL::M_SQRT2 p Math::sqrt(2) puts("sqrt(1/2)") p GSL::M_SQRT1_2 p Math::sqrt(1.0/2) puts("sqrt(3)") p GSL::M_SQRT3 p Math::sqrt(3) puts("pi") p GSL::M_PI p Math::PI puts("pi/2") p GSL::M_PI_2 p Math::PI/2.0 puts("pi/4") p GSL::M_PI_4 p Math::PI/4.0 puts("sqrt(pi)") p GSL::M_SQRTPI p Math::sqrt(Math::PI) puts("2/sqrt(pi)") p GSL::M_2_SQRTPI p 2.0/Math::sqrt(Math::PI) puts("1/pi") p GSL::M_1_PI p 1.0/Math::PI puts("2/pi") p GSL::M_2_PI p 2.0/Math::PI puts("ln10") p GSL::M_LN10 p Math::log(10) puts("ln2") p GSL::M_LN2 p Math::log(2) puts("ln(pi)") p GSL::M_LNPI p Math::log(Math::PI) puts("euler constant 0.5772156...") p GSL::M_EULER gsl-1.15.3/examples/math/inf_nan.rb0000755000175000017500000000110112220252463016442 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL puts("GSL_POSINF") p GSL::POSINF p GSL::POSINF.class p isinf(GSL::POSINF) p isinf?(GSL::POSINF) p isnan(GSL::POSINF) p isnan?(GSL::POSINF) p finite(GSL::POSINF) p finite?(GSL::POSINF) puts("GSL_NEGINF") p GSL::NEGINF p GSL::NEGINF.class p isinf(GSL::NEGINF) p isinf?(GSL::NEGINF) p isnan(GSL::NEGINF) p isnan?(GSL::NEGINF) p finite(GSL::NEGINF) p finite?(GSL::NEGINF) puts("GSL_NAN") p GSL::NAN p GSL::NAN.class p isinf(GSL::NAN) p isinf?(GSL::NAN) p isnan(GSL::NAN) p isnan?(GSL::NAN) p finite(GSL::NAN) p finite?(GSL::NAN ) gsl-1.15.3/examples/math/power.rb0000755000175000017500000000044412220252463016177 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") p GSL::pow_int(8, 3) p 8*8*8.0 p GSL::pow_2(2) p GSL::pow_3(2) p GSL::pow_4(2) p GSL::pow_5(2) p GSL::pow_6(2) p GSL::pow_7(2) p GSL::pow_8(2) p GSL::pow_9(2) p GSL::pow(3.2, 4.5) p GSL::pow([1, 2, 3, 4, 5], 3) p GSL::pow(GSL::Vector[1, 2, 3, 4, 5], 3) gsl-1.15.3/examples/math/minmax.rb0000755000175000017500000000056012220252463016333 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") p GSL::MAX(1, 2) p GSL::MAX(1, 2.0) p GSL::MAX(3, 1) p GSL::MAX(3.0, 1) p GSL::MIN(1, 2) p GSL::MIN(1.0, 2.0) p GSL::MIN(3, 1.0) p GSL::MIN(3.0, 1) p GSL::MAX_INT(5, 6) p GSL::MAX_INT(5, 6.0) p GSL::MAX_INT(6, 5) p GSL::MAX_INT(6.0, 5) p GSL::MIN_INT(2, 2) p GSL::MIN_INT(2.0, 2.0) p GSL::MIN_INT(7, 2.0) p GSL::MIN_INT(7.0, 2) gsl-1.15.3/examples/math/elementary.rb0000755000175000017500000000101712220252463017205 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") puts("gsl_log1p") p GSL::log1p(0.1) p Math::log(1 + 0.1) puts("gsl_expm1") p GSL::expm1(0.1) p Math::exp(0.1) - 1.0 puts("gsl_hypot") p GSL::hypot(20000, 30000) p Math::sqrt(20000*20000 + 30000*30000) puts("gsl_acosh") p GSL::acosh(1.5) p Math::acosh(1.5) puts("gsl_asinh") p GSL::asinh(1.5) p Math::asinh(1.5) puts("gsl_atanh") p GSL::atanh(0.5) p Math::atanh(0.5) puts("gsl_ldexp") p GSL::ldexp(1.5, 8) p Math::ldexp(1.5, 8) puts("gsl_frexp") p GSL::frexp(100) p Math::frexp(100) gsl-1.15.3/examples/math/functions.rb0000755000175000017500000000115612220252463017054 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") puts("gsl_log1p") p GSL::log1p(0.1) a = GSL::Vector.alloc(0.1, 1, 2, 3, 4) p GSL::log1p(a) b = GSL::Matrix.alloc([1, 2], [3, 4]) p GSL::log1p(b) exit puts("gsl_expm1") p GSL::expm1(0.1) p Math::exp(0.1) - 1.0 puts("gsl_hypot") p GSL::hypot(20000, 30000) p Math::sqrt(20000*20000 + 30000*30000) puts("gsl_acosh") p GSL::acosh(1.5) p Math::acosh(1.5) puts("gsl_asinh") p GSL::asinh(1.5) p Math::asinh(1.5) puts("gsl_atanh") p GSL::atanh(0.5) p Math::atanh(0.5) puts("gsl_ldexp") p GSL::ldexp(1.5, 8) p Math::ldexp(1.5, 8) puts("gsl_frexp") p GSL::frexp(100) p Math::frexp(100) gsl-1.15.3/examples/siman.rb0000755000175000017500000000146512220252463015225 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL include GSL::Siman N_TRIES = 200 ITERS_FIXED_T = 10 STEP_SIZE = 10 K = 1.0 T_INITIAL = 0.002 MU_T = 1.005 T_MIN = 2.0e-6 params = Siman::Params.alloc(N_TRIES, ITERS_FIXED_T, STEP_SIZE, K, T_INITIAL, MU_T, T_MIN) efunc = Efunc.alloc { |vx| x = vx[0] s = (x - 1.0) Math::exp(-s*s)*Math::sin(8*x) } metric = Metric.alloc { |vx, vy| (x[0] - y[0]).abs } step = Step.alloc { |rng, vx, step_size| r = rng.uniform old_x = vx[0] a = r * 2 * step_size - step_size + old_x vx[0] = a } simanprint = Print.alloc { |vx| printf("%12g", vx[0]) } x = GSL::Vector.alloc([15.5]) GSL::Rng.env_setup() r = GSL::Rng.alloc() Siman::solve(r, x, efunc, step, metric, simanprint, params) #Siman::solve(r, x, efunc, step, metric, nil, params) p x gsl-1.15.3/examples/wavelet/0000755000175000017500000000000012220252463015227 5ustar boutilboutilgsl-1.15.3/examples/wavelet/ecg.dat0000644000175000017500000000525212220252463016463 0ustar boutilboutil0.0462458 0.0462458 0.0512458 0.0712458 0.0712458 0.0662458 0.0962458 0.1012458 0.1162458 0.1212458 0.1162458 0.1062458 0.0912458 0.1012458 0.0962458 0.0962458 0.0962458 0.0912458 0.0862458 0.0812458 0.0862458 0.1012458 0.1112458 0.1162458 0.0762458 0.0362458 0.0362458 0.0212458 0.0112458 -0.0087542 -0.0087542 -0.0037542 0.0062458 0.0012458 0.0062458 -0.0037542 -0.0187542 -0.0237542 -0.0187542 -0.0187542 -0.0287542 -0.0237542 -0.0337542 -0.0087542 -0.0137542 -0.0087542 0.0012458 -0.0237542 -0.0337542 -0.0187542 -0.0087542 -0.0037542 -0.0087542 -0.0287542 -0.0437542 -0.0387542 -0.0587542 -0.1037542 -0.1237542 -0.1537542 -0.1887542 -0.2137542 -0.1837542 -0.0937542 0.0212458 0.1612458 0.3062458 0.5562458 0.8112458 1.0412458 1.1962458 1.2612458 1.2262458 1.0762458 0.8112458 0.4862458 0.2112458 0.0512458 -0.0687542 -0.1287542 -0.1537542 -0.1337542 -0.1037542 -0.0687542 -0.0687542 -0.0637542 -0.0687542 -0.0587542 -0.0587542 -0.0587542 -0.0737542 -0.0637542 -0.0637542 -0.0637542 -0.0537542 -0.0737542 -0.0887542 -0.0887542 -0.0787542 -0.0737542 -0.0687542 -0.0837542 -0.0737542 -0.0637542 -0.0537542 -0.0687542 -0.0687542 -0.0837542 -0.0887542 -0.0887542 -0.0687542 -0.0687542 -0.0737542 -0.0837542 -0.0937542 -0.0787542 -0.0887542 -0.0837542 -0.0887542 -0.0937542 -0.0887542 -0.0787542 -0.0787542 -0.0737542 -0.0687542 -0.0837542 -0.0887542 -0.0687542 -0.0687542 -0.0637542 -0.0637542 -0.0887542 -0.0837542 -0.0737542 -0.0687542 -0.0537542 -0.0687542 -0.0737542 -0.0887542 -0.0787542 -0.0687542 -0.0687542 -0.0637542 -0.0837542 -0.0937542 -0.0937542 -0.0787542 -0.0737542 -0.0837542 -0.0937542 -0.0987542 -0.0987542 -0.0887542 -0.0937542 -0.1037542 -0.0987542 -0.1137542 -0.1087542 -0.1087542 -0.0987542 -0.1087542 -0.1287542 -0.1337542 -0.1287542 -0.1137542 -0.1237542 -0.1287542 -0.1337542 -0.1487542 -0.1387542 -0.1337542 -0.1287542 -0.1337542 -0.1487542 -0.1537542 -0.1387542 -0.1287542 -0.1237542 -0.1187542 -0.1137542 -0.1187542 -0.0887542 -0.0737542 -0.0487542 -0.0437542 -0.0387542 -0.0437542 -0.0187542 -0.0037542 0.0062458 0.0012458 -0.0087542 -0.0087542 0.0012458 0.0112458 0.0212458 0.0212458 0.0012458 0.0012458 0.0062458 0.0162458 0.0162458 0.0262458 0.0012458 -0.0087542 0.0162458 0.0112458 0.0212458 0.0212458 0.0012458 -0.0037542 0.0112458 0.0162458 0.0062458 0.0162458 0.0062458 0.0062458 0.0112458 0.0262458 0.0312458 0.0162458 0.0112458 0.0012458 0.0062458 0.0212458 0.0062458 0.0062458 0.0062458 -0.0087542 0.0062458 0.0012458 0.0062458 -0.0037542 -0.0137542 -0.0187542 -0.0137542 -0.0137542 -0.0087542 -0.0037542 -0.0237542 -0.0287542 -0.0237542 -0.0137542 -0.0087542 -0.0087542 -0.0237542 -0.0237542 -0.0237542 0.0012458 -0.0087542 -0.0137542 -0.0187542 -0.0337542 -0.0137542 -0.0087542 -0.0087542 gsl-1.15.3/examples/wavelet/wavelet1.rb0000755000175000017500000000315712220252463017315 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 256 nc = 20 data = GSL::Vector.alloc(n) data.fscanf("ecg.dat") w = GSL::Wavelet.alloc("daubechies", 4) work = GSL::Wavelet::Workspace.alloc(n) # Choose as you like... data2 = w.transform(data, GSL::Wavelet::FORWARD, work) #data2 = data.wavelet_transform(w, GSL::Wavelet::FORWARD, work) #data2 = data.wavelet_transform_forward(w, work) #data2 = w.transform(data, work) #data2 = w.transform(data) #data2 = w.transform(data, GSL::Wavelet::FORWARD) #data2 = w.transform_forward(data, work) #data2 = w.transform_forward(data) #data2 = GSL::Wavelet.transform(w, data, GSL::Wavelet::FORWARD, work) #data2 = GSL::Wavelet.transform(w, data, GSL::Wavelet::FORWARD) #data2 = GSL::Wavelet.transform(w, data, work) #data2 = GSL::Wavelet.transform(w, data) #data2 = GSL::Wavelet.transform_forward(w, data, work) #data2 = GSL::Wavelet.transform_forward(w, data) perm = data2.abs.sort_index i = 0 while (i + nc) < n data2[perm[i]] = 0.0 i += 1 end # Choose as you like... data3 = w.transform(data2, GSL::Wavelet::BACKWARD, work) #data3 = data2.wavelet_transform(w, GSL::Wavelet::BACKWARD, work) #data3 = data2.wavelet_transform_inverse(w, work) #data3 = w.transform(data2, GSL::Wavelet::BACKWARD) #data3 = w.transform_inverse(data2, work) #data3 = w.transform_inverse(data2) #data3 = GSL::Wavelet.transform(w, data2, GSL::Wavelet::BACKWARD, work) #data3 = GSL::Wavelet.transform(w, data2, GSL::Wavelet::BACKWARD) #data3 = GSL::Wavelet.transform_inverse(w, data2, work) #data3 = GSL::Wavelet.transform_inverse(w, data2) GSL::graph(nil, data, data3, "-T X -C -g 3 -x 0 #{data.size} -L 'Red: data, Green: DWT'") gsl-1.15.3/examples/function/0000755000175000017500000000000012220252463015405 5ustar boutilboutilgsl-1.15.3/examples/function/synchrotron.rb0000755000175000017500000000105112220252463020322 0ustar boutilboutil#!/usr/bin/env ruby # Find synchrotron spectrum peak require("gsl") # Create Function object from the module function F = GSL::Function.alloc { |x| GSL::Sf::synchrotron_1(x) } # Derivative of the function DF = GSL::Function.alloc { |x| result, abserr, status = F.deriv_central(x, 1e-6) result } # Find zero-point of the derivative in interval (0.01, 5) peak, = DF.fsolve(0.01, 5) printf("A peak is found at %3.2f.\n", peak) x = GSL::Vector.linspace(0, 5, 100) s = GSL::Sf::synchrotron_1(x) s.graph(x, "-C -g 3 -X x -L 'Sf::synchrotron_1(x)'") gsl-1.15.3/examples/function/function.rb0000755000175000017500000000061612220252463017565 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math f = GSL::Function::alloc{ |x, params| a = params[0] b = params[1] c = params[2] (a*x + b)*x + c } p f.proc p f.params a = 1; b = 2; c = 3 f.set_params(a, b, c) p f.params p f.eval(2) p f.call(4) f.set { |x| x*x*x } p f.params p f.eval(2) p f[4] f2 = GSL::Function.alloc { |x| sin(x) - log(x)*sqrt(x) } p f2.eval(2.5) p f2.arity gsl-1.15.3/examples/function/sin.rb0000755000175000017500000000025312220252463016526 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 2*Math::PI, 20) f = GSL::Function.alloc { |x| GSL::Sf::sin(x) } f.graph(x, "-T X -g 3 -C -L 'sin(x)'") gsl-1.15.3/examples/function/min.rb0000755000175000017500000000201012220252463016511 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") humps = GSL::Function.alloc { |x| 1.0/(GSL::pow_2(x-0.3) + 0.01) + 1.0/(GSL::pow_2(x-0.9)+0.04) - 6 } iter = 0; max_iter = 500 m = 0.7 # initial guess m_expected = 0.6370 a = 0.3; b = 1.0 gmf = GSL::Min::FMinimizer.alloc(GSL::Min::FMinimizer::BRENT) gmf.set(humps, m, a, b) printf("Using %s method\n", gmf.name) printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "min", "err", "err(est)") printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", iter, a, b, m, m - m_expected, b - a) begin iter += 1 status = gmf.iterate status = gmf.test_interval(0.0001, 0.0) puts("Converged:") if status == GSL::SUCCESS a = gmf.x_lower; b = gmf.x_upper m = gmf.x_minimum printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", iter, a, b, m, m - m_expected, b - a); end while status == GSL::CONTINUE and iter < max_iter x = GSL::Vector.linspace(-0.5, 1.5, 100) GSL::graph([x, humps.eval(x)], [GSL::Vector[m], GSL::Vector[humps.eval(m)]], "-C -g 3 -S 4 -m -1") gsl-1.15.3/examples/function/log.rb0000755000175000017500000000037412220252463016522 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") f_log = GSL::Function.alloc { |x| Math::log(x) } x = GSL::Vector.linspace(1, 100, 10) x2 = GSL::Vector.logspace2(1, 100, 10) GSL::graph([x, f_log.eval(x)], [x2, f_log.eval(x2)], "-T X -C -g 3 -l x -S 4 -L 'log(x)'") gsl-1.15.3/examples/gallery/0000755000175000017500000000000012220252463015217 5ustar boutilboutilgsl-1.15.3/examples/gallery/koch.rb0000755000175000017500000000156112220252463016476 0ustar boutilboutil#!/usr/bin/env ruby # Koch curve require("gsl") include Math ONE_UNIT = 3 def koch(x, y, theta, size, order, file) if order == 0 x += cos(theta)*size y += sin(theta)*size file.printf("%e %e\n", x, y) else x, y = koch(x, y, theta, size/3, order-1, file) theta += Math::PI/3 x, y = koch(x, y, theta, size/3, order-1, file) theta -= 2.0*Math::PI/3 x, y = koch(x, y, theta, size/3, order-1, file) theta += Math::PI/3 x, y = koch(x, y, theta, size/3, order-1, file) end return [x, y] end SIZE = 243 ORDER = 4 x = 0.0 y = 0.0 theta = 0.0 IO.popen("graph -T X -C -N x -N y", "w") do |io| io.printf("%e %e\n", x, y) x, y = koch(x, y, theta, SIZE, ORDER, io) theta -= 2.0*Math::PI/3 x, y = koch(x, y, theta, SIZE, ORDER, io) theta -= 2.0*Math::PI/3 x, y = koch(x, y, theta, SIZE, ORDER, io) theta -= 2.0*Math::PI/3 end gsl-1.15.3/examples/gallery/butterfly.rb0000755000175000017500000000036312220252463017571 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") phi = GSL::Vector.linspace(0, 12*Math::PI, 800) r = GSL::Sf::exp(GSL::Sf::cos(phi)) - 2*GSL::Sf::cos(4*phi) + GSL::pow_5(GSL::Sf::sin(phi/12)) x = r*GSL::Sf::cos(phi) y = r*GSL::Sf::sin(phi) GSL::graph(x, y) gsl-1.15.3/examples/gallery/polar.rb0000755000175000017500000000042312220252463016663 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") phi = GSL::Vector.linspace(0, 2*Math::PI, 200) r1 = GSL::Sf::sin(4*phi) x1 = r1*GSL::Sf::cos(phi) y1 = r1*GSL::Sf::sin(phi) r2 = GSL::Sf::cos(4*phi) x2 = r2*GSL::Sf::cos(phi) y2 = r2*GSL::Sf::sin(phi) GSL::Vector.graph([x1, y1], [x2, y2]) gsl-1.15.3/examples/gallery/eight.rb0000755000175000017500000000027512220252463016653 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") a = 1 t = GSL::Vector.linspace(0, 2*Math::PI, 100) cost = GSL::Sf::cos(t) sint = GSL::Sf::sin(t) x = a*sint y = a*sint*cost GSL::graph(x, y, "-T X -C") gsl-1.15.3/examples/gallery/rgplot/0000755000175000017500000000000012220252463016526 5ustar boutilboutilgsl-1.15.3/examples/gallery/rgplot/roesller.rb0000755000175000017500000000171212220252463020706 0ustar boutilboutil#!/usr/bin/env ruby require("gnuplot") require("gsl") dim = 3 roesller = Proc.new { |t, v, dvdt, params| a = params[0]; b = params[1]; c = params[2] x = v[0]; y = v[1]; z = v[2] dvdt[0] = - y - z dvdt[1] = x + a*y dvdt[2] = b*x - (c - x)*z } a = 0.344 b = 0.4 c = 4.5 solver = GSL::Odeiv::Solver.new(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], roesller, dim) solver.set_params(a, b, c) t = 0.0; tend = 100.0 h = 1e-6 v = GSL::Vector[1, 0, 0] GSL::ieee_env_setup() N = 1000 x = GSL::Vector[N] y = GSL::Vector[N] z = GSL::Vector[N] i = 0 while t < tend t, h, status = solver.apply(t, tend, h, v) x[i] = v[0] y[i] = v[1] z[i] = v[2] i += 1 break if status != GSL::SUCCESS end Gnuplot::open do |gp| Gnuplot::SPlot.new( gp ) do |plot| plot.title "Roesller equation" plot.data = [ Gnuplot::DataSet.new( [x.subvector(i), y.subvector(i), z.subvector(i)] ) { |ds| ds.title = "" ds.with = "lines" } ] end end gsl-1.15.3/examples/gallery/rgplot/rgplot.replaced0000644000175000017500000000000012220252463021524 0ustar boutilboutilgsl-1.15.3/examples/gallery/rgplot/cossin.rb0000755000175000017500000000140412220252463020353 0ustar boutilboutil#!/usr/bin/env ruby #begin # require 'rubygems' # require_gem "gnuplot" # Try using rubygem #ensure require 'gnuplot' # No gem, use traditional require #end require "gsl" # Add the to_gplot method to Vector since its not already built in. This # might be worthwhile adding to the core GSL stuff. x = GSL::Vector.linspace(0, 2*M_PI, 100) s = Sf::sin(x) c = Sf::cos(x) # Now generate the actual plot Gnuplot::open do |gp| Gnuplot::Plot.new( gp ) do |plot| plot.title "GSL plotting example" plot.data = [ Gnuplot::DataSet.new( [x, c] ) { |ds| ds.title = "cos(x)" ds.with = "lines" }, Gnuplot::DataSet.new( [x, s] ) { |ds| ds.title = "sin(x)" ds.with = "lines" } ] end end gsl-1.15.3/examples/gallery/scarabaeus.rb0000755000175000017500000000032512220252463017660 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") t = GSL::Vector.linspace(0, 2*Math::PI, 100) a = 2 b = 3 cost = GSL::Sf::cos(t) r = b*GSL::Sf::cos(2*t) - a*cost x = r*cost y = r*GSL::Sf::sin(t) GSL::graph(x, y, "-T X -C") gsl-1.15.3/examples/gallery/cayley.rb0000755000175000017500000000033612220252463017037 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") a = 1 t = GSL::Vector.linspace(0, 3*Math::PI, 100) cost = GSL::Sf::cos(t/3) cost3 = cost*cost*cost r = 4*a*cost3 x = r*GSL::Sf::cos(t) y = r*GSL::Sf::sin(t) GSL::graph(x, y, "-T X -C") gsl-1.15.3/examples/gallery/roesller.rb0000755000175000017500000000155312220252463017402 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") dim = 3 roesller = Proc.new { |t, v, dvdt, params| a = params[0]; b = params[1]; c = params[2] x = v[0]; y = v[1]; z = v[2] dvdt[0] = - y - z dvdt[1] = x + a*y dvdt[2] = b*x - (c - x)*z } a = 0.344 b = 0.4 c = 4.5 solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], roesller, dim) solver.set_params(a, b, c) t = 0.0; tend = 100.0 h = 1e-6 v = GSL::Vector.alloc(1, 0, 0) GSL::ieee_env_setup() IO.popen("gnuplot -persist", "w") do |io| io.print("set title 'Roesller equation'\n") io.print("set xlabel 'X'\n") io.print("set ylabel 'Y'\n") io.print("set zlabel 'Z'\n") io.printf("splot '-' u 2:3:4 w l\n") while t < tend t, h, status = solver.apply(t, tend, h, v) io.printf("%e %e %e %e\n", t, v[0], v[1], v[2]) break if status != GSL::SUCCESS end io.printf("e\n") io.flush end gsl-1.15.3/examples/gallery/lemniscate.rb0000755000175000017500000000031512220252463017672 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") a = 1 t = GSL::Vector.linspace(0, 2*Math::PI, 100) cost = GSL::Sf::cos(t) sint = GSL::Sf::sin(t) x = a*cost y = a*sint*cost/(1 + sint*sint) GSL::graph(x, y, "-T X -C") gsl-1.15.3/examples/gallery/cornu.rb0000755000175000017500000000106612220252463016700 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math sint2 = GSL::Function.alloc { |t| Math::sin(Math::PI/2*t*t) } cost2 = GSL::Function.alloc { |t| Math::cos(Math::PI/2*t*t) } w = GSL::Integration::Workspace.alloc(1000) t = 0 STDOUT.print("Computing... ") STDOUT.flush IO.popen("graph -T X -C -g 3 -X 'C(t)' -Y 'S(t)' --toggle-rotate-y-label -L 'Cornu spiral'", "w") do |io| t = -4 while t < 4 c = cost2.qag([0, t], w)[0] s = sint2.qag([0, t], w)[0] io.printf("%e %e\n", c, s) t += 0.01 end STDOUT.print("done\n") STDOUT.flush io.flush end gsl-1.15.3/examples/sum.rb0000755000175000017500000000155112220252463014716 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math N = 20 Zeta2 = PI*PI/6.0 v = GSL::Vector.alloc(N) sum = 0.0 for n in 0...N do np1 = n.to_f + 1.0 v[n] = 1.0/(np1 * np1) sum += v[n] end #sum_accel, err, sum_plain, terms_used = v.accel_sum #sum_accel, err, sum_plain, terms_used = v.sum_accel sum_accel, err, sum_plain, terms_used = v.accel printf("term-by-term sum = %.16f using %d terms\n", sum, N) printf("term-by-term sum = %.16f using %d terms\n", sum_plain, terms_used) printf("exact value = %.16f\n", Zeta2) printf("accelerated sum = %.16f using %d terms\n", sum_accel, terms_used) printf("Estimated error = %.16f\n", err) printf("Actual error = %.16f\n", sum_accel - Zeta2) p GSL::Sum::Levin_u.accel(v) p GSL::Sum::Levin_utrunc.accel(v) lu = GSL::Sum::Levin_u.alloc(N) p lu.accel(v) lutrunc = GSL::Sum::Levin_utrunc.alloc(N) p lutrunc.accel(v) gsl-1.15.3/examples/alf/0000755000175000017500000000000012220252463014322 5ustar boutilboutilgsl-1.15.3/examples/alf/alf.rb0000755000175000017500000000146412220252463015421 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") exit unless GSL.const_defined?("ALF") lmax = 3 #w = GSL::ALF::Workspace.alloc(lmax) #w = GSL::ALF.alloc(lmax) w = GSL::alf_alloc(lmax) w.params(0, 0, GSL::ALF::NORM_NONE) result = GSL::Vector.alloc(GSL::ALF::array_size(lmax)) deriv = GSL::Vector.alloc(GSL::ALF::array_size(lmax)) ind11 = GSL::ALF::array_index(1, 1) ind21 = GSL::ALF::array_index(2, 1) ind22 = GSL::ALF::array_index(2, 2) ind31 = GSL::ALF::array_index(3, 1) File.open("alf.dat", "w") do |f| theta = 0.01 while theta < 1.99*Math::PI do x = Math.cos(theta) # w.Plm_deriv_array(lmax, x, result, deriv) w.Plm_array(lmax, x, result, deriv) f.printf("%e %e %e %e %e\n", theta, result[ind11], result[ind21], result[ind22], result[ind31]) theta += 0.01 end end system("gnuplot -persist alf.gp") gsl-1.15.3/examples/alf/alf.gp0000644000175000017500000000042312220252463015413 0ustar boutilboutilset multiplot set size 0.5, 0.5 set grid set origin 0, 0.5 plot "alf.dat" u 1:2, sin(x) set origin 0.5, 0.5 plot "alf.dat" u 1:3, 3*cos(x)*sin(x) set origin 0, 0 plot "alf.dat" u 1:4, 3*sin(x)*sin(x) set origin 0.5, 0 plot "alf.dat" u 1:5, 1.5*sin(x)*(5*cos(x)*cos(x)-1) gsl-1.15.3/examples/narray/0000755000175000017500000000000012220252463015054 5ustar boutilboutilgsl-1.15.3/examples/narray/sf.rb0000755000175000017500000000122212220252463016011 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") na = NArray[0.1, 0.2, 0.3, 0.4] p GSL::Sf::legendre_Pl(2, na) v = GSL::Vector[0.1, 0.2, 0.3, 0.4] p GSL::Sf::legendre_Pl(2, v) na = NArray[[1.0, 2, 3, 4], [2, 3, 4, 5]] p GSL::Sf::sin(na) m = GSL::Matrix[[1.0, 2, 3, 4], [2, 3, 4, 5]] p GSL::Sf::sin(m) n = 50 x = GSL::Vector.linspace(0.01, 1, n).to_na y1 = GSL::Sf::beta_inc(0.5, 5.0, x) y2 = GSL::Sf::beta_inc(1.0, 3.0, x) y3 = GSL::Sf::beta_inc(8.0, 10.0, x) y4 = GSL::Sf::beta_inc(5.0, 0.5, x) p y1.class p y2.class p y3.class p y4.class GSL::Vector.graph([x, y1], [x.to_gv, y2], [x, y3.to_gv], [x, y4], "-T X -C -g 3 -y 0 1.1 -X x -L 'Incomplete beta functions'") gsl-1.15.3/examples/narray/narray2.rb0000755000175000017500000000114512220252463016763 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") na = NArray[1.0, 2, 3, 4, 5, 6, 7 ,8 ,9] p na v = GSL::Vector.alloc(na) p v v[3] = 99.9 p v p na na2 = NArray[12.3, 45.6, 78.9, 1.23, 4.56, 7.89] p na2 vref = na2.to_gv_view p vref vref[1] = 0.00 p na2 m = NMatrix[[1.0, 2],[3, 4]] p m gm = GSL::Matrix.alloc(m) p gm gm.set(1, 1, 99.9) p gm p m gm2 = m.to_gm_view gm2.set(1, 1, 99.9) p gm2 p m m = NMatrix[[0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]] mref = GSL::Matrix.to_gm_view(m) mref[1,1] = 123 p m mm = GSL::Matrix.to_gm(m) mm[1,1] = 456 p m gsl-1.15.3/examples/narray/mandel.rb0000755000175000017500000000105612220252463016646 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("nimage") def mandel(w, h) zoom = 3.5 z = (GSL::Matrix::Complex[w, 1].indgen!/w - 0.65)*zoom + (GSL::Matrix::Complex[1, h].indgen!/h - 0.5)*zoom*GSL::Complex[0, 1] c = z.clone a = GSL::Vector::Int[w, h] idx = GSL::Vector::Int[h, w].indgen! for i in 1..30 z = z*z + c idx_t,idx_f = (z.abs>2).where2 a[idx[idx_t]] = i break if idx_f.size==0 idx = idx[idx_f] z = z[idx_f] c = c[idx_f] end a end NImage.show mandel(400,400).to_na_ref print "Hit return key..." STDIN.getc gsl-1.15.3/examples/narray/narray.rb0000755000175000017500000000061712220252463016704 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") puts("\nGSL::Vector") v = GSL::Vector.alloc(1..9) p v puts("\nGSL::Vector ---> NArray") vna = v.to_na p vna puts("\nNArray ---> GSL::Vector") v2 = GSL::Vector.to_gv(vna) p v2 puts("\nGSL::Matrix") m = GSL::Matrix.alloc(1..9, 3, 3) p m puts("\nGSL::Matrix ---> NArray") mna = m.to_na p mna puts("\nNArray ---> GSL::Matrix") m2 = GSL::Matrix.to_gm(mna) p m2 gsl-1.15.3/examples/narray/histogram.rb0000755000175000017500000000037012220252463017401 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 r = GSL::Rng.alloc na = r.gaussian(1.0, N).to_na # Generate N random numbers p na.class p na.rank p na.size p na.min p na.max h = GSL::Histogram.alloc(50, [-4, 4]) h.fill(na) h.graph("-T X -C -g 3") gsl-1.15.3/examples/ool/0000755000175000017500000000000012220252463014351 5ustar boutilboutilgsl-1.15.3/examples/ool/gencan.rb0000755000175000017500000000400612220252463016134 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("ool/conmin.rb") def iteration_echo(m) f = m.f x = m.x printf( "f( " ); for i in 0...3 do printf( "%+6.3e, ", x[i]) end printf( "... ) = %+6.3e, ||g||=%6.3e\n", f, m.size) end NN = 100 fun = Proc.new { |x, params| n = x.size f = 0 for i in 0...n do xi = x[i] - (i.to_f+1.0)/10.0 f += (i + 1.0)*xi*xi end f } fun_df = Proc.new { |x, params, g| n = x.size for i in 0...n do xi = x[i] - (i.to_f+1.0)/10.0 g[i] = 2.0*(i+1.0)*xi end } fun_Hv = Proc.new { |x, params, v, hv| n = x.size for i in 0...n do hv[i] = 2.0*(i+1.0)*v[i] end } a = GSL::Vector.alloc(NN) for i in 0...NN do a[i] = (i.to_f + 1.0)/10.0 end f = OOL::Conmin::Function.alloc() f.set(NN, fun, fun_df, nil, fun_Hv, a) L = GSL::Vector.alloc(NN) U = GSL::Vector.alloc(NN) L.set_all(-3.0) U.set_all(3.0) c = OOL::Conmin::Constraint.alloc() c.set(NN, L, U) #m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Spg, NN) #m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Pgrad, NN) m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Gencan, NN) #m = OOL::Conmin::Minimizer.alloc("pgrad", NN) #m = OOL::Conmin::Minimizer.alloc("spg", NN) #params = OOL::Conmin::Minimizer::Spg.parameters_default params = m.parameters_default x = GSL::Vector.alloc(NN) for i in 0...NN do x[i] = 1.0 + i end m.set(f, c, x, params) ii = 0 NMAX = 1000 status = OOL::CONTINUE; printf( "%4d : ", ii ) iteration_echo ( m ) while ii < NMAX && status == OOL::CONTINUE ii+=1 m.iterate status = m.is_optimal printf( "%4d : ", ii ) iteration_echo( m ) end printf("%s method\n", m.name) if status == OOL::SUCCESS printf("\nConvergence in %i iterations\n\n", ii); else printf("Stopped with %i iterations\n", ii); end printf("variables................: %6d\n", NN) printf("function evaluations.....: %6d\n", m.fcount) printf("gradient evaluations.....: %6d\n", m.gcount) printf("function value...........: %.6e\n", m.minimum) printf("projected gradient norm..: %.6e\n", m.size) gsl-1.15.3/examples/ool/conmin.rb0000755000175000017500000000364512220252463016174 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("ool/conmin.rb") def iteration_echo(m) f = m.f x = m.x printf( "f( " ); for i in 0...3 do printf( "%+6.3e, ", x[i]) end printf( "... ) = %+6.3e\n", f ) end NN = 100 fun = Proc.new { |x, params| n = x.size f = 0 for i in 0...n do ai = params[i] xi = x[i] f += (xi - ai)*(xi - ai) end f } fun_df = Proc.new { |x, params, g| n = x.size for i in 0...n do ai = params[i] xi = x[i] g[i] = 2.0*(xi - ai) end } fun_Hv = Proc.new { |x, params, v, hv| n = x.size for i in 0...n do hv[i] = 2.0*v[i] end } a = GSL::Vector.alloc(NN) for i in 0...NN do a[i] = (i.to_f + 1.0)/10.0 end f = OOL::Conmin::Function.alloc() f.set(NN, fun, fun_df, nil, fun_Hv, a) L = GSL::Vector.alloc(NN) U = GSL::Vector.alloc(NN) L.set_all(-3.0) U.set_all(3.0) c = OOL::Conmin::Constraint.alloc() c.set(NN, L, U) m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Spg, NN) #m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Pgrad, NN) #m = OOL::Conmin::Minimizer.alloc("pgrad", NN) #m = OOL::Conmin::Minimizer.alloc("spg", NN) #params = OOL::Conmin::Minimizer::Spg.parameters_default params = m.parameters_default p params.class p params x = GSL::Vector.alloc(NN) x.set_all(1.0) m.set(f, c, x, params) ii = 0 NMAX = 10000 status = OOL::CONTINUE; printf( "%4d : ", ii ) iteration_echo ( m ) while ii < NMAX && status == OOL::CONTINUE ii+=1 m.iterate status = m.is_optimal printf( "%4d : ", ii ) iteration_echo( m ) end printf("%s method\n", m.name) if status == OOL::SUCCESS printf("\nConvergence in %i iterations\n\n", ii); else printf("Stopped with %i iterations\n", ii); end printf("variables................: %6d\n", NN) printf("function evaluations.....: %6d\n", m.fcount) printf("gradient evaluations.....: %6d\n", m.gcount) printf("function value...........: %.6e\n", m.minimum) printf("projected gradient norm..: %.6e\n", m.size) gsl-1.15.3/examples/ool/pgrad.rb0000755000175000017500000000367012220252463016004 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("ool/conmin.rb") def iteration_echo(m) f = m.f x = m.x printf( "f( " ); for i in 0...3 do printf( "%+6.3e, ", x[i]) end printf( "... ) = %+6.3e\n", f ) end NN = 100 fun = Proc.new { |x, params| n = x.size f = 0 for i in 0...n do xi = x[i] - i.to_f/10.0 f += (i + 1.0)*xi*xi end f } fun_df = Proc.new { |x, params, g| n = x.size for i in 0...n do xi = x[i] - i.to_f/10.0 g[i] = 2.0*(i+1.0)*xi end } fun_Hv = Proc.new { |x, params, v, hv| n = x.size for i in 0...n do hv[i] = 2.0*(i+1.0)*v[i] end } a = GSL::Vector.alloc(NN) for i in 0...NN do a[i] = (i.to_f + 1.0)/10.0 end f = OOL::Conmin::Function.alloc() f.set(NN, fun, fun_df, nil, fun_Hv, a) L = GSL::Vector.alloc(NN) U = GSL::Vector.alloc(NN) L.set_all(-3.0) U.set_all(3.0) c = OOL::Conmin::Constraint.alloc() c.set(NN, L, U) #m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Spg, NN) m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Pgrad, NN) #m = OOL::Conmin::Minimizer.alloc("pgrad", NN) #m = OOL::Conmin::Minimizer.alloc("spg", NN) #params = OOL::Conmin::Minimizer::Spg.parameters_default params = m.parameters_default p params.class p params x = GSL::Vector.alloc(NN) for i in 0...NN do x[i] = 1.0 + i end m.set(f, c, x, params) ii = 0 NMAX = 1000 status = OOL::CONTINUE; printf( "%4d : ", ii ) iteration_echo ( m ) while ii < NMAX && status == OOL::CONTINUE ii+=1 m.iterate status = m.is_optimal printf( "%4d : ", ii ) iteration_echo( m ) end printf("%s method\n", m.name) if status == OOL::SUCCESS printf("\nConvergence in %i iterations\n\n", ii); else printf("Stopped with %i iterations\n", ii); end printf("variables................: %6d\n", NN) printf("function evaluations.....: %6d\n", m.fcount) printf("gradient evaluations.....: %6d\n", m.gcount) printf("function value...........: %.6e\n", m.minimum) printf("projected gradient norm..: %.6e\n", m.size) gsl-1.15.3/examples/ool/spg.rb0000755000175000017500000000367012220252463015500 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("ool/conmin.rb") def iteration_echo(m) f = m.f x = m.x printf( "f( " ); for i in 0...3 do printf( "%+6.3e, ", x[i]) end printf( "... ) = %+6.3e\n", f ) end NN = 100 fun = Proc.new { |x, params| n = x.size f = 0 for i in 0...n do xi = x[i] - i.to_f/10.0 f += (i + 1.0)*xi*xi end f } fun_df = Proc.new { |x, params, g| n = x.size for i in 0...n do xi = x[i] - i.to_f/10.0 g[i] = 2.0*(i+1.0)*xi end } fun_Hv = Proc.new { |x, params, v, hv| n = x.size for i in 0...n do hv[i] = 2.0*(i+1.0)*v[i] end } a = GSL::Vector.alloc(NN) for i in 0...NN do a[i] = (i.to_f + 1.0)/10.0 end f = OOL::Conmin::Function.alloc() f.set(NN, fun, fun_df, nil, fun_Hv, a) L = GSL::Vector.alloc(NN) U = GSL::Vector.alloc(NN) L.set_all(-3.0) U.set_all(3.0) c = OOL::Conmin::Constraint.alloc() c.set(NN, L, U) m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Spg, NN) #m = OOL::Conmin::Minimizer.alloc(OOL::Conmin::Minimizer::Pgrad, NN) #m = OOL::Conmin::Minimizer.alloc("pgrad", NN) #m = OOL::Conmin::Minimizer.alloc("spg", NN) #params = OOL::Conmin::Minimizer::Spg.parameters_default params = m.parameters_default p params.class p params x = GSL::Vector.alloc(NN) for i in 0...NN do x[i] = 1.0 + i end m.set(f, c, x, params) ii = 0 NMAX = 1000 status = OOL::CONTINUE; printf( "%4d : ", ii ) iteration_echo ( m ) while ii < NMAX && status == OOL::CONTINUE ii+=1 m.iterate status = m.is_optimal printf( "%4d : ", ii ) iteration_echo( m ) end printf("%s method\n", m.name) if status == OOL::SUCCESS printf("\nConvergence in %i iterations\n\n", ii); else printf("Stopped with %i iterations\n", ii); end printf("variables................: %6d\n", NN) printf("function evaluations.....: %6d\n", m.fcount) printf("gradient evaluations.....: %6d\n", m.gcount) printf("function value...........: %.6e\n", m.minimum) printf("projected gradient norm..: %.6e\n", m.size) gsl-1.15.3/examples/jacobi/0000755000175000017500000000000012220252463015007 5ustar boutilboutilgsl-1.15.3/examples/jacobi/interp.rb0000755000175000017500000000126712220252463016646 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") if ARGV.size != 1 puts("Usage: integrate n\nn is the number of quadrature points.") exit end Q = ARGV[0].to_i if Q < 1 puts("Usage: integrate n\nn is the number of quadrature points.") exit end def fun(x) Math::cos(3.0*x) end def dfun(x) -3.0*Math::sin(3.0*x) end f = GSL::Vector.alloc(4*Q) xp = GSL::Vector.linspace(0.1, 0.9, 9) quad = Jac::Quadrature.alloc(Q) quad.zwd(Jac::GJ, 0.0, 0.0) quad.interpmat_alloc(xp) for i in 0...Q do f[i] = fun(quad.x[i]) end fout = quad.interpolate(f) printf("X \t f(x) \t Error\n"); for i in 0...xp.size do printf("%f \t %f \t %e\n", xp[i], fout[i], fout[i] - fun(xp[i])); end quad.interpmat_free gsl-1.15.3/examples/jacobi/deriv.rb0000755000175000017500000000114512220252463016451 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") if ARGV.size != 1 puts("Usage: integrate n\nn is the number of quadrature points.") exit end Q = ARGV[0].to_i if Q < 1 puts("Usage: integrate n\nn is the number of quadrature points.") exit end def fun(x) Math::cos(3.0*x) end def dfun(x) -3.0*Math::sin(3.0*x) end f = GSL::Vector.alloc(4*Q) quad = Jac::Quadrature.alloc(Q) quad.zwd(Jac::GJ, 0.0, 0.0) for i in 0...Q do f[i] = fun(quad.x[i]) end d = quad.differentiate(f) printf("X \t Derivative \t Error\n"); for i in 0...Q do printf("%f \t %f \t %e\n", quad.x[i], d[i], d[i] - dfun(quad.x[i])); end gsl-1.15.3/examples/jacobi/jacobi.rb0000755000175000017500000000030712220252463016566 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") p Jac::jacobi_P1(0.2, 0.2, 0.5) x = GSL::Vector.linspace(-1, 1, 6) p Jac::jacobi(x, 1, 0.2, 0.5) p Jac::jacobi_P1(x, 0.2, 0.5) p Jac::jacobi_zeros(6, 0.2, 0.5) gsl-1.15.3/examples/jacobi/integrate.rb0000755000175000017500000000114412220252463017321 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") if ARGV.size != 1 puts("Usage: integrate n\nn is the number of quadrature points.") exit end Q = ARGV[0].to_i if Q < 1 puts("Usage: integrate n\nn is the number of quadrature points.") exit end def fun(x) Math::cos(3.0*x) end f = GSL::Vector.alloc(4*Q) quad = Jac::Quadrature.alloc(Q) quad.zwd(Jac::GJ, 0.0, 0.0) for i in 0...Q do f[i] = fun(quad.x[i]) end integr = quad.integrate(f) exact = 2.0/3.0*Math::sin(3.0) printf("Integral of cos(3x) from -1 to 1: %f\n", exact); printf("jac_integrate result: %f\n", integr) printf("Error: %e\n", integr - exact); gsl-1.15.3/examples/pdf/0000755000175000017500000000000012220252463014331 5ustar boutilboutilgsl-1.15.3/examples/pdf/weibull.rb0000755000175000017500000000046012220252463016324 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 2, 100) y1 = GSL::Ran::weibull_pdf(x, 1, 1) y2 = GSL::Ran::weibull_pdf(x, 1, 2) y3 = GSL::Ran::weibull_pdf(x, 2, 3) GSL::graph(x, y1, y2, y3, "-T X -g 3 -C -x 0 2 -y 0 1.5 -X x -Y 'p(x)' -L 'Weibull distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/binomiral.rb0000755000175000017500000000042112220252463016632 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") pp = 0.5 nn = 9 IO.popen("graph -T X -C -g 3 -x 0 10 -y 0 0.3 -L 'Binomial Distribution, p = 0.5, n = 9'", "w") do |io| for i in 0..10 do y = GSL::Ran::binomial_pdf(i, pp, nn) io.printf("%d %e\n%d %e\n", i, y, i+1, y) end end gsl-1.15.3/examples/pdf/poisson.rb0000755000175000017500000000027512220252463016357 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector[0..10] y = GSL::Ran::poisson_pdf(x, 2.5) y.graph_step(x, "-C -X x -Y 'p(x)' -L 'Poisson distribution, mu = 2.5' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/pareto.rb0000755000175000017500000000040712220252463016154 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0, 5, n) y1 = GSL::Ran::pareto_pdf(x, 1, 1) y2 = GSL::Ran::pareto_pdf(x, 3, 2) GSL::graph(x, y1, y2, "-T X -g 3 -C -x 0 5 -y 0 2 -X x -Y 'p(x)' -L 'Pareto distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/landau.rb0000755000175000017500000000027012220252463016124 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-5, 10, 100) y1 = GSL::Ran::landau_pdf(x) y1.graph(x, "-C -X x -Y 'p(x)' -L 'Landau distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/tdist.rb0000755000175000017500000000036412220252463016013 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-4, 4, 100) y1 = GSL::Ran::tdist_pdf(x, 1) y2 = GSL::Ran::tdist_pdf(x, 5) GSL::graph(x, y1, y2, "-T X -C -g 3 -X x -Y 'p(x)' -L 'Student t distribution, n=1' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/laplace.rb0000755000175000017500000000041312220252463016260 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-5, 5, 100) y1 = GSL::Ran::laplace_pdf(x, 1) y2 = GSL::Ran::laplace_pdf(x, 2) GSL::Vector.graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -x -5 5 -L 'Laplace distribution, a = 1, 2' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/fdist.rb0000755000175000017500000000037512220252463015777 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 100 x = GSL::Vector.linspace(0.01, 6, n) y1 = GSL::Ran::fdist_pdf(x, 10, 20) y2 = GSL:Ran::fdist_pdf(x, 3, 4) GSL::graph(x, y1, y2, "-T X -g 3 -C -y 0 1 -X x -Y 'p(x)' -L 'F distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/cauchy.rb0000755000175000017500000000042012220252463016131 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-5, 5, 100) y1 = GSL::Ran::cauchy_pdf(x, 1) y2 = GSL::Ran::cauchy_pdf(x, 2) GSL::Vector.graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -x -5 5 -y 0 0.4 -L 'Cauchy distribution, a = 1, 2' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/gamma.rb0000755000175000017500000000045312220252463015745 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 5, 100) y1 = GSL::Ran::gamma_pdf(x, 1, 1) y2 = GSL::Ran::gamma_pdf(x, 2, 1) y3 = GSL::Ran::gamma_pdf(x, 3, 1) GSL::Vector.graph(x, y1, y2, y3, "-T X -C -g 3 -X x -Y 'p(x)' -L 'Gamma distribution, a = 1, 2, 3' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/logarithmic.rb0000755000175000017500000000031512220252463017162 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector[0..10] y = GSL::Ran::logarithmic_pdf(x, 0.7) y.graph_step(x, "-C -X x -Y 'p(x)' -y 0 0.7 -L 'Logarithmic distribution, p = 0.7' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/beta.rb0000755000175000017500000000042212220252463015572 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 1, 100) y1 = GSL::Ran::beta_pdf(x, 2, 2) y2 = GSL::Ran::beta_pdf(x, 4, 1) y3 = GSL::Ran::beta_pdf(x, 1, 4) GSL::graph(x, y1, y2, y3, "-T X -g 3 -C -X x -Y 'p(x)' -L 'Beta distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/lognormal.rb0000755000175000017500000000041312220252463016651 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 3, 100) y1 = GSL::Ran::lognormal_pdf(x, 0, 1) y2 = GSL::Ran::lognormal_pdf(x, 1, 1) GSL::graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -L 'Lognormal distribution, zeta=0,1, s=1' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/neg-binomiral.rb0000755000175000017500000000044712220252463017411 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") pp = 0.5 nn = 3.5 IO.popen("graph -T X -C -g 3 -x 0 10 -y 0 0.3 -L 'Negative Binomial Distribution, p = 0.5, n = 3.5'", "w") do |io| for i in 0..10 do y = GSL::Ran::negative_binomial_pdf(i, pp, nn) io.printf("%d %e\n%d %e\n", i, y, i+1, y) end end gsl-1.15.3/examples/pdf/hypergeometric.rb0000755000175000017500000000044712220252463017714 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n1 = 5 n2 = 20 t = 3 IO.popen("graph -T X -C -g 3 -x 0 10 -y 0 0.7 -L 'Hypergeometric Distribution, n1=5, n2=20, t=3'", "w") do |io| for i in 0..10 do y = GSL::Ran::hypergeometric_pdf(i, n1, n2, t) io.printf("%d %e\n%d %e\n", i, y, i+1, y) end end gsl-1.15.3/examples/pdf/bernoulli.rb0000755000175000017500000000030612220252463016653 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector[0..1] y = GSL::Ran::bernoulli_pdf(x, 0.7) y.graph_step(x, "-C -X x -Y 'p(x)' -y 0 1 -L 'Bernoulli distribution, p = 0.7' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/exponential.rb0000755000175000017500000000041712220252463017211 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(0, 3, n) y1 = GSL::Ran::exponential_pdf(x, 1) y2 = GSL::Ran::exponential_pdf(x, 2) GSL::Vector.graph(x, y1, y2, "-T X -C -g 3 -X x -Y 'p(x)' -y 0 1 -L 'Exponential distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/gumbel.rb0000755000175000017500000000040012220252463016126 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-2, 2, 100) y1 = GSL::Ran::gumbel1_pdf(x, 1, 1) y2 = GSL::Ran::gumbel2_pdf(x, 1, 1) GSL::graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -L 'Type 1, 2 Gumbel distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/chisq.rb0000755000175000017500000000044712220252463015775 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") n = 50 x = GSL::Vector.linspace(0.01, 3, n) y1 = GSL::Ran::chisq_pdf(x, 1) y2 = GSL::Ran::chisq_pdf(x, 2) y3 = GSL::Ran::chisq_pdf(x, 3) GSL::graph(x, y1, y2, y3, "-T X -g 3 -C -y 0 1 -X x -Y 'p(x)' -L 'Chi^2 distribution, dof=1,2,3' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/flat.rb0000755000175000017500000000042712220252463015612 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 5, 100) y1 = GSL::Ran::flat_pdf(x, 0.5, 2.5) y2 = GSL::Ran::flat_pdf(x, 1.2, 4.8) GSL::Vector.graph(x, y1, y2, "-T X -C -g 3 -X x -Y 'p(x)' -y 0 1 -L 'Flat distribution, a = 0.5, b = 2.5' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/gauss.rb0000755000175000017500000000043212220252463016002 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-5, 5, 100) y1 = GSL::Ran::gaussian_pdf(x, 1) y2 = GSL::Ran::gaussian_pdf(x, 2) GSL::Vector.graph(x, y1, y2, "-T X -C -g 3 -X x -Y 'p(x)' -x -5 5 -y 0 0.5 -L 'Gaussian distribution, sigma = 1, 2' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/geometric.rb0000755000175000017500000000031012220252463016631 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector[0..5] y = GSL::Ran::geometric_pdf(x, 0.5) y.graph_step(x, "-C -X x -Y 'p(x)' -y 0 0.7 -L 'Geometric distribution, p = 0.5' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/rayleigh-tail.rb0000755000175000017500000000045712220252463017422 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 5, 100) y1 = GSL::Ran::rayleigh_tail_pdf(x, 1, 1) y2 = GSL::Ran::rayleigh_tail_pdf(x, 0.5, 2) GSL::Vector.graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -x 0 5 -y 0 1.2 -L 'Rayleigh-tail distribution, a = 1, s = 1' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/logistic.rb0000755000175000017500000000040512220252463016475 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-5, 5, 100) y1 = GSL::Ran::logistic_pdf(x, 1) y2 = GSL::Ran::logistic_pdf(x, 2) GSL::graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -x -5 5 -y 0 0.3 -L 'Logistic distribution' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/rayleigh.rb0000755000175000017500000000041012220252463016460 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 5, 100) y1 = GSL::Ran::rayleigh_pdf(x, 1) y2 = GSL::Ran::rayleigh_pdf(x, 2) GSL::Vector.graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -x 0 5 -L 'Rayleigh distribution, a = 1' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/gauss-tail.rb0000755000175000017500000000034312220252463016732 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(0, 5, 100) y1 = GSL::Ran::gaussian_tail_pdf(x, 1.5, 1) y1.graph(x, "-C -X x -Y 'p(x)' -x 0 5 -L 'Gaussian-tail distribution, s = 1, a = 1.5' --toggle-rotate-y-label") gsl-1.15.3/examples/pdf/pascal.rb0000755000175000017500000000041512220252463016124 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") pp = 0.5 nn = 3 IO.popen("graph -T X -C -g 3 -x 0 10 -y 0 0.3 -L 'Pascal Distribution, p = 0.5, n = 3'", "w") do |io| for i in 0..10 do y = GSL::Ran::pascal_pdf(i, pp, nn) io.printf("%d %e\n%d %e\n", i, y, i+1, y) end end gsl-1.15.3/examples/pdf/exppow.rb0000755000175000017500000000043212220252463016202 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = GSL::Vector.linspace(-5, 5, 100) y1 = GSL::Ran::exppow_pdf(x, 1, 2.5) y2 = GSL::Ran::exppow_pdf(x, 1, 0.5) GSL::Vector.graph(x, y1, y2, "-T X -g 3 -C -X x -Y 'p(x)' -x -5 5 -L 'Exppow distribution, a = 1, b = 2.5, 0' --toggle-rotate-y-label") gsl-1.15.3/examples/histogram/0000755000175000017500000000000012220252463015555 5ustar boutilboutilgsl-1.15.3/examples/histogram/xexp.rb0000755000175000017500000000054212220252463017072 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 rng = GSL::Rng.alloc data = rng.gamma(2, 1.5, N) h = GSL::Histogram.alloc(100, [0, 15]) h.fill(data) p h.bin #result = h.fit_exponential result = h.fit("xexp") b = result[0] amp = result[1] p amp p 1.0/b x = GSL::Vector.linspace(0, 15, 100) y = amp*x*GSL::Sf::exp(-x*b) GSL::graph(h, [x, y], "-C -g 3") gsl-1.15.3/examples/histogram/rebin.rb0000755000175000017500000000054512220252463017210 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") h = GSL::Histogram.alloc(100, [-4, 4]) rng = GSL::Rng.alloc for i in 0..10000 do h.increment(rng.gaussian) end h2 = h.rebin h5 = h.rebin(5) h7 = h.rebin(7) printf("%d %d %d %d\n", h.n, h2.n, h5.n, h7.n) printf("%f %f %f %f\n", h.sigma, h2.sigma, h5.sigma, h7.sigma) GSL::graph(h, h2, h5, h7, "-T X -C -g 3 -x -4 4") gsl-1.15.3/examples/histogram/histogram-pdf.rb0000755000175000017500000000077112220252463020656 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") NDATA = 1000 NBINS = 100 MAX = 8 rng = GSL::Rng.alloc() data = GSL::Ran.gaussian(rng, 1.0, NDATA) + 2 h = GSL::Histogram.alloc(NBINS, [-MAX, MAX]) h.fill(data) hpdf = GSL::Histogram::Pdf.alloc(h) rng2 = GSL::Rng.alloc() h2 = GSL::Histogram.alloc(NBINS, [-MAX, MAX]) NDATA2 = 10000 for i in 0...NDATA2 do val = hpdf.sample(rng2.uniform()) h2.fill(val) end GSL::graph(h, h2) sum = h.sum() # NDATA sum2 = h2.sum() # NDATA2 GSL::graph(h, h2.scale(sum/sum2)) gsl-1.15.3/examples/histogram/smp.dat0000644000175000017500000000010612220252463017043 0ustar boutilboutil 0.0 20.0 1 20.0 40.0 10 40.0 60.0 15 60.0 80.0 8 80.0 100.0 2 gsl-1.15.3/examples/histogram/poisson.rb0000755000175000017500000000064312220252463017602 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") GSL::Rng.env_setup() N = 10000 rng = GSL::Rng.alloc h = GSL::Histogram.alloc(20, [0, 20]) =begin for i in 0...N do r = rng.poisson(5) # r = GSL::Ran::poisson(rng, 5) h.increment(r) end =end v = rng.poisson(5, N) h.fill(v) h.normalize! x = GSL::Vector.linspace(0, 20, 100) y = GSL::Ran::poisson_pdf(x, 5) GSL::graph(h, [x, y], "-C -g 3 -L 'Poisson distribution, mu = 5'") gsl-1.15.3/examples/histogram/integral.rb0000755000175000017500000000075212220252463017716 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 BINS = 100 rng1 = GSL::Rng.alloc(2) h = GSL::Histogram.alloc(BINS, [-5, 5]) for i in 0...N do r1 = rng1.gaussian h.increment(r1) end # Integrate: cumulative distribution hi = h.integrate a = hi.diff # Scale the histograms to ~ 1 at the maximum (to display together) h.scale!(1.0/h[BINS/2]) a.scale!(1.0/a[BINS/2]) hi.normalize! # this is equivalent to hi.scale(1.0/hi[BINS-1]) GSL::graph(h, hi,a, "-T X -C -g 3") gsl-1.15.3/examples/histogram/cauchy.rb0000755000175000017500000000100012220252463017350 0ustar boutilboutil#!/usr/bin/env ruby # Usage from command line: # % gsl-randist 0 10000 cauchy 30 | ./hist1d.rb -100 100 200 require("gsl") if ARGV.size != 3 puts("Usage: gsl-histogram xmin xmax n") puts(" Computes a histogram of the data") puts(" on stdin using n bins from xmin to xmax") end a = ARGV.shift.to_f b = ARGV.shift.to_f n = ARGV.shift.to_i h = GSL::Histogram.alloc(n, a, b) while line = STDIN.gets x = line.chomp.to_f h.increment(x) end h.graph("-C -g 3 -L 'gsl-randist 0 10000 cauchy 30'") gsl-1.15.3/examples/histogram/power.rb0000755000175000017500000000115612220252463017244 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math def ran_power_law(slope, range, rng) x = rng.uniform xmin = GSL::pow(10.0, range*(1.0 + slope)); x2 = (1 - xmin)*x + xmin; return GSL::pow(x2, 1.0/(1+slope)); end h = GSL::Histogram.alloc(19, [1, 20]) rng = GSL::Rng.alloc for i in 0..5000 x = ran_power_law(-3.2, 1000, rng) h.increment(x) end result = h.fit_power x = GSL::Vector.logspace2(1, 20, 19) y = result[0]*GSL::pow(x, result[1]) GSL::graph(h, [x, y], "-l x -l y -x 1 20 -y 1 10000 -C -g 3") puts("Expected power index: -3.2") printf("Estimated power index: %5.4f +/- %5.4f\n", result[1], result[3]) gsl-1.15.3/examples/histogram/exponential.rb0000755000175000017500000000051612220252463020435 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 rng = GSL::Rng.alloc data = rng.exponential(2, N) h = GSL::Histogram.alloc(100, [0, 15]) h.fill(data) #result = h.fit_exponential result = h.fit("exponential") a = result[0] b = result[1] x = GSL::Vector.linspace(0, 15, 100) y = a*GSL::Sf::exp(x*b) GSL::graph(h, [x, y], "-C -g 3") gsl-1.15.3/examples/histogram/cauchy.sh0000644000175000017500000000010612220252463017362 0ustar boutilboutil#!/bin/sh gsl-randist 0 10000 cauchy 30 | ruby cauchy.rb -100 100 200 gsl-1.15.3/examples/histogram/gauss.rb0000755000175000017500000000053612220252463017233 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 MAX = 8 rng = GSL::Rng.alloc(2) data = GSL::Ran.gaussian(rng, 1.5, N) + 2 h = GSL::Histogram.alloc(100, [-MAX, MAX]) h.increment(data) sigma, mean, height, = h.fit_gaussian x = GSL::Vector.linspace(-MAX, MAX, 100) y = height*GSL::Ran::gaussian_pdf(x-mean, sigma) GSL::graph(h, [x, y], "-T X -C -g 3") gsl-1.15.3/examples/histogram/histo2d.rb0000755000175000017500000000131512220252463017461 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10000 BINS = 100 rng = GSL::Rng.alloc("mt19937", 123456) h2 = GSL::Histogram2d.alloc(BINS, [-8, 8], BINS, [-8, 8]) sig1 = 0.8 sig2 = 2.0 for i in 0...N do r1 = rng.gaussian(sig1) + 2.5 r2 = rng.gaussian(sig2) - 1 h2.increment(r1, r2) end hx = h2.xproject hy = h2.yproject printf("%f %f %f %f\n", h2.xmean, h2.ymean, hx.mean, hy.mean) printf("%f %f %f %f\n", h2.xsigma, h2.ysigma, hx.sigma, hy.sigma) x = GSL::Vector.linspace(-8, 8, 100) result = hx.fit_gaussian y1 = result[2]*GSL::Ran::gaussian_pdf(x-result[1], result[0]) result = hy.fit_gaussian y2 = result[2]*GSL::Ran::gaussian_pdf(x-result[1], result[0]) GSL::graph(hx, hy, [x, y1], [x, y2], "-T X -C -g 3") gsl-1.15.3/examples/histogram/histo3d.rb0000755000175000017500000000147612220252463017472 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 5000 BINS = 50 rng = GSL::Rng.alloc(1) h = GSL::Histogram3d.alloc(BINS, [-5, 5], BINS, [-4, 8], BINS, [-8, 3]) sig1 = 1 sig2 = 2 sig3 = 1.3 for i in 0...N do r1 = rng.gaussian(sig1) + 1 r2 = rng.gaussian(sig2) + 1.5 r3 = rng.gaussian(sig3) - 2 h.increment(r1, r2, r3) end hxy = h.xyproject h1 = hxy.xproject h2 = hxy.yproject hxz = h.xzproject h3 = hxz.yproject x = GSL::Vector.linspace(-7, 7, 100) a = h1.fit_gaussian # a[0]: sigma, a[1]: mean, a[2]: height y1 = a[2]*GSL::Ran::gaussian_pdf(x-a[1], a[0]) a = h2.fit_gaussian # a[0]: sigma, a[1]: mean, a[2]: height y2 = a[2]*GSL::Ran::gaussian_pdf(x-a[1], a[0]) a = h3.fit_gaussian # a[0]: sigma, a[1]: mean, a[2]: height y3 = a[2]*GSL::Ran::gaussian_pdf(x-a[1], a[0]) GSL::graph(h1, h2, h3, [x, y1], [x, y2], [x, y3]) gsl-1.15.3/examples/histogram/gsl-histogram.rb0000755000175000017500000000141612220252463020667 0ustar boutilboutil#!/usr/bin/env ruby # This is equivalent to the gsl-histogram program require("gsl") require("getopts") getopts(nil, "DISPLAY_STATS") case ARGV.size when 2 a = ARGV[0].to_f b = ARGV[1].to_f n = (b - a).to_i when 3 a = ARGV[0].to_f b = ARGV[1].to_f n = ARGV[2].to_i else puts("Usage: : gsl-histogram.rb [--DISPLAY_STATS] xmin xmax [n]") puts("Computes a histogram of the data on stdin using n bins from xmin to xmax.") puts("If n is unspecified then bins of integer width are used.") exit end h = GSL::Histogram.alloc(n) h.set_ranges_uniform(a, b) while line = STDIN.gets x = line.chomp.split[0].to_f h.increment(x) end if $OPT_DISPLAY_STATS printf("# mean = %g\n", h.mean) printf("# sigma = %g\n", h.sigma) end h.fprintf(STDOUT, "%g", "%g") exit gsl-1.15.3/examples/histogram/histogram.rb0000755000175000017500000000046712220252463020111 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") h = GSL::Histogram.alloc(5) p h p h.size h.set_ranges([1, 5, 23, 45, 67, 89]) p h.range h.set_ranges_uniform(0.0, 100) p h.range p h.get_range(3) p h.max p h.bins p h.find(55) #File.open("smp.dat") do |f| # h.fscanf(f) #end h.fscanf("smp.dat") p h.max_val p h.max_bin gsl-1.15.3/examples/cdf.rb0000755000175000017500000000047212220252463014647 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") x = 2.0 P = GSL::Cdf::ugaussian_P(x); printf("prob(x < %f) = %f\n", x, P); Q = GSL::Cdf::ugaussian_Q(x); printf("prob(x > %f) = %f\n", x, Q); x = GSL::Cdf::ugaussian_Pinv(P); printf("Pinv(%f) = %f\n", P, x); x = GSL::Cdf::ugaussian_Qinv(Q); printf("Qinv(%f) = %f\n", Q, x); gsl-1.15.3/examples/stats/0000755000175000017500000000000012220252463014716 5ustar boutilboutilgsl-1.15.3/examples/stats/statistics.rb0000755000175000017500000000074612220252463017447 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") data = GSL::Vector[17.2, 18.1, 16.5, 18.3, 12.6] mean = data.mean() variance = data.variance() largest = data.max() smallest = data.min() printf("The dataset is %g, %g, %g, %g, %g\n", data[0], data[1], data[2], data[3], data[4]); printf("The sample mean is %g\n", mean); printf("The estimated variance is %g\n", variance); printf("The largest value is %g\n", largest); printf("The smallest value is %g\n", smallest); p data.stats_sd gsl-1.15.3/examples/stats/mean.rb0000755000175000017500000000032412220252463016165 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 100000 rng = GSL::Rng.alloc v = rng.gaussian(2, N) p v.mean p v.variance p v.sd p v.variance_m(0) p v.sd_m(0) p v.variance_with_fixed_mean(0) p v.sd_with_fixed_mean(0) gsl-1.15.3/examples/stats/test.rb0000755000175000017500000000030312220252463016221 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") v = GSL::Vector.alloc([17.2, 18.1, 16.5, 18.3, 12.6]) p GSL::Stats.mean(v) p GSL::Stats.variance(v) p GSL::Stats.sd(v) p GSL::Stats.max(v) p GSL::Stats.min(v) gsl-1.15.3/examples/poly/0000755000175000017500000000000012220252463014543 5ustar boutilboutilgsl-1.15.3/examples/poly/bell.rb0000755000175000017500000000011512220252463016006 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") for n in 0..10 p GSL::Poly.bell(n) end gsl-1.15.3/examples/poly/poly.rb0000755000175000017500000000034312220252463016056 0ustar boutilboutil#!/usr/bin/env ruby require('gsl') poly = GSL::Poly.alloc(-1, 0, 0, 0, 0, 1) w = GSL::Poly::Complex::Workspace.alloc(6) z = poly.solve(w) for i in 0...5 do printf("z%d = %+.18f %+.18f\n", i, z[i].re, z[i].im) end __END__ gsl-1.15.3/examples/poly/fit.rb0000755000175000017500000000077012220252463015661 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL x = Vector[1, 2, 3, 4, 5] y = Vector[5.5, 43.1, 128, 290.7, 498.4] coef, cov, chisq, status = Poly.fit(x, y, 3) p coef x2 = Vector.linspace(1, 5, 20) graph([x, y], [x2, coef.eval(x2)], "-C -g 3 -S 4 -X X -Y Y") # x = Vector[0, 0.3, 0.8, 1.1, 1.6, 2.3] y = Vector[0.5, 0.82, 1.14, 1.25, 1.35, 1.40] coef, cov, chisq, status = MultiFit.polyfit(x, y, 2) p coef x2 = Vector.linspace(0, 2.5, 20) graph([x, y], [x2, coef.eval(x2)], "-C -g 3 -S 4 -X X -Y Y") gsl-1.15.3/examples/poly/cheb.rb0000755000175000017500000000011512220252463015771 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") for n in 0..10 p GSL::Poly.cheb(n) end gsl-1.15.3/examples/poly/eval_derivs.rb0000755000175000017500000000046112220252463017377 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") poly = [1, 2, 3] p GSL::Poly::eval_derivs(poly, 1) # Returned Array poly = NArray[1.0, 2, 3] p GSL::Poly::eval_derivs(poly, 1) # Returned NArray poly = GSL::Poly.alloc([1, 2, 3]) # Returned GSL::Poly p GSL::Poly::eval_derivs(poly, 1) p poly.eval_derivs(1, 3) gsl-1.15.3/examples/poly/cubic.rb0000755000175000017500000000022712220252463016161 0ustar boutilboutil#!/usr/bin/env ruby require('gsl') puts("Solve x^3 - 1 == 0") puts("x = 1, (-1 +/- i sqrt(3))/2") p GSL::Poly.complex_solve_cubic(0, 0, -1) __END__ gsl-1.15.3/examples/poly/quadratic.rb0000755000175000017500000000111212220252463017043 0ustar boutilboutil#!/usr/bin/env ruby require('gsl') puts("Solve 2 - 3*x + x*x = 0") p GSL::Poly.solve_quadratic([1, -3, 2]) p GSL::Poly.solve_quadratic(1, -3, 2) z = GSL::Poly.complex_solve_quadratic(1, -3, 2) printf("%f %f\n", z[0].re, z[0].im) printf("%f %f\n", z[1].re, z[1].im) #p GSL::Poly.complex_solve_quadratic([1, -3, 2]) #z = GSL::Poly.solve([2, -3, 1]) poly = GSL::Poly.alloc(2, -3, 1) z = poly.solve printf("%f %f\n", z[0].re, z[0].im) printf("%f %f\n", z[1].re, z[1].im) z = GSL::Poly.solve([2, -3, 1]) printf("%f %f\n", z[0].re, z[0].im) printf("%f %f\n", z[1].re, z[1].im) __END__ gsl-1.15.3/examples/poly/bessel.rb0000755000175000017500000000011712220252463016347 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") for n in 0..10 p GSL::Poly.bessel(n) end gsl-1.15.3/examples/poly/hermite.rb0000755000175000017500000000012012220252463016521 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") for n in 0..10 p GSL::Poly.hermite(n) end gsl-1.15.3/examples/poly/cheb_II.rb0000755000175000017500000000012012220252463016346 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") for n in 0..10 p GSL::Poly.cheb_II(n) end gsl-1.15.3/examples/poly/demo.rb0000755000175000017500000000113012220252463016012 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL # Polynomial p(x) = 1.5-1.25x-3.75x^2+x^4 poly = Poly[1.5, -1.25, -3.75, 0, 1] # Solve the equation p(x) == 0 root = poly.solve # Vector::Complex # Extract only the real parts # (imaginary parts are zero for this case) re = root.real # Vector::View puts("p(x) = 1.5-1.25x-3.75x^2+x^4 == 0") puts("Roots are found at #{re[0]}, #{re[1]}, #{re[2]}, #{re[3]}") # Display the result x = Vector.linspace(-2.5, 2.5, 20) y = poly.eval(x) zero = Vector.calloc(4) graph([x, y], [re, zero], "-T X -C -g 3 -S 4 -X x -L 'p(x) = 1.5-1.25x-3.75x^2+x^4'") gsl-1.15.3/examples/poly/eval.rb0000755000175000017500000000131212220252463016017 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") # f(x) = 1 + 2x + 3x^3 # Evaluate at x = 2 ---> f(x) = 17 p GSL::Poly.eval([1, 2, 3], 2) p GSL::Poly.eval([1, 2, 3].to_gv, 2) p GSL::Poly.eval(NArray[1.0, 2, 3], 2) # f(1) = 6, f(2) = 17, f(3) = 34 p GSL::Poly.eval([1, 2, 3], [1, 2, 3]) p GSL::Poly.eval([1, 2, 3], [1, 2, 3].to_gv) p GSL::Poly.eval([1, 2, 3], NArray[1.0, 2, 3]) v = GSL::Vector[1, 2, 3] p GSL::Poly.eval(v, [1, 2, 3]) p GSL::Poly.eval(v, [1, 2, 3].to_gv) p GSL::Poly.eval(v, NArray[1.0, 2, 3]) v = NArray[1.0, 2, 3] p GSL::Poly.eval(v, [1, 2, 3]) p GSL::Poly.eval(v, [1, 2, 3].to_gv) p GSL::Poly.eval(v, NArray[1.0, 2, 3]) v = GSL::Vector[1, 2, 3] x = GSL::Matrix.alloc(1...9, 3, 3) p GSL::Poly.eval(v, x) gsl-1.15.3/examples/min.rb0000755000175000017500000000174512220252463014702 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") fn1 = GSL::Function.alloc { |x| Math::cos(x) + 1.0 } iter = 0; max_iter = 500 m = 2.0 # initial guess m_expected = Math::PI a = 0.0; b = 6.0 gmf = GSL::Min::FMinimizer.alloc(GSL::Min::FMinimizer::BRENT) gmf.set(fn1, m, a, b) printf("Using %s method\n", gmf.name) printf("%5s [%9s, %9s] %9s %10s %9s\n", "iter", "lower", "upper", "min", "err", "err(est)") printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", iter, a, b, m, m - m_expected, b - a) begin iter += 1 status = gmf.iterate status = gmf.test_interval(0.001, 0.0) puts("Converged:") if status == GSL::SUCCESS a = gmf.x_lower; b = gmf.x_upper m = gmf.x_minimum printf("%5d [%.7f, %.7f] %.7f %+.7f %.7f\n", iter, a, b, m, m - m_expected, b - a); end while status == GSL::CONTINUE and iter < max_iter x = GSL::Vector.linspace(0, 6, 50) mx = gmf.x_minimum min = fn1.eval(mx) GSL::graph([x, fn1.eval(x)], [GSL::Vector[mx], GSL::Vector[min]], "-C -g 3 -S 4 -m -1") gsl-1.15.3/examples/complex/0000755000175000017500000000000012220252463015227 5ustar boutilboutilgsl-1.15.3/examples/complex/set.rb0000755000175000017500000000037012220252463016352 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' a = GSL::Complex.rect(1, 2) p a a.set(5) p a a.set(3, 6) p a p a.re p a.im p a.real p a.imag p a.REAL p a.IMAG a.re = 7 p a a.im = 1 p a a.real = 4 p a a.imag = 9 p a a.set_real(2) p a a.set_imag(3) p a gsl-1.15.3/examples/complex/RC-lpf.rb0000755000175000017500000000175112220252463016646 0ustar boutilboutil#!/usr/bin/env ruby # Transfer function of a RC low-pass filter require("gsl") include GSL::CONST::NUM class RC_LPF def initialize(r, c) @r = r @c = c @fp = 1.0/(2*Math::PI*r*c) @omegap = 1.0/(r*c) puts("Pole at #{fp} Hz") end def Vout(f) if f.class == GSL::Vector out = GSL::Vector::Complex[f.size] i = 0 f.each do |freq| a = 1.0/GSL::Complex[1.0, freq/@fp] out[i] = a i += 1 end return out else 1.0/GSL::Complex(1.0, f/@fp) end end attr_reader :r, :c, :fp end # Create RC filter R = 1*KILO # 1 [kOhm] C = 1*MICRO # 1 [muF] lpf = RC_LPF.new(R, C) # Frequency, 1Hz - 10kHz, 100 divisions f = GSL::Vector.logspace2(1, 10*KILO, 100) # Transfer function tf = lpf.Vout(f) GSL::graph([f, tf.amp.dB], "-C -l x -g 3 -y -100 10 -X 'Frequency [Hz]' -Y 'dB' --toggle-rotate-y-label") GSL::graph([f, tf.phase/Math::PI], "-C -l x -g 3 -X 'Frequency [Hz]' -Y 'Phase [Pi]' --toggle-rotate-y-label") gsl-1.15.3/examples/complex/michelson.rb0000755000175000017500000000157612220252463017551 0ustar boutilboutil#!/usr/bin/env ruby # Frequency response of a Michelson interferometer # require("gsl") class Michelson CLIGHT = GSL::CONST::MKSA::SPEED_OF_LIGHT def initialize(len, wavelength) @len = len.to_f @laserfreq = 2.0*Math::PI*CLIGHT/wavelength.to_f end def response(f) if f.class != GSL::Vector; f = GSL::Vector[f]; end r = GSL::Vector::Complex[f.size] f.each_index do |i| freq = f[i] omega = 2.0*Math::PI*freq a = @len*omega/CLIGHT r[i] = 2.0*@laserfreq/omega*Math::sin(a)*GSL::Complex::exp([0, -a]) end r end attr_reader :len, :laserfreq end # 3km mi1 = Michelson.new(3000, 1e-6) # 75km mi2 = Michelson.new(75000, 1e-6) f = GSL::Vector.linspace(10, 100000, 1000) r1 = mi1.response(f).amp r2 = mi2.response(f).amp GSL::graph(f, r2/1e11, r1/1e11, "-C -g 3 -l x -l y -y 1e-2 1e2 -L 'Transfer function of Michelson interferometer'") gsl-1.15.3/examples/complex/coerce.rb0000755000175000017500000000017712220252463017024 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' a = GSL::Complex.rect(1, 2) p 2 + a p 2 - a p 2*a p a - 3 p a * 3 p 2.0/a # 0.4 - 0.8i gsl-1.15.3/examples/complex/mul.rb0000755000175000017500000000040212220252463016350 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' a = GSL::Complex.rect(1, 2) b = GSL::Complex[3, 4] p a*b # -5 + 10i p a.mul(b) p a p a.div(b) p a a *= b p a a /= b p a p a.mul(2) p a.mul_real(2) p a.div_real(2) p a.conjugate p a.inverse p 1.0/a p a.negative p -a gsl-1.15.3/examples/complex/fpmi.rb0000755000175000017500000000356412220252463016522 0ustar boutilboutil#!/usr/bin/env ruby # Frequency response of a Fabry-Perot Michelson interferometer # require("gsl") CLIGHT = GSL::CONST::MKSA::SPEED_OF_LIGHT class Michelson def initialize(len, wavelength) @len = len.to_f @laserfreq = 2.0*Math::PI*CLIGHT/wavelength.to_f end def response(f) if f.class != GSL::Vector; f = GSL::Vector[f]; end r = GSL::Vector::Complex[f.size] f.each_index do |i| freq = f[i] omega = 2.0*Math::PI*freq a = @len*omega/CLIGHT # r[i] = 2.0*@laserfreq/omega*Math::sin(a)*GSL::Complex[0, -a].exp r[i] = 2.0*@laserfreq/omega*Math::sin(a)*GSL::Complex::exp(0, -a) end r end attr_reader :len, :laserfreq end class FabryPerot # rF: Reflectance of the front mirror # rE: Reflectance of the end mirror # tF: Transmittance of the front mirror def initialize(len, wavelength, rF, rE) @len = len.to_f @laserfreq = 2.0*Math::PI*CLIGHT/wavelength.to_f @tF = Math::sqrt(1.0 - rF*rF) @rF = rF @rE = rE end def response(f) if f.class != GSL::Vector; f = GSL::Vector[f]; end r = GSL::Vector::Complex[f.size] f.each_index do |i| freq = f[i] omega = 2.0*Math::PI*freq a = 2.0*@len*omega/CLIGHT r[i] = @tF*@tF*@rE/(1.0 - @rF*@rE)/(1.0 - @rF*@rE*GSL::Complex::exp(0, -a)) end r end attr_reader :len, :laserfreq, :tF, :rF, :rE end class FPMI def initialize(len, wavelength, rF, rE) @mi = Michelson.new(len, wavelength) @fp = FabryPerot.new(len, wavelength, rF, rE) end def response(f) @mi.response(f)*@fp.response(f) end attr_reader :mi, :fp end # Fabry-Perot Michelson IFO of the same length fpmi = FPMI.new(3000, 1e-6, 0.85, 1.0) f = GSL::Vector.linspace(10, 100000, 1000) rmi = fpmi.mi.response(f).amp/1e11 rfpmi = fpmi.response(f).amp/1e11 GSL::graph(f, rmi, rfpmi, "-C -g 3 -l x -l y -y 1e-3 1e2 -L 'Red: MI 3km, Green: FPMI 3km'") gsl-1.15.3/examples/complex/complex.rb0000755000175000017500000000044112220252463017225 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' a = GSL::Complex.rect(1, 2) b = GSL::Complex[3, 4] c = GSL::Complex.alloc(5, 6) d = GSL::Complex.alloc([7, 8]) p a p b p c p d e = GSL::Complex.polar(1, Math::PI/6) p e p a.abs p a.abs2 p a.logabs p Math::log(a.abs) p e.abs p e.arg p Math::PI/6 exit gsl-1.15.3/examples/complex/functions.rb0000755000175000017500000000262212220252463017571 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math # Test GSL::Complex#sqrt z = GSL::Complex.alloc(1, 2) sqrtz = z.sqrt p sqrtz d = sqrtz*sqrtz p z == d sqrtz = GSL::Complex.sqrt(z) d = sqrtz*sqrtz p z == d # Test GSL::Complex::sqrt_real a = -2.0 c = GSL::Complex.sqrt_real(a) p GSL::equal?(a, (c*c).re) # Test GSL::Complex#exp, log p f = z.exp p GSL::Complex.exp(z) p f.log p f.log == z p z.pow(f) # [1.931e-02 1.752e-02], verified with Octave result # The results below are verified with the Octave results p GSL::Complex.sin(z) p GSL::Complex.cos(z) p GSL::Complex.tan(z) p GSL::Complex.sec(z) p GSL::Complex.csc(z) p GSL::Complex.cot(z) p GSL::Complex.arcsin(z) p GSL::Complex.arcsin_real(2) p GSL::Complex.arccos(z) p GSL::Complex.arccos_real(2) p GSL::Complex.arctan(z) p GSL::Complex.arcsec(z) p GSL::Complex.arcsec_real(2) p GSL::Complex.arccsc(z) p GSL::Complex.arccsc_real(2) p GSL::Complex.arccot(z) p GSL::Complex.sinh(z) p GSL::Complex.cosh(z) p GSL::Complex.tanh(z) p GSL::Complex.sech(z) p GSL::Complex.csch(z) p GSL::Complex.coth(z) p GSL::Complex.arcsinh(z) p GSL::Complex.arccosh(z) p GSL::Complex.arccosh_real(2) p GSL::Complex.arctanh(z) p GSL::Complex.arctanh_real(2) p GSL::Complex.arcsech(z) p GSL::Complex.arccsch(z) p GSL::Complex.arccoth(z) p 1/z p z.inverse p z.conjugate p z.negative p -z z2 = GSL::Complex.alloc(2, 3) p z*z2 p z/z2 p z - z2 p z + z2 p z + 1 p 2 + z p 2 * z p 2/z p z/2 gsl-1.15.3/examples/complex/oscillator.rb0000755000175000017500000000067612220252463017743 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") m = 1.0 k = 1.0 b = 1.0 mode = GSL::Poly.complex_solve_quadratic(m, b, k) p mode.class f = GSL::Vector.linspace(0.01, 100, 1000) p f.class tf0 = 1.0/((m*mode[0]*f + b)*mode[0]*f + k) tf1 = 1.0/((m*mode[1]*f + b)*mode[1]*f + k) p tf0.class GSL::graph(f, tf0.amp, tf1.amp, "-C -g 3 -l x -l y -L 'Transfer function: amplitude'") GSL::graph(f, tf0.phase, tf1.phase, "-C -g 3 -l x -L 'Transfer function: phase'") gsl-1.15.3/examples/complex/add.rb0000755000175000017500000000040612220252463016307 0ustar boutilboutil#!/usr/bin/env ruby require 'gsl' a = GSL::Complex.rect(1, 2) b = GSL::Complex[3, 4] p a + b p a a += b p a p a - b p a a -= b p a p a + b + a p a.add(b) p a p a.sub(b) p a p a + 5 p a.add_real(5) p a p a.sub_real(5) p a p a.add_real(6).sub_real(6) gsl-1.15.3/examples/interp/0000755000175000017500000000000012220252463015061 5ustar boutilboutilgsl-1.15.3/examples/interp/spline.rb0000755000175000017500000000060612220252463016705 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL x, y = Vector.filescan("points") #spline = Spline.alloc(Interp::CSPLINE, n) #spline.init(x, y) #spline = Spline.alloc(x, y, "cspline") #spline = Spline.alloc("cspline", x, y) spline = Spline.alloc(x, y) x2 = Vector.linspace(x[0], x[-1], 100) y2 = spline.eval(x2) graph([x, y], [x2, y2], "-C -g 3 -S 2") #p spline.name #p spline.min_size gsl-1.15.3/examples/interp/demo.gp0000644000175000017500000000057312220252463016342 0ustar boutilboutilset pointsize 2 set multiplot set xlabel 'x' set ylabel 'y' set yrange [0:14] set size 0.5, 0.5 set grid set origin 0, 0.5 set key box plot 'points' set origin 0.5, 0.5 plot 'points', 'linear.dat' w l, 'polynomial.dat' w l set origin 0, 0 plot 'points', 'cspline.dat' w l, 'cspline_periodic.dat' w l set origin 0.5, 0 plot 'points', 'akima.dat' w l, 'akima_periodic.dat' w l gsl-1.15.3/examples/interp/points0000644000175000017500000000040412220252463016316 0ustar boutilboutil0.000000e+00 1.000000e+00 1.420735e+00 1.540302e+00 2.454649e+00 1.346356e+00 3.070560e+00 2.088870e+00 3.621599e+00 3.042341e+00 4.520538e+00 5.991203e+00 5.860292e+00 5.872036e+00 7.328493e+00 7.300593e+00 8.494679e+00 8.391857e+00 9.206059e+00 9.776686e+00 gsl-1.15.3/examples/interp/interp.rb0000755000175000017500000000125512220252463016715 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL n = 10 x = Vector[n] y = Vector[n] #x = NArray.float(n) #y = NArray.float(n) File.open("data0.dat", "w") do |f| for i in 0...n do a = i.to_f x[i] = i + 0.5*Math::sin(a) y[i] = i + Math::cos(a*a) f.printf("%e %e\n", x[i], y[i]) end end interp = Interp.alloc("akima", n) interp.init(x, y) #interp = Interp.alloc(x, y) p interp.class p interp.name File.open("data1.dat", "w") do |f| xi = x[0] while xi < x[9] yi = interp.eval(x, y, xi) f.printf("%e %e\n", xi, yi) xi += 0.01 end end system("graph -T X -g 3 -C -m -1 -S 4 data0.dat -S 1 data1.dat") File.delete("data0.dat") File.delete("data1.dat") gsl-1.15.3/examples/interp/demo.rb0000755000175000017500000000154212220252463016337 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math include GSL n = 10 xa = Vector[n] ya = Vector[n] for i in 0...n do a = i.to_f xa[i] = i + 0.5*sin(a) ya[i] = i + cos(a*a) end def spline_compare(type, xa, ya, filename) n = xa.size spline = Spline.alloc(type, xa, ya) p spline.name xi = xa[0] File.open(filename, "w") do |file| while xi < xa[n-1] yi = spline.eval(xi) file.printf("%e %e\n", xi, yi) xi += 0.01 end end end types = ["linear", "polynomial", "cspline", "cspline_periodic", "akima", "akima_periodic"] types.each do |t| filename = t + ".dat" spline_compare(t, xa, ya, filename) end #puts("6 interpolation types are examined.") #puts("Try \"gnuplot -persist spline-compare.gp\"") system("gnuplot -persist demo.gp") types.each do |t| filename = t + ".dat" File.delete(filename) end gsl-1.15.3/examples/sort/0000755000175000017500000000000012220252463014547 5ustar boutilboutilgsl-1.15.3/examples/sort/heapsort.rb0000755000175000017500000000044612220252463016730 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") v = GSL::Vector.alloc(1, 2, 6, 7, 8, 9, 3, 4, 5) p v.heapsort { |a, b| b <=> a } p v p v.heapsort! { |a, b| b <=> a } p v v = GSL::Vector.alloc(1, 2, 6, 7, 8, 9, 3, 4, 5) p v.heapsort_index { |a, b| a <=> b } p GSL.heapsort(v) { |a, b| b <=> a } gsl-1.15.3/examples/sort/sort2.rb0000755000175000017500000000027412220252463016153 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") v = GSL::Vector.alloc(1, 2, 6, 7, 8, 9, 3, 4, 5) p v.smallest(5) p v.largest(3) p v.smallest_index(3) p v.largest_index(5) p v.sort p v v.sort! p v gsl-1.15.3/examples/sort/heapsort_vector_complex.rb0000755000175000017500000000042312220252463022034 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") v = GSL::Vector::Complex.alloc(5) v[0] = [1, 2] v[1] = [3, 4] v[2] = [0, 1] v[3] = [15, 3] v[4] = [5, 7] p v.heapsort { |a, b| a.abs <=> b.abs } p v.heapsort { |a, b| b.abs <=> a.abs } p GSL.heapsort(v) { |a, b| b.abs <=> a.abs } gsl-1.15.3/examples/sort/sort.rb0000755000175000017500000000050612220252463016067 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 100000 k = 5 x = GSL::Vector.alloc(N) GSL::Rng.env_setup() T = GSL::Rng::DEFAULT r = GSL::Rng.alloc(T) for i in 0...N do x[i] = r.uniform() end small = x.sort_smallest(k) printf("%d smallest values from %d\n", k, N); for i in 0...k do printf("%d: %.18f\n", i, small[i]); end gsl-1.15.3/examples/permutation/0000755000175000017500000000000012220252463016127 5ustar boutilboutilgsl-1.15.3/examples/permutation/permutation.rb0000755000175000017500000000027712220252463021034 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") p = GSL::Permutation::alloc(10) p.init p.swap(4, 7) #p p.to_a p.print #p p.inverse.to_a #p p.next.to_a #p p.next.to_a #p p.next.to_a p.printf("%u \n") gsl-1.15.3/examples/permutation/ex1.rb0000755000175000017500000000060212220252463017152 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 10 pp = GSL::Permutation.alloc(N) GSL::Rng::env_setup() r = GSL::Rng.alloc("gsl_rng_default") puts("initial permutation:") pp.init pp.fprintf(STDOUT, " %u") printf("\n") puts(" random permutation:"); r.shuffle(pp) pp.fprintf(STDOUT, " %u") printf("\n"); puts("inverse permutation:"); q = pp.inverse q.fprintf(STDOUT, " %u") printf ("\n"); gsl-1.15.3/examples/bspline.rb0000755000175000017500000000177512220252463015556 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") N = 200 NCOEFFS = 8 NBREAK = NCOEFFS - 2 GSL::Rng::env_setup() r = GSL::Rng.alloc() bw = GSL::BSpline.alloc(4, NBREAK) B = GSL::Vector.alloc(NCOEFFS) x = GSL::Vector.alloc(N) y = GSL::Vector.alloc(N) xx = GSL::Matrix.alloc(N, NCOEFFS) w = GSL::Vector.alloc(N) #printf("#m=0,S=0\n") for i in 0...N do xi = (15.0/(N-1)/1)*i yi = Math::cos(xi)*Math::exp(-0.1*xi) sigma = 0.1 dy = GSL::Ran.gaussian(r, sigma) yi += dy x[i] = xi y[i] = yi w[i] = sigma # printf("%f %f\n", xi, yi) end bw.knots_uniform(0.0, 15.0) for i in 0...N do xi = x[i] bw.eval(xi, B) for j in 0...NCOEFFS do xx[i,j] = B[j] end end c, cov, chisq = GSL::MultiFit.wlinear(xx, w, y) #printf("#m=0,S=0\n") x2 = GSL::Vector.linspace(0, 15, 150) y2 = GSL::Vector.alloc(150) x2.each_index do |i| bw.eval(x2[i], B) yi, yerr = GSL::MultiFit::linear_est(B, c, cov) y2[i] = yi # printf("%f %f\n", xi, yi) end GSL::graph([x, y], [x2, y2], "-T X -C -X x -Y y -x 0 15 -y -1 1.3") gsl-1.15.3/examples/combination.rb0000755000175000017500000000047712220252463016422 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") c = 0 printf("All subsets of {0,1,2,3} by size:\n") ; for i in 0...4 do c = GSL::Combination.calloc(4, i); begin printf("{"); c.fprintf(STDOUT, " %u"); printf(" }\n"); end while c.next == GSL::SUCCESS end p c c2 = c.clone p c2 a = c.data p a.class p a p a.print gsl-1.15.3/examples/odeiv/0000755000175000017500000000000012220252463014666 5ustar boutilboutilgsl-1.15.3/examples/odeiv/frei2.rb0000755000175000017500000000303112220252463016222 0ustar boutilboutil#!/usr/bin/env ruby # This example is taken from frei2.cpp # in "Numerische Physik" p205-206 (Springer). # # Reference: # "Numerische Physik", by Harald Wiedemann, Springer (2004) # ISBN: 3-540-40774-X # http://www.springeronline.com/sgw/cda/frontpage/0,10735,1-102-22-22345455-0,00.html require("gsl") #NMAX = 8192 NMAX = 256 psi = GSL::Vector::Complex[NMAX] dx = 0.1 dt = 0.1 n_out = 20 alpha = 1 p_0 = -0.5 dp = 2*Math::PI/dx/NMAX sum = 0.0 for n in 0...NMAX x = (n-NMAX/2) * dx psi[n] = Math::exp(-GSL::pow_2(x/alpha)/2) sum += GSL::pow_2(psi[n].re); end sum = 1.0/Math::sqrt(sum) for n in 0...NMAX x = (n-NMAX/2) * dx psi[n] *= GSL::Complex[ sum * Math::cos(p_0*x), -sum * Math::sin(p_0*x) # Imaginaerteil ] end IO.popen("graph -T X -C -g 3", "w") do |io| psi_p = psi.duplicate for n1 in 0...NMAX do x = (n1-NMAX/2) * dx io.printf("%e %e\n", x, psi[n1].abs) end io.printf("\n") psi_p.radix2_forward! t = 0.0 for n in 1..n_out do t1 = n*dt STDOUT.printf("t = %2.1f (%2d/%2d)\n", t1, n, n_out) for n1 in 0...(NMAX/2) do pp = n1*dp arg = GSL::pow_2(pp)*t1/2 psi[n1] = psi_p[n1] * GSL::Complex.polar(1, -arg) end for n1 in (NMAX/2)...NMAX do pp = (n1-NMAX)*dp arg = GSL::pow_2(pp)*t1/2 psi[n1] = psi_p[n1] * GSL::Complex.polar(1, -arg) end psi.radix2_inverse! if n%10 == 0 for n1 in 0...NMAX do x = (n1-NMAX/2) * dx io.printf("%e %e\n", x, psi[n1].abs) end io.printf("\n") end end end gsl-1.15.3/examples/odeiv/sedov.rb0000755000175000017500000000545512220252463016347 0ustar boutilboutil#!/usr/bin/env ruby # Self-similar solution of the Sedev-Taylor equation, # which describes spherically expanding gas # triggered by a supernova explosion. require("gsl") include Math # Sedov-Taylor equation # logx: (log of) the radial coordinate in the gas shpere, x = r/R. # logx = 0 at the surface, and negative within the shell # y: GSL::GSL::Vector::View::ReadOnly # y[0]: gas velocity at the radius # y[1]: density # y[2]: pressure # dydlogx: GSL::GSL::Vector::View, derivatives # sh: specific heat of the gas (5/3) Sedov = Proc.new { |logx, y, dydlogx, sh| a = -5.0*(6.0*y[2] - 15.0*y[2]*y[0]*sh + 2.0*y[0]*y[1] - 7.0*y[0]*y[0]*y[1] + 5.0*GSL::pow_3(y[0])*y[1]) b = -25.0*y[2]*sh + 4.0*y[1] - 20.0*y[0]*y[1] + 25.0*y[0]*y[0]*y[1] dydlogx[0] = a/b bb = -5.0*(6.0*y[2] - 15.0*y[2]*y[0]*sh + 2.0*y[0]*y[1] - 7.0*y[0]*y[0]*y[1]) a = -5.0*(-30.0*y[2]*y[1] + 2.0*y[0]*y[1]*y[1] - 25.0*GSL::pow_2(y[0]*y[1]) + 50.0*GSL::pow_3(y[0])*GSL::pow_2(y[1])) bb = (-2.0 + 5.0*y[0])*(-25.0*y[2]*sh + 4.0*y[1] - 20.0*y[0]*y[1] + 25.0*y[0]*y[0]*y[1]) dydlogx[1] = a/bb a = -5.0*y[2]*(-10.0*y[2]*sh + 4.0*y[1] - 14.0*y[0]*y[1] + 10.0*y[0]*y[0]*y[1] - y[0]*sh*y[1] + 10.0*y[0]*y[0]*sh*y[1]) dydlogx[2] = a/b } DIM = 3 sh = 5.0/3.0 solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-5, 1e-5], Sedov, nil, DIM) solver.set_params(sh) def boundary_condition(sh) delta = 2.0/5.0 xx = 1 y = GSL::Vector[DIM] y[0] = 2.0/(sh + 1.0)*delta y[1] = (sh + 1.0)/(sh - 1.0) y[2] = 2.0/(sh + 1.0)*delta*delta y00 = xx*y[0] y10 = y[1] y20 = xx*xx*y[2] c = adiabatic_integ(xx, y, sh); return y, y00, y10, y20, c end def adiabatic_integ(xx, y, sh) GSL::pow(y[1], 1.0 - sh)*y[2]*(y[0] - 2.0/5.0)*GSL::pow_5(xx) end # y: GSL::Vector (velocity, density, pressure) # y00, y10, y20: initial values # c: adiabatic integral (this must be constant throughout the computation) y, y00, y10, y20, c = boundary_condition(sh) # x: the radial coordinates in the shell, x = r/R. # x = 1 at the surface (r = R), and zero at the center (r = 0) x = 1 logx = log(x) logxend = log(1e-5) h = -0.000001 N = 150 R = GSL::Vector[N] V = GSL::Vector[N] RHO = GSL::Vector[N] PRESS = GSL::Vector[N] # The values are normalized to [0, 1] R[0] = x V[0] = x*y[0]/y00 RHO[0] = y[1]/y10 PRESS[0] = x*x*y[2]/y20 GSL::ieee_env_setup() n = 1 while logx > logxend logx, h, status = solver.apply(logx, logxend, h, y) break if status != GSL::SUCCESS break if y[0] < 0.0 x = exp(logx) c = adiabatic_integ(x, y, sh); R[n] = x V[n] = x*y[0]/y00 RHO[n] = y[1]/y10 PRESS[n] = x*x*y[2]/y20 n += 1 end GSL::graph(R.subvector(n), V.subvector(n), RHO.subvector(n), PRESS.subvector(n), "-T X -C -g 3 -X 'x = r/R' -S 4 -L 'red: v, green: rho, blue: p'") gsl-1.15.3/examples/odeiv/binarysystem.rb0000755000175000017500000000573512220252463017761 0ustar boutilboutil#!/usr/bin/env ruby # 19/Apr/2004 by Yoshiki Tsunesada # # This is an example to calculate the orbital evolution of # a double neutron star (binary) system. General relativity predicts # that the binary orbital decays by radiating gravitational waves, # and the two stars will coalesce in time scale of 100-1000 Mega-years. # The values used here are of the binary system J0730-3039 discovered # in 2003 (Burgay et al., Nature 2003). The result shows that the two # neutron stars will merge after about 85 Mega-years. From the age of # the system 100 Mega-year, the lifetime of the system is estimated # about 185 Mega-years. # # References: # 1. Burgay et al., Nature 426, 531 (2003) # 2. Shapiro & Teukolsky, "Black holes, white dwarfs and neutron stars" # John Wiley and Sans (1983) # require("gsl") include Math class BinarySystem def initialize(m1, m2) @m1 = m1 @m2 = m2 end attr_reader :m1 attr_reader :m2 end GMsolarC3 = 4.925490947e-6 MegaYear = 3600*24*365*1e6 # Time evolution of the binary orbital period and the eccentricity # due to gravitational radiation. # The calculation is based on general relativity (See e.g. Ref.2). # y[0]: orbital period (pb) # y[1]: eccentricity (e) # dydt[0]: time derivative of pb # dydt[1]: time derivative of e deriv = Proc.new { |t, y, dydt, binary| pb = y[0] # orbital period e = y[1] # eccentricity m1 = binary.m1 # neutron star masses m2 = binary.m2 totalM = m1 + m2 # total mass mu = m1*m2/totalM # reduced mass mm = mu*GSL::pow(totalM, 2.0/3.0) f_e = GSL::pow(1.0 - e*e, -3.5)*(1.0 + (73.0/24.0 + 37.0/96.0*e*e)*e*e); h_e = (1.0 + 121.0/304.0*e*e)*GSL::pow(1.0 - e*e, -2.5) tmp = GSL::pow(GMsolarC3*2.0*PI/pb, 5.0/3.0) dydt[0] = -192.0*PI/5.0*f_e*tmp*mm # dP/dt dydt[1] = -304.0/15.0*e*h_e*tmp*(2.0*PI/pb) # de/dt } # Neutron star masses in solar-mass unit. # The values are of the binary system J0730-3039 discoverd in 2003. # See Burgay et al., Nature 426, 531 (2003) m1 = 1.34 m2 = 1.24 #m1 = 1.25 #m2 = 2.574 - m1 binary = BinarySystem.new(m1, m2) # Initial data: the present values pb = 2.45*3600 # orbital period: 2.45 hours at present ecc = 0.088 # eccentricity #pb = 7.67*3600 #ecc = 0.181 y = GSL::Vector[pb, ecc] # ODE solver using RKF45 algorithm solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], deriv, 2) solver.set_params(binary) # the age of the binary system from birth age = 100*MegaYear #age = 444*MegaYear t = 0 tend = 2500*MegaYear # initial time step h = 1.0*MegaYear begin file = File.open("binarysystem.dat", "w") while t < tend t, h, status = solver.apply(t, tend, h, y) break if status != GSL::SUCCESS break if GSL::isnan?(y[0]) file.printf("%e %e %e %e\n", (t+age)/MegaYear, y[0]/3600, y[1], h/MegaYear) end ensure file.close end system("gnuplot -persist binarysystem.gp") File.delete("binarysystem.dat") __END__ gsl-1.15.3/examples/odeiv/binarysystem.gp0000644000175000017500000000120712220252463017747 0ustar boutilboutilset title 'Orbital decay of the binary system J0730-3039' set xlabel 'Time since birth [Myr]' set ylabel 'Orbital Period [Hr]' set y2label 'Eccentricity' set grid set yrange [1e-2:10] set xrange [90:200] set y2range [1e-4:1e-1] #set xrange [90:2500] #set y2range [1e-4:2e-1] set ytics nomirror set y2tics set logscale y set logscale y2 set pointsize 1 set label 1 'Present' at first 96, 0.04 set label 2 'Plunge!' at first 150, 0.04 set arrow from 100,0.03 to 100,0.013 lw 2 lt 3 set arrow from 160, 0.035 to 182, 0.011 lw 2 lt 4 plot 'binarysystem.dat' u 1:2 title 'Orbital period' w lp lw 1, '' u 1:3 axes x1y2 title 'Eccentricity' w lp lw 1 gsl-1.15.3/examples/odeiv/demo.gp0000644000175000017500000000122212220252463016137 0ustar boutilboutilset multiplot set grid set size 0.33, 0.33 set origin 0, 0.66 plot 'rk2.dat' title 'rk2', exp(-2*x) set origin 0.33, 0.66 plot 'rk4.dat' title 'rk4', exp(-2*x) set origin 0.66, 0.66 plot 'rkf45.dat' title 'rkf45', exp(-2*x) set origin 0, 0.33 plot 'rkck.dat' title 'rkck', exp(-2*x) set origin 0.33, 0.33 plot 'rk8pd.dat' title 'rk8pd', exp(-2*x) set origin 0.66, 0.33 plot 'rk2imp.dat' title 'rk2imp', exp(-2*x) set origin 0, 0 plot 'rk4imp.dat' title 'rk4imp', exp(-2*x) set origin 0.33, 0 plot 'bsimp.dat' title 'bsimp', exp(-2*x) set origin 0.66, 0 plot 'gear1.dat' title 'gear1', exp(-2*x) #set origin 0.5, 0 #plot 'gear2.dat' title 'gear2', exp(-2*x) gsl-1.15.3/examples/odeiv/frei1.rb0000755000175000017500000000552612220252463016234 0ustar boutilboutil#!/usr/bin/env ruby # Solve Schroedinger equation # # This example is taken from frei1.cpp # in "Numerische Physik" p201-204 (Springer), # which simulates the time evolution of a probability density. # # Name: frei1.cpp # Zweck: Simuliert ein quantenmechanisches freies Teilchen # Gleichung: Schroedingergleichung ohne Potential verwendete # Bibiliothek: GSL # # Reference: # "Numerische Physik", by Harald Wiedemann, Springer (2004) # ISBN: 3-540-40774-X # http://www.springeronline.com/sgw/cda/frontpage/0,10735,1-102-22-22345455-0,00.html require("gsl") #NMAX = 8192 NMAX = 256 # The wave equation: # calculate time derivative of the wave function. # The second spatial derivative is approximated by # d2_psi/dx2 ~ (psi[n+1] - 2*psi[n] + pxi[n-1])/(dx*dx) # See "Numerische Physik" p204, Eq. (5.47). # # psi(x), dpsi_dt(x): Complex-valued wavefunction, expressed as # # 0 NMAX 2*NMAX # |-----------------|-----------------| # Real Imaginary # f = Proc.new { |t, psi, dpsi_dt| dx2 = $dx*$dx # Real part for n in 1...(NMAX-1) do dpsi_dt[n] = -(psi[NMAX+n+1]+psi[NMAX+n-1]-2*psi[NMAX+n])/dx2 end dpsi_dt[0] = -(psi[NMAX+1]+psi[2*NMAX-1]-2*psi[NMAX])/dx2 dpsi_dt[NMAX-1] = -(psi[NMAX]+psi[2*NMAX-2]-2*psi[2*NMAX-1])/dx2 # Imaginary part for n in (NMAX+1)...(2*NMAX-1) do dpsi_dt[n] = +(psi[n+1-NMAX]+psi[n-1-NMAX]-2*psi[n-NMAX])/dx2 end dpsi_dt[NMAX] = +(psi[1]+psi[NMAX-1]-2*psi[0])/dx2 dpsi_dt[2*NMAX-1] = +(psi[0]+psi[NMAX-2]-2*psi[NMAX-1])/dx2 } psi = GSL::Vector[2*NMAX] dpsi_dt = GSL::Vector[2*NMAX] $dx = 0.1 dt = 0.1 n_out = 20 alpha = 1 p_0 = -0.5 atol = 1e-4 rtol = 0.0 h = 1.0e-4 dx2 = $dx*$dx sum = 0.0 for n in 0...NMAX do x = (n-NMAX/2) * $dx psi[n] = Math::exp(-GSL::pow_2(x/alpha)/2) sum += GSL::pow_2(psi[n]) end sum = 1.0/Math::sqrt(sum) for n in 0...NMAX do x = (n-NMAX/2) * $dx psi[n+NMAX] = -psi[n] * sum * Math::sin(p_0*x) # Imaginaerteil psi[n] = psi[n] * sum * Math::cos(p_0*x) # Realteil end IO.popen("graph -T X -C -g 3", "w") do |io| for n1 in 0...NMAX do x = (n1-NMAX/2) * $dx io.printf("%e %e\n", x, Math::sqrt(GSL::pow_2(psi[n1]) + GSL::pow_2(psi[n1+NMAX]))) end io.printf("\n") step = GSL::Odeiv::Step.alloc(GSL::Odeiv::Step::RKF45, 2*NMAX) c = GSL::Odeiv::Control.y_new(atol, rtol) evolve = GSL::Odeiv::Evolve.alloc(2*NMAX) sys = GSL::Odeiv::System.alloc(f, 2*NMAX) t = 0.0 for n in 1..n_out do t1 = n*dt STDOUT.printf("t = %2.1f (%2d/%2d)\n", t1-dt, n, n_out) while t < t1 t, h, status = evolve.apply(c, step, sys, t, t1, h, psi) break if status != GSL::SUCCESS end if n%10 == 0 for n1 in 0...NMAX do x = (n1-NMAX/2) * $dx io.printf("%e %e\n", x, Math::sqrt(GSL::pow_2(psi[n1]) + GSL::pow_2(psi[n1+NMAX]))) end io.printf("\n") end end end gsl-1.15.3/examples/odeiv/whitedwarf.gp0000644000175000017500000000211312220252463017357 0ustar boutilboutil#set terminal postscript eps enhanced color #set output 'whitedwarf.eps' set multiplot set size 0.5, 0.5 set grid set origin 0, 0.5 #set xlabel 'r/R' #set ylabel '{/Symbol r}/{/Symbol r}_c' set xlabel 'Radius (normalized)' set ylabel 'Density (normalized)' set xrange [0:1] plot 'polytrope.dat' u ($1/6.8969):4 title 'Density Dist' w l lt 1 lw 5 set origin 0.5, 0.5 set logscale x set xrange [1e6:1e11] #set xlabel '{/Symbol r}_c [g/cm^3]' set xlabel 'Central Density [g/cm^3]' set ylabel 'Radius [km]' #plot 'whitedwarf.dat' u 1:3 title '{/Symbol r}_c - Radius' w l lw 5 plot 'whitedwarf.dat' u 1:3 title 'Central Density - Radius' w l lt 2 lw 5 set origin 0, 0 set logscale x set xrange [1e6:1e11] set yrange [0.5:1.6] #set xlabel '{/Symbol r}_c [g/cm^3]' set xlabel 'Central Density [g/cm^3]' set ylabel 'WD Mass [Msolar]' plot 'whitedwarf.dat' u 1:4 title 'Central Density - Mass' w l lt 3 lw 5 set origin 0.5, 0 unset logscale x set xrange [0.5:1.5] set yrange [100:25000] set xlabel 'Mass [Msolar]' set ylabel 'Radius [km]' plot 'whitedwarf.dat' u 4:3 title 'Mass - Radius' w l lt 4 lw 5 gsl-1.15.3/examples/odeiv/odeiv.rb0000755000175000017500000000134612220252463016330 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") dim = 2 func = Proc.new { |t, y, dydt, mu| dydt[0] = y[1] dydt[1] = -y[0] - mu*y[1]*(y[0]*y[0] - 1.0) } step = GSL::Odeiv::Step.alloc(GSL::Odeiv::Step::RKF45, dim) c = GSL::Odeiv::Control.y_new(1e-6, 0.0) evolve = GSL::Odeiv::Evolve.alloc(dim) sys = GSL::Odeiv::System.alloc(func, dim) mu = 10.0 sys.set_params(mu) t = 0.0; tend = 100.0 h = 1e-6 y = GSL::Vector[1.0, 0.0] GSL::ieee_env_setup() N = 1500 tt = GSL::Vector[N] yt = GSL::Vector[N] i = 0 while t < tend and i < N t, h, status = evolve.apply(c, step, sys, t, tend, h, y) tt[i] = t yt[i] = y[0] break if status != GSL::SUCCESS i += 1 end yt.subvector(i).graph(tt.subvector(i), "-T X -C -g 3 -x 0 #{tt.max} -L '#{step.name}' -S 4") gsl-1.15.3/examples/odeiv/demo2.gp0000644000175000017500000000132512220252463016225 0ustar boutilboutilset multiplot set grid set size 0.33, 0.25 set origin 0, 0.75 plot 'rk2.dat' title 'rk2', exp(-2*x) set origin 0.33, 0.75 plot 'rk4.dat' title 'rk4', exp(-2*x) set origin 0.66, 0.75 plot 'rkf45.dat' title 'rkf45', exp(-2*x) set origin 0, 0.5 plot 'rkck.dat' title 'rkck', exp(-2*x) set origin 0.33, 0.5 plot 'rk8pd.dat' title 'rk8pd', exp(-2*x) set origin 0.66, 0.5 plot 'rk2imp.dat' title 'rk2imp', exp(-2*x) set origin 0, 0.25 plot 'rk4imp.dat' title 'rk4imp', exp(-2*x) set origin 0.33, 0.25 plot 'bsimp.dat' title 'bsimp', exp(-2*x) set origin 0.66, 0.25 plot 'gear1.dat' title 'gear1', exp(-2*x) set origin 0, 0 plot 'gear2.dat' title 'gear2', exp(-2*x) set origin 0.33, 0 plot 'rk2simp.dat' title 'rk2simp', exp(-2*x) gsl-1.15.3/examples/odeiv/whitedwarf.rb0000755000175000017500000001015712220252463017366 0ustar boutilboutil#!/usr/bin/env ruby # This example solves Lane-Emden equation to calculate white dwarf # structure, using Chandrasekhar's model, as a polytrope gas sphere # of self-gravitating body supported by eletron degeneration pressure. require("gsl") include Math include GSL::CONST::CGSM include GSL::Odeiv # Degenerated electron/neutron gas # Reference: "Black holes, white dwarfs, and neutron stars" # S.L. Shapiro & S.A. Teukolsky, Willey, 1983 module Degenerate hbar = PLANCKS_CONSTANT_HBAR # Planck's constant me = MASS_ELECTRON # Electron mass mn = MASS_NEUTRON # Neutron mass mu = UNIFIED_ATOMIC_MASS c = SPEED_OF_LIGHT ELambda = hbar/me/c # Compton length of electron NLambda = hbar/mn/c MeC2 = me*c*c # Electron rest mass energy MnC2 = mn*c*c Factor_xe = GSL::pow(3.0*PI*PI/mu, 1.0/3.0)*ELambda Factor_xn = GSL::pow(3.0*PI*PI/mu, 1.0/3.0)*NLambda # See Shapiro&Teukolsky Chapter 2 def phi(x) tmp = sqrt(1.0 + x*x) (x*tmp*(2.0*x*x/3.0 - 1.0) + log(x + tmp))/8/PI/PI end def chi(x) tmp = sqrt(1.0 + x*x) (x*tmp*(1.0 + 2*x*x) - log(x + tmp))/8/PI/PI end def xe_rho_mue(rho, mue) Factor_xe*GSL::pow(rho/mue, 1.0/3.0) end def xn_rho(rho) Factor_xn*GSL::pow(rho, 1.0/3.0) end end # Polytrope gas sphere module Polytrope # Lane-Emden equation # n: polytrope index EmdenEq = Proc.new { |x, y, dydx, n| dydx[0] = y[1] dydx[1] = -GSL::pow(y[0], n) - 2.0/x*y[1] } def emden_xi(n) dim = 2 y = GSL::Vector[1.0, 0.0] dydx = GSL::Vector.alloc(dim) solver = Solver.alloc(Step::RKF45, [1e-6, 0], EmdenEq, dim) solver.set_params(n) solver.reset vx = GSL::Vector.alloc(10000) vy = GSL::Vector.alloc(10000) vdy = GSL::Vector.alloc(10000) x = 0.0001 xend = 10.0 h = 1e-6 file = File.open("polytrope.dat", "w") i = 0 while x < xend x, h, status = solver.apply(x, xend, h, y) break if GSL::isnan?(y[0]) break if GSL::isnan?(y[1]) vx[i] = x vy[i] = y[0] vdy[i] = y[1] file.printf("%e %e %e %e\n", x, y[0], y[1], GSL::pow_3(y[0])) i += 1 break if status != GSL::SUCCESS break if y[0] <= -0.1 end file.close # p vx.size # p i vx2 = vx.subvector(0, i) vy2 = vy.subvector(0, i) vdy2 = vdy.subvector(0, i) spline = GSL::Spline.alloc(GSL::Interp::AKIMA, i) spline.init(vy2.reverse, vx2.reverse) # Find star surface: # Star sufrace is defined as the zero point of density structure function x1 = spline.eval(0.0) spline.init(vx2, vdy2) yx2 = spline.eval(x1).abs return [x1, yx2*x1*x1] end end # Chandrasekhar white dwarf model: # * Polytrope gas sphere # * Support its self gravity by electron degeneration pressure class WhiteDwarf include Degenerate include Polytrope G = GRAVITATIONAL_CONSTANT @@x1 = nil @@x12 = nil def initialize(n, rhoc, mue) @n = n @gam = 1.0 + 1.0/n @rhoc = rhoc @mue = mue x = xe_rho_mue(@rhoc, mue) phix = phi(x) @K = MeC2*phix/GSL::pow_3(ELambda)/GSL::pow(@rhoc, @gam) @a = sqrt((@n + 1)*@K*GSL::pow(@rhoc, 1.0/@n - 1.0)/4/PI/G) if !@@x1 @@x1, @@x12 = emden_xi(@n) end @Pc = MeC2*phix/GSL::pow_3(ELambda)*phix # Electron Fermi pressure @radius = @a*@@x1 # White dwarf radius @mass = 4.0*PI*GSL::pow_3(@a)*@rhoc*@@x12 # White dwarf mass end attr_accessor :radius attr_accessor :mass attr_accessor :rhoc # Central density attr_accessor :Pc # Central pressure attr_accessor :gam # Adiabatic index attr_accessor :n # Polytrope index attr_accessor :mue # Mean eletron number per barion attr_accessor :K # Normalization constant attr_accessor :a end file = File.open("whitedwarf.dat", "w") rho = 1e6 # central density while rho < 1e11 wd = WhiteDwarf.new(3, rho, 2) file.printf("%e %e %e %e\n", rho, wd.Pc, wd.radius/1000/100, wd.mass/SOLAR_MASS) rho *= 1.2 end file.close system("gnuplot -persist whitedwarf.gp") File.delete("polytrope.dat") File.delete("whitedwarf.dat") gsl-1.15.3/examples/odeiv/legendre.rb0000755000175000017500000000212012220252463016776 0ustar boutilboutil#!/usr/bin/env ruby # # Solve Legendre's differential equation # l = 2, m = 1 require("gsl") dim = 2 fleg = Proc.new { |x, y, f, params| l = params[0] m = params[1] f[0] = y[1] f[1] = 2.0*x/(1-x*x)*y[1] - (l*(l + 1) - m*m/(1-x*x))/(1-x*x)*y[0] } solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], fleg, dim) # P21 l = 2 m = 1 solver.set_params(l, m) x = 0.0 # initial position xend = 0.999 hstart = 1e-8 h = hstart*1.0 # Initial conditions, at x = 0 # P21(0) = 0, P21'(0) = 3 y = GSL::Vector.alloc(0.0, 3.0) File.open("legode.dat", "w") do |f| while x < xend x, h, status = solver.apply(x, xend, h, y) f.printf("%g %g\n", x, y[0]) break if status != GSL::SUCCESS end end File.open("plm.dat", "w") do |f| x = 0.0 while x < xend plmx = GSL::Sf::legendre_Plm(l, m, x).abs f.printf("%g %g\n", x, plmx) x += 0.01 end end system("graph -T X -C -g 3 -X x -Y 'P21(x)' --toggle-rotate-y-label --title-font-size 0.05 -L 'Red: expect, Green: RKF45' -m 1 plm.dat -m -2 -S 4 legode.dat") File.delete("legode.dat") File.delete("plm.dat") gsl-1.15.3/examples/odeiv/odeiv2.rb0000755000175000017500000000241612220252463016411 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") dim = 2 func = Proc.new { |t, y, dydt, mu| dydt[0] = y[1] dydt[1] = -y[0] - mu*y[1]*(y[0]*y[0] - 1.0) } jac = Proc.new { |t, y, dfdy, dfdt, mu| dfdy[0,0] = 0.0 dfdy[0,1] = 1.0 dfdy[1,0] = -2*mu*y[0]*y[1] - 1.0 dfdy[1,1] = -mu*(y[0]*y[0] - 1.0) dfdt[0] = 0.0 dfdt[1] = 0.0 } #solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0, 1, 0], func, jac, dim) #solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0, 1, 0], func, nil, dim) #solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0], func, nil, dim) #solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], func, jac, dim) #solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], func, nil, dim) solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::BSIMP, [1e-6, 0.0], func, jac, dim) solver.set_params(10.0) t = 0.0; tend = 100.0 h = 1e-6 y = GSL::Vector.alloc([1.0, 0.0]) GSL::ieee_env_setup() N = 1500 tt = GSL::Vector[N] yt = GSL::Vector[N] i = 0 while t < tend and i < N t, h, status = solver.apply(t, tend, h, y) break if status != GSL::SUCCESS tt[i] = t yt[i] = y[0] i += 1 end GSL::graph(tt.subvector(i), yt.subvector(i), "-T X -C -g 3 -x 0 #{tt.max} -L '#{solver.step.name}' -S 4") gsl-1.15.3/examples/odeiv/demo.rb0000755000175000017500000000300712220252463016142 0ustar boutilboutil#!/usr/bin/env ruby # Solve # dydt = -2y ---> y(t) = exp(-2t) require("gsl") include GSL::Odeiv dim = 1 PARAM = 2.0 func = Proc.new { |t, y, dydt, param| dydt[0] = -param*y[0] } jac = Proc.new { |t, y, dfdy, dfdt, param| dfdy = -param dfdt[0] = 0.0 } def odeiv_compare_algorithm(solver, steptype, t0, tend, h0, y0, outfile) t = t0*1.0 h = h0*1.0 y = GSL::Vector.alloc([y0]) s = Step.alloc(steptype, solver.dim) solver.set_step(s) solver.evolve.reset # p solver.params i = 0 file = File.open(outfile, "w") while t < tend t, h, status = solver.apply(t, tend, h, y) break if status != GSL::SUCCESS file.printf("%.5e %.5e %.5e\n", t, y[0], h) i += 1 end file.close return i end if GSL::VERSION >= "1.5.90" ALGORITHMS = ["rk2", "rk4", "rkf45", "rkck", "rk8pd", "rk2imp", "rk4imp", "bsimp", "gear1", "gear2", "rk2simp"] gpfile = "demo2.gp" else ALGORITHMS = ["rk2", "rk4", "rkf45", "rkck", "rk8pd", "rk2imp", "rk4imp", "bsimp", "gear1", "gear2"] gpfile = "demo.gp" end solver = Solver.alloc(Step::RKF45, [1e-6, 0.0], func, jac, dim) solver.set_params(PARAM) puts("Solve dydt = -2y, y[0] = 1") puts("y(t) = exp(-2t)\n\n") ALGORITHMS.each do |alg| outfile = alg + ".dat" t0, tend, h0, y0 = 0.0, 3.0, 1e-6, 1.0 i = odeiv_compare_algorithm(solver, alg, t0, tend, h0, y0, outfile) printf("%7s: Iteration %5d\n", alg, i) end system("gnuplot -persist #{gpfile}") ALGORITHMS.each do |alg| outfile = alg + ".dat" File.delete(outfile) end gsl-1.15.3/examples/odeiv/duffing.rb0000755000175000017500000000155512220252463016646 0ustar boutilboutil#!/usr/bin/env ruby # # Duffing equation # require("gsl") dim = 2 # x'' + a x' + bx^3 = f cos(omega t) # duffing = Proc.new { |t, x, dxdt, params| a = params[0]; b = params[1] omega = params[2]; f = params[3] dxdt[0] = x[1] dxdt[1] = -a*x[1] - b*GSL::pow_3(x[0]) + f*Math::cos(omega*t) } solver = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RK8PD, [1e-6, 0.0], duffing, dim) a = 0.05 b = 1.0 omega = 1.0 f = 5.0 solver.set_params(a, b, omega, f) t = 0.0 # initial position tend = 200 hstart = 2.0*Math::PI/1000 h = hstart*1.0 # Initial conditions, at x = 0 # P21(0) = 0, P21'(0) = 3 x = GSL::Vector.alloc(0.0, 0.0) count = 0 IO.popen("graph -T X -C -g 3", "w") do |io| while t < tend t, h, status = solver.apply(t, tend, h, x) if count%2 == 0 io.printf("%g %g\n", t, x[0]) end break if status != GSL::SUCCESS count += 1 end end gsl-1.15.3/examples/odeiv/oscillator.rb0000755000175000017500000000146712220252463017401 0ustar boutilboutil#!/usr/bin/env ruby # An oscillator # m: mass # k: spring constant # b: resist # f: external force require("gsl") dim = 2 # x[0]: displacement, x[1]: velocity func = Proc.new { |t, x, dxdt, params| m = params[0]; b = params[1]; f = params[2]; k = params[3] dxdt[0] = x[1] dxdt[1] = (f - b*x[1] - k*x[0])/m } gos = GSL::Odeiv::Solver.alloc(GSL::Odeiv::Step::RKF45, [1e-6, 0.0], func, dim) m = 1.0 b = 1.0 f = 1.0 k = 10.0 gos.set_params(m, b, f, k) t = 0.0; tend = 10.0 h = 1e-6 x = GSL::Vector.alloc([0.0, 0.0]) GSL::ieee_env_setup() IO.popen("graph -T X -C -g 3 -S 4 -X Time -Y Amp", "w") do |io| while t < tend t, h, status = gos.apply(t, tend, h, x) break if status != GSL::SUCCESS # printf("%.5e %.5e %.5e %.5e\n", t, x[0], x[1], h) io.printf("%.5e %.5e\n", t, x[0]) end end gsl-1.15.3/ext/0000755000175000017500000000000012220252463012542 5ustar boutilboutilgsl-1.15.3/ext/sf_fermi_dirac.c0000644000175000017500000001355212220252463015650 0ustar boutilboutil/* sf_fermi_dirac.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_fermi_dirac_m1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_fermi_dirac_m1, x); } static VALUE rb_gsl_sf_fermi_dirac_m1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_fermi_dirac_m1_e, x); } static VALUE rb_gsl_sf_fermi_dirac_0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_fermi_dirac_0, x); } static VALUE rb_gsl_sf_fermi_dirac_0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_fermi_dirac_0_e, x); } static VALUE rb_gsl_sf_fermi_dirac_1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_fermi_dirac_1, x); } static VALUE rb_gsl_sf_fermi_dirac_1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_fermi_dirac_1_e, x); } static VALUE rb_gsl_sf_fermi_dirac_2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_fermi_dirac_2, x); } static VALUE rb_gsl_sf_fermi_dirac_2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_fermi_dirac_2_e, x); } static VALUE rb_gsl_sf_fermi_dirac_int(VALUE obj, VALUE j, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_fermi_dirac_int, j, x); } static VALUE rb_gsl_sf_fermi_dirac_int_e(VALUE obj, VALUE j, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_fermi_dirac_int_e, j, x); } static VALUE rb_gsl_sf_fermi_dirac_mhalf(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_fermi_dirac_mhalf, x); } static VALUE rb_gsl_sf_fermi_dirac_mhalf_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_fermi_dirac_mhalf_e, x); } static VALUE rb_gsl_sf_fermi_dirac_half(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_fermi_dirac_half, x); } static VALUE rb_gsl_sf_fermi_dirac_half_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_fermi_dirac_half_e, x); } static VALUE rb_gsl_sf_fermi_dirac_3half(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_fermi_dirac_3half, x); } static VALUE rb_gsl_sf_fermi_dirac_3half_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_fermi_dirac_3half_e, x); } static VALUE rb_gsl_sf_fermi_dirac_inc_0(VALUE obj, VALUE x, VALUE b) { return rb_float_new(gsl_sf_fermi_dirac_inc_0(NUM2DBL(x), NUM2DBL(b))); } static VALUE rb_gsl_sf_fermi_dirac_inc_0_e(VALUE obj, VALUE x, VALUE b) { return rb_gsl_sf_eval_e_double2(gsl_sf_fermi_dirac_inc_0_e, x, b); } void Init_gsl_sf_fermi_dirac(VALUE module) { VALUE mgsl_sf_fermi; rb_define_module_function(module, "fermi_dirac_m1", rb_gsl_sf_fermi_dirac_m1, 1); rb_define_module_function(module, "fermi_dirac_m1_e", rb_gsl_sf_fermi_dirac_m1_e, 1); rb_define_module_function(module, "fermi_dirac_0", rb_gsl_sf_fermi_dirac_0, 1); rb_define_module_function(module, "fermi_dirac_0_e", rb_gsl_sf_fermi_dirac_0_e, 1); rb_define_module_function(module, "fermi_dirac_1", rb_gsl_sf_fermi_dirac_1, 1); rb_define_module_function(module, "fermi_dirac_1_e", rb_gsl_sf_fermi_dirac_1_e, 1); rb_define_module_function(module, "fermi_dirac_2", rb_gsl_sf_fermi_dirac_2, 1); rb_define_module_function(module, "fermi_dirac_2_e", rb_gsl_sf_fermi_dirac_2_e, 1); rb_define_module_function(module, "fermi_dirac_int", rb_gsl_sf_fermi_dirac_int, 2); rb_define_module_function(module, "fermi_dirac_int_e", rb_gsl_sf_fermi_dirac_int_e, 2); rb_define_module_function(module, "fermi_dirac_mhalf", rb_gsl_sf_fermi_dirac_mhalf, 1); rb_define_module_function(module, "fermi_dirac_mhalf_e", rb_gsl_sf_fermi_dirac_mhalf_e, 1); rb_define_module_function(module, "fermi_dirac_half", rb_gsl_sf_fermi_dirac_half, 1); rb_define_module_function(module, "fermi_dirac_half_e", rb_gsl_sf_fermi_dirac_half_e, 1); rb_define_module_function(module, "fermi_dirac_3half", rb_gsl_sf_fermi_dirac_3half, 1); rb_define_module_function(module, "fermi_dirac_3half_e", rb_gsl_sf_fermi_dirac_3half_e, 1); rb_define_module_function(module, "fermi_dirac_inc_0", rb_gsl_sf_fermi_dirac_inc_0, 2); rb_define_module_function(module, "fermi_dirac_inc_0_e", rb_gsl_sf_fermi_dirac_inc_0_e, 2); mgsl_sf_fermi = rb_define_module_under(module, "Fermi_Dirac"); rb_define_module_function(mgsl_sf_fermi, "m1", rb_gsl_sf_fermi_dirac_m1, 1); rb_define_module_function(mgsl_sf_fermi, "m1_e", rb_gsl_sf_fermi_dirac_m1_e, 1); rb_define_module_function(mgsl_sf_fermi, "zero", rb_gsl_sf_fermi_dirac_0, 1); rb_define_module_function(mgsl_sf_fermi, "zero_e", rb_gsl_sf_fermi_dirac_0_e, 1); rb_define_module_function(mgsl_sf_fermi, "one", rb_gsl_sf_fermi_dirac_1, 1); rb_define_module_function(mgsl_sf_fermi, "one_e", rb_gsl_sf_fermi_dirac_1_e, 1); rb_define_module_function(mgsl_sf_fermi, "two", rb_gsl_sf_fermi_dirac_2, 1); rb_define_module_function(mgsl_sf_fermi, "two_e", rb_gsl_sf_fermi_dirac_2_e, 1); rb_define_module_function(mgsl_sf_fermi, "int", rb_gsl_sf_fermi_dirac_int, 2); rb_define_module_function(mgsl_sf_fermi, "int_e", rb_gsl_sf_fermi_dirac_int_e, 2); rb_define_module_function(mgsl_sf_fermi, "mhalf", rb_gsl_sf_fermi_dirac_mhalf, 1); rb_define_module_function(mgsl_sf_fermi, "mhalf_e", rb_gsl_sf_fermi_dirac_mhalf_e, 1); rb_define_module_function(mgsl_sf_fermi, "half", rb_gsl_sf_fermi_dirac_half, 1); rb_define_module_function(mgsl_sf_fermi, "half_e", rb_gsl_sf_fermi_dirac_half_e, 1); rb_define_module_function(mgsl_sf_fermi, "threehalf", rb_gsl_sf_fermi_dirac_3half, 1); rb_define_module_function(mgsl_sf_fermi, "threehalf_e", rb_gsl_sf_fermi_dirac_3half_e, 1); rb_define_module_function(mgsl_sf_fermi, "inc_0", rb_gsl_sf_fermi_dirac_inc_0, 2); rb_define_module_function(mgsl_sf_fermi, "inc_0_e", rb_gsl_sf_fermi_dirac_inc_0_e, 2); } gsl-1.15.3/ext/ool.c0000644000175000017500000007360412220252463013511 0ustar boutilboutil#ifdef HAVE_OOL_OOL_VERSION_H #include "rb_gsl.h" #include "rb_gsl_array.h" #include static VALUE cool_conmin_function; static VALUE cool_conmin_constraint; static VALUE cool_conmin_pgrad; static VALUE cool_conmin_spg; static VALUE cool_conmin_gencan; static VALUE cool_conmin_pgrad_parameters; static VALUE cool_conmin_spg_parameters; static VALUE cool_conmin_gencan_parameters; #ifndef CHECK_OOL_CONMIN_FUNCTION #define CHECK_OOL_CONMIN_FUNCTION(x) if(CLASS_OF(x)!=cool_conmin_function)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (OOL::Conmin::Function expected)",\ rb_class2name(CLASS_OF(x))); #endif enum enum_ool_conmin_minimizer_type { OOL_CONMIN_PGRAD, OOL_CONMIN_SPG, OOL_CONMIN_GENCAN, }; static const ool_conmin_minimizer_type* get_minimizer_type(VALUE t) { char name[64]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (str_tail_grep(name, "pgrad") == 0) { return ool_conmin_minimizer_pgrad; } else if (str_tail_grep(name, "spg") == 0) { return ool_conmin_minimizer_spg; } else if (str_tail_grep(name, "gencan") == 0) { return ool_conmin_minimizer_gencan; } else { rb_raise(rb_eTypeError, "%s: unknown minimizer type", name); } break; case T_FIXNUM: switch (FIX2INT(t)) { case OOL_CONMIN_PGRAD: return ool_conmin_minimizer_pgrad; break; case OOL_CONMIN_SPG: return ool_conmin_minimizer_spg; break; case OOL_CONMIN_GENCAN: return ool_conmin_minimizer_gencan; break; default: rb_raise(rb_eTypeError, "%d: unknown minimizer type", FIX2INT(t)); break; } break; default: if (t == cool_conmin_pgrad) return ool_conmin_minimizer_pgrad; else if (t == cool_conmin_spg) return ool_conmin_minimizer_spg; else if (t == cool_conmin_gencan) return ool_conmin_minimizer_gencan; else rb_raise(rb_eTypeError, "type is given by a String or a Fixnum"); break; } } static void def_const(VALUE module) { rb_define_const(module, "CONTINUE", INT2FIX(OOL_CONTINUE)); rb_define_const(module, "SUCCESS", INT2FIX(OOL_SUCCESS)); } static VALUE rb_ool_conmin_minimizer_set(int argc, VALUE *argv, VALUE obj); static VALUE rb_ool_conmin_minimizer_alloc(int argc, VALUE *argv, VALUE klass) { ool_conmin_minimizer *m; VALUE obj; if (argc < 2) rb_raise(rb_eArgError, "Too few arguments (%d for >= 2)", argc); m = ool_conmin_minimizer_alloc(get_minimizer_type(argv[0]), FIX2INT(argv[1])); obj = Data_Wrap_Struct(klass, 0, ool_conmin_minimizer_free, m); if (argc > 2) rb_ool_conmin_minimizer_set(argc-2, argv+2, obj); return obj; } static void* get_parameter(const ool_conmin_minimizer_type *T, ool_conmin_pgrad_parameters *Pp, ool_conmin_spg_parameters *Ps, ool_conmin_gencan_parameters *Pg, VALUE ary); static VALUE rb_ool_conmin_minimizer_set(int argc, VALUE *argv, VALUE obj) { ool_conmin_minimizer *m; ool_conmin_function *F; ool_conmin_constraint *C; gsl_vector *v; ool_conmin_pgrad_parameters Pp; ool_conmin_spg_parameters Ps; ool_conmin_gencan_parameters Pg; void *P; Data_Get_Struct(obj, ool_conmin_minimizer, m); switch (argc) { case 3: if (CLASS_OF(argv[0]) != cool_conmin_function) rb_raise(rb_eTypeError, "Wrong argument type 0 (OOL::Conmin::Function expected)"); if (CLASS_OF(argv[1]) != cool_conmin_constraint) rb_raise(rb_eTypeError, "Wrong argument type 1 (OOL::Conmin::Constraint expected)"); if (!VECTOR_P(argv[2])) rb_raise(rb_eTypeError, "Wrong argument type 2 (GSL::Vector expected)"); Data_Get_Struct(argv[0], ool_conmin_function, F); Data_Get_Struct(argv[1], ool_conmin_constraint, C); Data_Get_Struct(argv[2], gsl_vector, v); P = get_parameter(m->type, &Pp, &Ps, &Pg, Qnil); ool_conmin_minimizer_set(m, F, C, v, P); break; case 4: if (CLASS_OF(argv[0]) != cool_conmin_function) rb_raise(rb_eTypeError, "Wrong argument type 0 (OOL::Conmin::Function expected)"); if (CLASS_OF(argv[1]) != cool_conmin_constraint) rb_raise(rb_eTypeError, "Wrong argument type 1 (OOL::Conmin::Constraint expected)"); if (!VECTOR_P(argv[2])) rb_raise(rb_eTypeError, "Wrong argument type 2 (GSL::Vector expected)"); if (!rb_obj_is_kind_of(argv[3], rb_cArray) && argv[3] != Qnil) rb_raise(rb_eTypeError, "Wrong argument type 3 (Array expected)"); Data_Get_Struct(argv[0], ool_conmin_function, F); Data_Get_Struct(argv[1], ool_conmin_constraint, C); Data_Get_Struct(argv[2], gsl_vector, v); P = get_parameter(m->type, &Pp, &Ps, &Pg, argv[3]); ool_conmin_minimizer_set(m, F, C, v, P); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 3 or 4)", argc); } return obj; } static void* get_parameter(const ool_conmin_minimizer_type *T, ool_conmin_pgrad_parameters *Pp, ool_conmin_spg_parameters *Ps, ool_conmin_gencan_parameters *Pg, VALUE ary) { if (T == ool_conmin_minimizer_pgrad) { if (ary == Qnil) { ool_conmin_parameters_default(T, (void*) Pp); } else { Pp->fmin = NUM2DBL(rb_ary_entry(ary, 0)); Pp->tol = NUM2DBL(rb_ary_entry(ary, 1)); Pp->alpha = NUM2DBL(rb_ary_entry(ary, 2)); Pp->sigma1 = NUM2DBL(rb_ary_entry(ary, 3)); Pp->sigma2 = NUM2DBL(rb_ary_entry(ary, 4)); } return (void*) Pp; } else if (T == ool_conmin_minimizer_spg) { if (ary == Qnil) { ool_conmin_parameters_default(T, (void*) Ps); } else { Ps->fmin = NUM2DBL(rb_ary_entry(ary, 0)); Ps->tol = NUM2DBL(rb_ary_entry(ary, 1)); Ps->M = NUM2DBL(rb_ary_entry(ary, 2)); Ps->alphamin = NUM2DBL(rb_ary_entry(ary, 3)); Ps->alphamax = NUM2DBL(rb_ary_entry(ary, 4)); Ps->gamma = NUM2DBL(rb_ary_entry(ary, 5)); Ps->sigma2 = NUM2DBL(rb_ary_entry(ary, 6)); Ps->sigma2 = NUM2DBL(rb_ary_entry(ary, 7)); } return (void*) Ps; } else { if (ary == Qnil) { ool_conmin_parameters_default(T, (void*) Pg); } else { Pg->epsgpen = NUM2DBL(rb_ary_entry(ary, 0)); Pg->epsgpsn = NUM2DBL(rb_ary_entry(ary, 1)); Pg->fmin = NUM2DBL(rb_ary_entry(ary, 2)); Pg->udelta0 = NUM2DBL(rb_ary_entry(ary, 3)); Pg->ucgmia = NUM2DBL(rb_ary_entry(ary, 4)); Pg->ucgmib = NUM2DBL(rb_ary_entry(ary, 5)); Pg->cg_scre = FIX2INT(rb_ary_entry(ary, 6)); Pg->cg_gpnf = NUM2DBL(rb_ary_entry(ary, 7)); Pg->cg_epsi = NUM2DBL(rb_ary_entry(ary, 8)); Pg->cg_epsf = NUM2DBL(rb_ary_entry(ary, 9)); Pg->cg_epsnqmp = NUM2DBL(rb_ary_entry(ary, 10)); Pg->cg_maxitnqmp = (size_t) FIX2INT(rb_ary_entry(ary, 11)); Pg->nearlyq = FIX2INT(rb_ary_entry(ary, 12)); Pg->nint = NUM2DBL(rb_ary_entry(ary, 13)); Pg->next = NUM2DBL(rb_ary_entry(ary, 14)); Pg->mininterp = (size_t) FIX2INT(rb_ary_entry(ary, 15)); Pg->maxextrap = (size_t) FIX2INT(rb_ary_entry(ary, 16)); Pg->trtype = FIX2INT(rb_ary_entry(ary, 17)); Pg->eta = NUM2DBL(rb_ary_entry(ary, 18)); Pg->delmin = NUM2DBL(rb_ary_entry(ary, 19)); Pg->lspgmi = NUM2DBL(rb_ary_entry(ary, 20)); Pg->lspgma = NUM2DBL(rb_ary_entry(ary, 21)); Pg->theta = NUM2DBL(rb_ary_entry(ary, 22)); Pg->gamma = NUM2DBL(rb_ary_entry(ary, 23)); Pg->beta = NUM2DBL(rb_ary_entry(ary, 24)); Pg->sigma1 = NUM2DBL(rb_ary_entry(ary, 25)); Pg->sigma2 = NUM2DBL(rb_ary_entry(ary, 26)); Pg->epsrel = NUM2DBL(rb_ary_entry(ary, 27)); Pg->epsabs = NUM2DBL(rb_ary_entry(ary, 28)); Pg->infrel = NUM2DBL(rb_ary_entry(ary, 29)); Pg->infabs = NUM2DBL(rb_ary_entry(ary, 30)); } return (void*) Pg; } } static VALUE create_parameters_ary_pgrad(ool_conmin_pgrad_parameters *Pp) { VALUE ary; ary = rb_ary_new2(5); rb_ary_store(ary, 0, rb_float_new(Pp->fmin)); rb_ary_store(ary, 1, rb_float_new(Pp->tol)); rb_ary_store(ary, 2, rb_float_new(Pp->alpha)); rb_ary_store(ary, 3, rb_float_new(Pp->sigma1)); rb_ary_store(ary, 4, rb_float_new(Pp->sigma2)); return ary; } static VALUE create_parameters_ary_spg(ool_conmin_spg_parameters *Ps) { VALUE ary; ary = rb_ary_new2(8); rb_ary_store(ary, 0, rb_float_new(Ps->fmin)); rb_ary_store(ary, 1, rb_float_new(Ps->tol)); rb_ary_store(ary, 2, rb_float_new(Ps->M)); rb_ary_store(ary, 3, rb_float_new(Ps->alphamin)); rb_ary_store(ary, 4, rb_float_new(Ps->alphamax)); rb_ary_store(ary, 5, rb_float_new(Ps->gamma)); rb_ary_store(ary, 6, rb_float_new(Ps->sigma2)); rb_ary_store(ary, 7, rb_float_new(Ps->sigma2)); return ary; } static VALUE create_parameters_ary_gencan(ool_conmin_gencan_parameters *Pg) { VALUE ary; ary = rb_ary_new2(31); rb_ary_store(ary, 0, rb_float_new(Pg->epsgpen)); rb_ary_store(ary, 1, rb_float_new(Pg->epsgpsn)); rb_ary_store(ary, 2, rb_float_new(Pg->fmin)); rb_ary_store(ary, 3, rb_float_new(Pg->udelta0)); rb_ary_store(ary, 4, rb_float_new(Pg->ucgmia)); rb_ary_store(ary, 5, rb_float_new(Pg->ucgmib)); rb_ary_store(ary, 6, INT2FIX(Pg->cg_scre)); rb_ary_store(ary, 7, rb_float_new(Pg->cg_gpnf)); rb_ary_store(ary, 8, rb_float_new(Pg->cg_epsi)); rb_ary_store(ary, 9, rb_float_new(Pg->cg_epsf)); rb_ary_store(ary, 10, rb_float_new(Pg->cg_epsnqmp)); rb_ary_store(ary, 11, INT2FIX((int) Pg->cg_maxitnqmp)); rb_ary_store(ary, 12, INT2FIX(Pg->nearlyq)); rb_ary_store(ary, 13, rb_float_new(Pg->nint)); rb_ary_store(ary, 14, rb_float_new(Pg->next)); rb_ary_store(ary, 15, INT2FIX((int)Pg->mininterp)); rb_ary_store(ary, 16, INT2FIX((int)Pg->maxextrap)); rb_ary_store(ary, 17, INT2FIX(Pg->trtype)); rb_ary_store(ary, 18, rb_float_new(Pg->eta)); rb_ary_store(ary, 19, rb_float_new(Pg->delmin)); rb_ary_store(ary, 20, rb_float_new(Pg->lspgmi)); rb_ary_store(ary, 21, rb_float_new(Pg->lspgma)); rb_ary_store(ary, 22, rb_float_new(Pg->theta)); rb_ary_store(ary, 23, rb_float_new(Pg->gamma)); rb_ary_store(ary, 24, rb_float_new(Pg->beta)); rb_ary_store(ary, 25, rb_float_new(Pg->sigma1)); rb_ary_store(ary, 26, rb_float_new(Pg->sigma2)); rb_ary_store(ary, 27, rb_float_new(Pg->epsrel)); rb_ary_store(ary, 28, rb_float_new(Pg->epsabs)); rb_ary_store(ary, 29, rb_float_new(Pg->infrel)); rb_ary_store(ary, 30, rb_float_new(Pg->infabs)); return ary; } static VALUE rb_ool_conmin_minimizer_parameters_get(VALUE obj) { ool_conmin_minimizer *m; ool_conmin_pgrad_parameters *Pp; ool_conmin_spg_parameters *Ps; ool_conmin_gencan_parameters *Pg; void *P; VALUE ary; Data_Get_Struct(obj, ool_conmin_minimizer, m); ool_conmin_parameters_get(m, P); if (m->type == ool_conmin_minimizer_pgrad) { Pp = (ool_conmin_pgrad_parameters*) P; ary = create_parameters_ary_pgrad(Pp); } else if (m->type == ool_conmin_minimizer_spg) { Ps = (ool_conmin_spg_parameters*) P; ary = create_parameters_ary_spg(Ps); } else { Pg = (ool_conmin_gencan_parameters*) P; ary = create_parameters_ary_gencan(Pg); } return ary; } static VALUE rb_ool_conmin_minimizer_parameters_set(VALUE obj, VALUE params) { ool_conmin_minimizer *m; ool_conmin_pgrad_parameters *Pp; ool_conmin_spg_parameters *Ps; ool_conmin_gencan_parameters *Pg; void *P; Data_Get_Struct(obj, ool_conmin_minimizer, m); P = get_parameter(m->type, Pp, Ps, Pg, params); ool_conmin_parameters_set(m, P); return params; } static VALUE rb_ool_conmin_minimizer_name(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return rb_str_new2(ool_conmin_minimizer_name(m)); } static VALUE rb_ool_conmin_minimizer_f(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return rb_float_new(m->f); } static VALUE rb_ool_conmin_minimizer_x(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return Data_Wrap_Struct(cgsl_vector, 0, NULL, m->x); } static VALUE rb_ool_conmin_minimizer_gradient(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return Data_Wrap_Struct(cgsl_vector, 0, NULL, m->gradient); } static VALUE rb_ool_conmin_minimizer_minimum(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return rb_float_new(ool_conmin_minimizer_minimum(m)); } static VALUE rb_ool_conmin_minimizer_dx(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return Data_Wrap_Struct(cgsl_vector, 0, NULL, m->dx); } static VALUE rb_ool_conmin_minimizer_size(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return rb_float_new(ool_conmin_minimizer_size(m)); } static VALUE rb_ool_conmin_minimizer_fcount(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return INT2FIX((int) ool_conmin_minimizer_fcount(m)); } static VALUE rb_ool_conmin_minimizer_gcount(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return INT2FIX((int) ool_conmin_minimizer_gcount(m)); } static VALUE rb_ool_conmin_minimizer_hcount(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return INT2FIX((int) ool_conmin_minimizer_hcount(m)); } static VALUE rb_ool_conmin_minimizer_is_optimal(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return INT2FIX((int) ool_conmin_is_optimal(m)); } static VALUE rb_ool_conmin_minimizer_is_optimal2(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); if (ool_conmin_is_optimal(m)) return Qtrue; else return Qfalse; } static VALUE rb_ool_conmin_minimizer_iterate(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return INT2FIX((int) ool_conmin_minimizer_iterate(m)); } static VALUE rb_ool_conmin_minimizer_restart(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return INT2FIX((int) ool_conmin_minimizer_restart(m)); } static VALUE rb_ool_conmin_pgrad_parameters_default(VALUE klass); static VALUE rb_ool_conmin_spg_parameters_default(VALUE klass); static VALUE rb_ool_conmin_gencan_parameters_default(VALUE klass); static VALUE rb_ool_conmin_minimizer_parameters_default(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); if (m->type == ool_conmin_minimizer_spg) { return rb_ool_conmin_spg_parameters_default(cool_conmin_spg); } else if (m->type == ool_conmin_minimizer_pgrad) { return rb_ool_conmin_pgrad_parameters_default(cool_conmin_pgrad); } else if (m->type == ool_conmin_minimizer_gencan) { return rb_ool_conmin_gencan_parameters_default(cool_conmin_gencan); } else { rb_raise(rb_eRuntimeError, "Unkowm minimizer type."); } return Qnil; /* never reaches here */ } /***/ static void rb_ool_conmin_function_mark(ool_conmin_function *F) { rb_gc_mark((VALUE) F->params); } static double rb_ool_conmin_function_f(const gsl_vector *x, void *p); static void rb_ool_conmin_function_df(const gsl_vector *x, void *p, gsl_vector *g); static void rb_ool_conmin_function_fdf(const gsl_vector *x, void *p, double *f, gsl_vector *g); static void rb_ool_conmin_function_Hv(const gsl_vector *X, void *params, const gsl_vector *V, gsl_vector *hv); static void set_functions(int argc, VALUE *argv, ool_conmin_function *F); static void set_params(ool_conmin_function *F, VALUE p); static VALUE rb_ool_conmin_function_set_n(VALUE obj, VALUE nn); static VALUE rb_ool_conmin_function_set_functions(int argc, VALUE *argv, VALUE obj); static VALUE rb_ool_conmin_function_set(int argc, VALUE *argv, VALUE obj); static VALUE rb_ool_conmin_function_alloc(int argc, VALUE *argv, VALUE klass) { ool_conmin_function *F = NULL; VALUE ary, obj; F = ALLOC(ool_conmin_function); F->f = &rb_ool_conmin_function_f; F->df = &rb_ool_conmin_function_df; F->fdf = &rb_ool_conmin_function_fdf; F->Hv = &rb_ool_conmin_function_Hv; F->n = 0; ary = rb_ary_new2(5); F->params = (void *) ary; rb_ary_store(ary, 0, Qnil); /* proc f */ rb_ary_store(ary, 1, Qnil); /* proc df */ rb_ary_store(ary, 2, Qnil); /* proc fdf */ rb_ary_store(ary, 3, Qnil); /* proc Hv */ rb_ary_store(ary, 4, Qnil); /* params */ // set_functions(argc, argv, F); obj = Data_Wrap_Struct(klass, rb_ool_conmin_function_mark, free, F); rb_ool_conmin_function_set(argc, argv, obj); return obj; } static VALUE rb_ool_conmin_function_set(int argc, VALUE *argv, VALUE obj) { ool_conmin_function *F; Data_Get_Struct(obj, ool_conmin_function, F); switch (argc) { case 0: break; case 1: rb_ool_conmin_function_set_n(obj, argv[0]); break; case 4: set_functions(argc, argv, F); break; case 5: if (FIXNUM_P(argv[0])) { rb_ool_conmin_function_set_n(obj, argv[0]); set_functions(argc-1, argv+1, F); } else { set_functions(argc-1, argv, F); set_params(F, argv[argc-1]); } break; case 6: rb_ool_conmin_function_set_n(obj, argv[0]); set_functions(argc-2, argv+1, F); set_params(F, argv[argc-1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments."); } return obj; } static VALUE rb_ool_conmin_function_set_n(VALUE obj, VALUE nn) { ool_conmin_function *F = NULL; if (FIXNUM_P(nn)) { Data_Get_Struct(obj, ool_conmin_function, F); F->n = (size_t) FIX2INT(nn); } else { rb_raise(rb_eArgError, "Wrong argument type %s (Fixnum expected)", rb_class2name(CLASS_OF(nn))); } return nn; } static VALUE rb_ool_conmin_function_n(VALUE obj) { ool_conmin_function *F = NULL; Data_Get_Struct(obj, ool_conmin_function, F); return INT2FIX((int) F->n); } static double rb_ool_conmin_function_f(const gsl_vector *x, void *p) { VALUE vx, proc, vp, result, ary; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); ary = (VALUE) p; proc = rb_ary_entry(ary, 0); vp = rb_ary_entry(ary, RARRAY_LEN(ary)-1); if (NIL_P(vp)) result = rb_funcall(proc, RBGSL_ID_call, 1, vx); else result = rb_funcall(proc, RBGSL_ID_call, 2, vx, vp); return NUM2DBL(result); } static void rb_ool_conmin_function_df(const gsl_vector *x, void *p, gsl_vector *g) { VALUE vx, vg, proc, vp, ary; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vg = Data_Wrap_Struct(cgsl_vector, 0, NULL, g); ary = (VALUE) p; proc = rb_ary_entry(ary, 1); vp = rb_ary_entry(ary, RARRAY_LEN(ary)-1); if (NIL_P(vp)) { rb_funcall(proc, RBGSL_ID_call, 2, vx, vg); } else { rb_funcall(proc, RBGSL_ID_call, 3, vx, vp, vg); } } static void rb_ool_conmin_function_fdf(const gsl_vector *x, void *p, double *f, gsl_vector *g) { VALUE vx, vf, vg, proc_fdf, proc_f, proc_df, vp, ary, result; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vg = Data_Wrap_Struct(cgsl_vector, 0, NULL, g); vf = rb_float_new(*f); ary = (VALUE) p; proc_f = rb_ary_entry(ary, 0); proc_df = rb_ary_entry(ary, 1); proc_fdf = rb_ary_entry(ary, 2); vp = rb_ary_entry(ary, RARRAY_LEN(ary)-1); if (NIL_P(vp)) { result = rb_funcall(proc_f, RBGSL_ID_call, 1, vx); rb_funcall(proc_df, RBGSL_ID_call, 2, vx, vg); } else { result = rb_funcall(proc_f, RBGSL_ID_call, 2, vx, vp); rb_funcall(proc_df, RBGSL_ID_call, 3, vx, vp, vg); } *f = NUM2DBL(result); } static void rb_ool_conmin_function_Hv(const gsl_vector *X, void *params, const gsl_vector *V, gsl_vector *hv) { VALUE vX, vV, vHv, ary, proc_Hv, vp; vX = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector*) X); vV = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector*) V); vHv = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector*) hv); ary = (VALUE) params; proc_Hv = rb_ary_entry(ary, 3); vp = rb_ary_entry(ary, RARRAY_LEN(ary)-1); if (NIL_P(vp)) { rb_funcall(proc_Hv, RBGSL_ID_call, 3, vX, vV, vHv); } else { rb_funcall(proc_Hv, RBGSL_ID_call, 4, vX, vp, vV, vHv); } } static VALUE rb_ool_conmin_function_set_functions(int argc, VALUE *argv, VALUE obj) { ool_conmin_function *F; Data_Get_Struct(obj, ool_conmin_function, F); set_functions(argc, argv, F); return obj; } static void set_functions(int argc, VALUE *argv, ool_conmin_function *F) { VALUE ary; size_t i; if (F->params == NULL) { ary = rb_ary_new2(5); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } switch (argc) { case 4: for (i = 0; i < argc; i++) rb_ary_store(ary, i, argv[i]); break; default: rb_raise(rb_eArgError,"Wrong number of arguments (%d for 4)", argc); } } static VALUE rb_ool_conmin_function_set_f(VALUE obj, VALUE proc) { ool_conmin_function *F; VALUE ary; Data_Get_Struct(obj, ool_conmin_function, F); if (F->params == NULL) { ary = rb_ary_new2(5); F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 0, proc); return proc; } static VALUE rb_ool_conmin_function_set_df(VALUE obj, VALUE proc) { ool_conmin_function *F; VALUE ary; Data_Get_Struct(obj, ool_conmin_function, F); if (F->params == NULL) { ary = rb_ary_new2(5); F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 1, proc); return proc; } static VALUE rb_ool_conmin_function_set_fdf(VALUE obj, VALUE proc) { ool_conmin_function *F; VALUE ary; Data_Get_Struct(obj, ool_conmin_function, F); if (F->params == NULL) { ary = rb_ary_new2(5); F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 2, proc); return proc; } static VALUE rb_ool_conmin_function_set_Hv(VALUE obj, VALUE proc) { ool_conmin_function *F; VALUE ary; Data_Get_Struct(obj, ool_conmin_function, F); if (F->params == NULL) { ary = rb_ary_new2(5); F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 3, proc); return proc; } static VALUE rb_ool_conmin_function_set_params(VALUE obj, VALUE p) { ool_conmin_function *F; Data_Get_Struct(obj, ool_conmin_function, F); set_params(F, p); return p; } static void set_params(ool_conmin_function *F, VALUE p) { VALUE ary; if (F->params == NULL) { ary = rb_ary_new2(5); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 4, p); } static VALUE rb_ool_conmin_function_params(VALUE obj) { ool_conmin_function *F; Data_Get_Struct(obj, ool_conmin_function, F); return rb_ary_entry((VALUE) F->params, 4);; } static VALUE rb_ool_conmin_constraint_set(int argc, VALUE *argv, VALUE obj); static VALUE rb_ool_conmin_constraint_set_n(VALUE obj, VALUE n); static VALUE rb_ool_conmin_constraint_alloc(int argc, VALUE *argv, VALUE klass) { ool_conmin_constraint *C; VALUE obj; C = ALLOC(ool_conmin_constraint); C->n = 0; C->L = NULL; C->U = NULL; obj = Data_Wrap_Struct(klass, 0, free, C); rb_ool_conmin_constraint_set(argc, argv, obj); return obj; } static VALUE rb_ool_conmin_constraint_set_n(VALUE obj, VALUE n) { ool_conmin_constraint *C; if (!FIXNUM_P(n)) rb_raise(rb_eArgError, "Wrong argument type %s (Fixnum expected)", rb_class2name(CLASS_OF(n))); Data_Get_Struct(obj, ool_conmin_constraint, C); C->n = (size_t) FIX2INT(n); return n; } static VALUE rb_ool_conmin_constraint_set_L(VALUE obj, VALUE vL) { ool_conmin_constraint *C; gsl_vector *L; CHECK_VECTOR(vL); Data_Get_Struct(obj, ool_conmin_constraint, C); Data_Get_Struct(vL, gsl_vector, L); C->L = L; return vL; } static VALUE rb_ool_conmin_constraint_set_U(VALUE obj, VALUE vU) { ool_conmin_constraint *C; gsl_vector *U; CHECK_VECTOR(vU); Data_Get_Struct(obj, ool_conmin_constraint, C); Data_Get_Struct(vU, gsl_vector, U); C->U = U; return vU; } static VALUE rb_ool_conmin_constraint_set_LU(VALUE obj, VALUE vL, VALUE vU) { rb_ool_conmin_constraint_set_L(obj, vL); rb_ool_conmin_constraint_set_U(obj, vU); return obj; } static VALUE rb_ool_conmin_constraint_set(int argc, VALUE *argv, VALUE obj) { ool_conmin_constraint *C; Data_Get_Struct(obj, ool_conmin_constraint, C); switch (argc) { case 0: break; case 1: rb_ool_conmin_constraint_set_n(obj, argv[0]); break; case 2: rb_ool_conmin_constraint_set_LU(obj, argv[0], argv[1]); break; case 3: rb_ool_conmin_constraint_set_n(obj, argv[0]); rb_ool_conmin_constraint_set_LU(obj, argv[1], argv[2]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1-3)", argc); } return obj; } static VALUE rb_ool_conmin_pgrad_parameters_default(VALUE klass) { ool_conmin_pgrad_parameters P; VALUE ary; ool_conmin_parameters_default(ool_conmin_minimizer_pgrad, (void*) &P); ary = create_parameters_ary_pgrad(&P); RBASIC(ary)->klass = cool_conmin_pgrad_parameters; return ary; } static VALUE rb_ool_conmin_spg_parameters_default(VALUE klass) { ool_conmin_spg_parameters P; VALUE ary; ool_conmin_parameters_default(ool_conmin_minimizer_spg, (void*) &P); ary = create_parameters_ary_spg(&P); RBASIC(ary)->klass = cool_conmin_spg_parameters; return ary; } static VALUE rb_ool_conmin_gencan_parameters_default(VALUE klass) { ool_conmin_gencan_parameters P; VALUE ary; ool_conmin_parameters_default(ool_conmin_minimizer_gencan, (void*) &P); ary = create_parameters_ary_gencan(&P); RBASIC(ary)->klass = cool_conmin_gencan_parameters; return ary; } /*************************************************/ void Init_ool(VALUE module) { VALUE mOOL, mConmin; VALUE cool_conmin_minimizer; mOOL = rb_define_module("OOL"); mConmin = rb_define_module_under(mOOL, "Conmin"); cool_conmin_function = rb_define_class_under(mConmin, "Function", cgsl_function); cool_conmin_constraint = rb_define_class_under(mConmin, "Constraint", cGSL_Object); cool_conmin_minimizer = rb_define_class_under(mConmin, "Minimizer", cGSL_Object); cool_conmin_pgrad = rb_define_class_under(cool_conmin_minimizer, "Pgrad", cGSL_Object); cool_conmin_spg = rb_define_class_under(cool_conmin_minimizer, "Spg", cGSL_Object); cool_conmin_gencan = rb_define_class_under(cool_conmin_minimizer, "Gencan", cGSL_Object); def_const(mOOL); rb_define_singleton_method(cool_conmin_minimizer, "alloc", rb_ool_conmin_minimizer_alloc, -1); rb_define_method(cool_conmin_minimizer, "set", rb_ool_conmin_minimizer_set, -1); rb_define_method(cool_conmin_minimizer, "parameters_default", rb_ool_conmin_minimizer_parameters_default, 0); rb_define_method(cool_conmin_minimizer, "name", rb_ool_conmin_minimizer_name, 0); rb_define_method(cool_conmin_minimizer, "size", rb_ool_conmin_minimizer_size, 0); rb_define_method(cool_conmin_minimizer, "f", rb_ool_conmin_minimizer_f, 0); rb_define_method(cool_conmin_minimizer, "x", rb_ool_conmin_minimizer_x, 0); rb_define_method(cool_conmin_minimizer, "dx", rb_ool_conmin_minimizer_dx, 0); rb_define_method(cool_conmin_minimizer, "gradient", rb_ool_conmin_minimizer_gradient, 0); rb_define_method(cool_conmin_minimizer, "minimum", rb_ool_conmin_minimizer_minimum, 0); rb_define_method(cool_conmin_minimizer, "fcount", rb_ool_conmin_minimizer_fcount, 0); rb_define_method(cool_conmin_minimizer, "gcount", rb_ool_conmin_minimizer_gcount, 0); rb_define_method(cool_conmin_minimizer, "hcount", rb_ool_conmin_minimizer_hcount, 0); rb_define_method(cool_conmin_minimizer, "is_optimal", rb_ool_conmin_minimizer_is_optimal, 0); rb_define_method(cool_conmin_minimizer, "is_optimal?", rb_ool_conmin_minimizer_is_optimal2, 0); rb_define_method(cool_conmin_minimizer, "iterate", rb_ool_conmin_minimizer_iterate, 0); rb_define_method(cool_conmin_minimizer, "restart", rb_ool_conmin_minimizer_restart, 0); rb_define_method(cool_conmin_minimizer, "parameters_get", rb_ool_conmin_minimizer_parameters_get, 0); rb_define_method(cool_conmin_minimizer, "parameters_set", rb_ool_conmin_minimizer_parameters_set, 1); rb_define_singleton_method(cool_conmin_function, "alloc", rb_ool_conmin_function_alloc, -1); rb_define_method(cool_conmin_function, "set", rb_ool_conmin_function_set, -1); rb_define_method(cool_conmin_function, "set_n", rb_ool_conmin_function_set_n, 1); rb_define_alias(cool_conmin_function, "n=", "set_n"); rb_define_method(cool_conmin_function, "n", rb_ool_conmin_function_n, 0); rb_define_method(cool_conmin_function, "params", rb_ool_conmin_function_params, 0); rb_define_method(cool_conmin_function, "set_params", rb_ool_conmin_function_set_params, 1); rb_define_alias(cool_conmin_function, "params=", "set_params"); rb_define_method(cool_conmin_function, "set_functions", rb_ool_conmin_function_set_functions, 1); rb_define_alias(cool_conmin_function, "functions=", "set_functions"); rb_define_method(cool_conmin_function, "set_f", rb_ool_conmin_function_set_f, 1); rb_define_alias(cool_conmin_function, "f=", "set_f"); rb_define_method(cool_conmin_function, "set_df", rb_ool_conmin_function_set_df, 1); rb_define_alias(cool_conmin_function, "df=", "set_df"); rb_define_method(cool_conmin_function, "set_fdf", rb_ool_conmin_function_set_fdf, 1); rb_define_alias(cool_conmin_function, "fdf=", "set_fdf"); rb_define_method(cool_conmin_function, "set_Hv", rb_ool_conmin_function_set_Hv, 1); rb_define_alias(cool_conmin_function, "Hv=", "set_Hv"); rb_define_singleton_method(cool_conmin_constraint, "alloc", rb_ool_conmin_constraint_alloc, -1); rb_define_method(cool_conmin_constraint, "set", rb_ool_conmin_constraint_set, -1); rb_define_method(cool_conmin_constraint, "set_n", rb_ool_conmin_constraint_set_n, 1); rb_define_alias(cool_conmin_constraint, "n=", "set_n"); rb_define_method(cool_conmin_constraint, "set_L", rb_ool_conmin_constraint_set_L, 1); rb_define_alias(cool_conmin_constraint, "L=", "set_L"); rb_define_method(cool_conmin_constraint, "set_U", rb_ool_conmin_constraint_set_U, 1); rb_define_alias(cool_conmin_constraint, "U=", "set_U"); rb_define_method(cool_conmin_constraint, "set_LU", rb_ool_conmin_constraint_set_LU, 2); rb_define_alias(cool_conmin_constraint, "LU=", "set_LU"); cool_conmin_pgrad_parameters = rb_define_class_under(cool_conmin_pgrad, "Parameters", rb_cArray); cool_conmin_spg_parameters = rb_define_class_under(cool_conmin_spg, "Parameters", rb_cArray); cool_conmin_gencan_parameters = rb_define_class_under(cool_conmin_gencan, "Parameters", rb_cArray); rb_define_singleton_method(cool_conmin_pgrad, "parameters_default", rb_ool_conmin_pgrad_parameters_default, 0); rb_define_singleton_method(cool_conmin_spg, "parameters_default", rb_ool_conmin_spg_parameters_default, 0); rb_define_singleton_method(cool_conmin_gencan, "parameters_default", rb_ool_conmin_gencan_parameters_default, 0); } #endif gsl-1.15.3/ext/min.c0000644000175000017500000001726212220252463013501 0ustar boutilboutil/* min.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_function.h" #include double rb_gsl_function_f(double x, void *p); enum { GSL_MIN_FMINIMIZER_GOLDENSECTION, GSL_MIN_FMINIMIZER_BRENT, #ifdef GSL_1_13_LATER GSL_MIN_FMINIMIZER_QUAD_GOLDEN, #endif }; static const gsl_min_fminimizer_type* rb_gsl_min_fminimizer_type_get(VALUE t); static const gsl_min_fminimizer_type* rb_gsl_min_fminimizer_type_get(VALUE t) { char name[32]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (str_tail_grep(name, "goldensection") == 0) return gsl_min_fminimizer_goldensection; else if (str_tail_grep(name, "brent") == 0) return gsl_min_fminimizer_brent; #ifdef GSL_1_13_LATER else if (str_tail_grep(name, "quad_golden") == 0) return gsl_min_fminimizer_quad_golden; #endif else rb_raise(rb_eTypeError, "unknown type %s (goldensection, brent or quad_golden expected)", name); break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_MIN_FMINIMIZER_GOLDENSECTION: return gsl_min_fminimizer_goldensection; break; case GSL_MIN_FMINIMIZER_BRENT: return gsl_min_fminimizer_brent; break; #ifdef GSL_1_13_LATER case GSL_MIN_FMINIMIZER_QUAD_GOLDEN: return gsl_min_fminimizer_quad_golden; break; #endif default: rb_raise(rb_eTypeError, "unknown type (GOLDENSECION or BRENT or QUAD_GOLDEN expected)"); break; } break; default: rb_raise(rb_eTypeError, "wrong argument type %s (String of Fixnum)", rb_class2name(CLASS_OF(t))); break; } } static VALUE rb_gsl_min_fminimizer_new(VALUE klass, VALUE t) { gsl_min_fminimizer *gmf = NULL; const gsl_min_fminimizer_type *T; T = rb_gsl_min_fminimizer_type_get(t); gmf = gsl_min_fminimizer_alloc(T); return Data_Wrap_Struct(klass, 0, gsl_min_fminimizer_free, gmf); } static VALUE rb_gsl_min_fminimizer_name(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return rb_str_new2(gsl_min_fminimizer_name(gmf)); } static VALUE rb_gsl_min_fminimizer_set(VALUE obj, VALUE ff, VALUE xmin, VALUE xl, VALUE xu) { gsl_min_fminimizer *gmf = NULL; gsl_function *f = NULL; Need_Float(xmin); Need_Float(xl); Need_Float(xu); CHECK_FUNCTION(ff); Data_Get_Struct(obj, gsl_min_fminimizer, gmf); Data_Get_Struct(ff, gsl_function, f); return INT2FIX(gsl_min_fminimizer_set(gmf, f, NUM2DBL(xmin), NUM2DBL(xl), NUM2DBL(xu))); } static VALUE rb_gsl_min_fminimizer_set_with_values(VALUE obj, VALUE ff, VALUE xmin, VALUE fmin, VALUE xl, VALUE fl, VALUE xu, VALUE fu) { gsl_min_fminimizer *gmf = NULL; gsl_function *f = NULL; Need_Float(xmin); Need_Float(xl); Need_Float(xu); Need_Float(fl); Need_Float(fu); CHECK_FUNCTION(ff); Data_Get_Struct(obj, gsl_min_fminimizer, gmf); Data_Get_Struct(ff, gsl_function, f); return INT2FIX(gsl_min_fminimizer_set_with_values(gmf, f, NUM2DBL(xmin), NUM2DBL(fmin), NUM2DBL(xl), NUM2DBL(fl), NUM2DBL(xu), NUM2DBL(fu))); } static VALUE rb_gsl_min_fminimizer_iterate(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return INT2FIX(gsl_min_fminimizer_iterate(gmf)); } static VALUE rb_gsl_min_fminimizer_x_lower(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return rb_float_new(gsl_min_fminimizer_x_lower(gmf)); } static VALUE rb_gsl_min_fminimizer_x_upper(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return rb_float_new(gsl_min_fminimizer_x_upper(gmf)); } #ifndef GSL_1_2_LATER static double gsl_min_fminimizer_x_minimum(const gsl_min_fminimizer * s) { /* return s->x_minimum;*/ return s->minimum; } static double gsl_min_fminimizer_f_minimum(const gsl_min_fminimizer * s) { return s->f_minimum; } static double gsl_min_fminimizer_f_lower(const gsl_min_fminimizer * s) { return s->f_lower; } static double gsl_min_fminimizer_f_upper(const gsl_min_fminimizer * s) { return s->f_upper; } #endif static VALUE rb_gsl_min_fminimizer_x_minimum(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return rb_float_new(gsl_min_fminimizer_x_minimum(gmf)); } static VALUE rb_gsl_min_fminimizer_f_minimum(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return rb_float_new(gsl_min_fminimizer_f_minimum(gmf)); } static VALUE rb_gsl_min_fminimizer_f_lower(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return rb_float_new(gsl_min_fminimizer_f_lower(gmf)); } static VALUE rb_gsl_min_fminimizer_f_upper(VALUE obj) { gsl_min_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_min_fminimizer, gmf); return rb_float_new(gsl_min_fminimizer_f_upper(gmf)); } static VALUE rb_gsl_min_fminimizer_test_interval(VALUE obj, VALUE ea, VALUE er) { gsl_min_fminimizer *gmf = NULL; double xl, xu; Need_Float(ea); Need_Float(er); Data_Get_Struct(obj, gsl_min_fminimizer, gmf); xl = gsl_min_fminimizer_x_lower(gmf); xu = gsl_min_fminimizer_x_upper(gmf); return INT2FIX(gsl_min_test_interval(xl, xu, NUM2DBL(ea), NUM2DBL(er))); } static VALUE rb_gsl_fminimizer_test_interval(VALUE obj, VALUE xl, VALUE xu, VALUE ea, VALUE er) { Need_Float(xl); Need_Float(xu); Need_Float(ea); Need_Float(er); return INT2FIX(gsl_min_test_interval(NUM2DBL(xl), NUM2DBL(xu), NUM2DBL(ea), NUM2DBL(er))); } void Init_gsl_min(VALUE module) { VALUE mgsl_min, cgsl_fminimizer; mgsl_min = rb_define_module_under(module, "Min"); cgsl_fminimizer = rb_define_class_under(mgsl_min, "FMinimizer", cGSL_Object); rb_define_const(cgsl_fminimizer, "GOLDENSECTION", INT2FIX(GSL_MIN_FMINIMIZER_GOLDENSECTION)); rb_define_const(cgsl_fminimizer, "Goldensection", INT2FIX(GSL_MIN_FMINIMIZER_GOLDENSECTION)); rb_define_const(cgsl_fminimizer, "BRENT", INT2FIX(GSL_MIN_FMINIMIZER_BRENT)); rb_define_const(cgsl_fminimizer, "Brent", INT2FIX(GSL_MIN_FMINIMIZER_BRENT)); #ifdef GSL_1_13_LATER rb_define_const(cgsl_fminimizer, "QUAD_GOLDEN", INT2FIX(GSL_MIN_FMINIMIZER_QUAD_GOLDEN)); #endif rb_define_singleton_method(cgsl_fminimizer, "new", rb_gsl_min_fminimizer_new, 1); rb_define_singleton_method(cgsl_fminimizer, "alloc", rb_gsl_min_fminimizer_new, 1); rb_define_method(cgsl_fminimizer, "name", rb_gsl_min_fminimizer_name, 0); rb_define_method(cgsl_fminimizer, "set", rb_gsl_min_fminimizer_set, 4); rb_define_method(cgsl_fminimizer, "set_with_values", rb_gsl_min_fminimizer_set_with_values, 7); rb_define_method(cgsl_fminimizer, "iterate", rb_gsl_min_fminimizer_iterate, 0); rb_define_method(cgsl_fminimizer, "x_lower", rb_gsl_min_fminimizer_x_lower, 0); rb_define_method(cgsl_fminimizer, "x_upper", rb_gsl_min_fminimizer_x_upper, 0); rb_define_method(cgsl_fminimizer, "test_interval", rb_gsl_min_fminimizer_test_interval, 2); rb_define_singleton_method(mgsl_min, "test_interval", rb_gsl_fminimizer_test_interval, 4); rb_define_method(cgsl_fminimizer, "x_minimum", rb_gsl_min_fminimizer_x_minimum, 0); rb_define_method(cgsl_fminimizer, "f_minimum", rb_gsl_min_fminimizer_f_minimum, 0); rb_define_method(cgsl_fminimizer, "f_lower", rb_gsl_min_fminimizer_f_lower, 0); rb_define_method(cgsl_fminimizer, "f_upper", rb_gsl_min_fminimizer_f_upper, 0); } gsl-1.15.3/ext/sf_elementary.c0000644000175000017500000000271512220252463015550 0ustar boutilboutil/* sf_elementary.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_multiply_e(VALUE obj, VALUE x, VALUE y) { gsl_sf_result *r; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(y); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r); /*status =*/ gsl_sf_multiply_e(NUM2DBL(x), NUM2DBL(y), r); return v; } static VALUE rb_gsl_sf_multiply_err_e(VALUE obj, VALUE x, VALUE dx, VALUE y, VALUE dy) { gsl_sf_result *r; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(y); Need_Float(dx); Need_Float(dy); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r); /*status =*/ gsl_sf_multiply_err_e(NUM2DBL(x), NUM2DBL(dx), NUM2DBL(y), NUM2DBL(dy), r); return v; } void Init_gsl_sf_elementary(VALUE module) { rb_define_module_function(module, "multiply_e", rb_gsl_sf_multiply_e, 2); rb_define_module_function(module, "multiply_err_e", rb_gsl_sf_multiply_err_e, 4); } gsl-1.15.3/ext/sf_dilog.c0000644000175000017500000000261512220252463014500 0ustar boutilboutil/* sf_dilog.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_dilog(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_dilog, x); } static VALUE rb_gsl_sf_dilog_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_dilog_e, x); } static VALUE rb_gsl_sf_complex_dilog_e(VALUE obj, VALUE r, VALUE theta) { gsl_sf_result *re, *im; VALUE vre, vim; // local variable "status" declared and set, but never used //int status; Need_Float(r); Need_Float(theta); vre = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, re); vim = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, im); /*status =*/ gsl_sf_complex_dilog_e(NUM2DBL(r), NUM2DBL(theta), re, im); return rb_ary_new3(2, vre, vim); } void Init_gsl_sf_dilog(VALUE module) { rb_define_module_function(module, "dilog", rb_gsl_sf_dilog, 1); rb_define_module_function(module, "dilog_e", rb_gsl_sf_dilog_e, 1); rb_define_module_function(module, "complex_dilog_e", rb_gsl_sf_complex_dilog_e, 2); } gsl-1.15.3/ext/vector_int.c0000644000175000017500000001471412220252463015071 0ustar boutilboutil/* vector_int.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Modified by Seiya Nishizawa 14/Apr/2004 Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_complex.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif VALUE rb_gsl_vector_int_inner_product(int argc, VALUE *argv, VALUE obj); VALUE rb_gsl_vector_int_do_something(VALUE obj, void (*func)(gsl_vector_int*)); static VALUE rb_gsl_vector_int_to_i(VALUE obj) { return obj; } VALUE rb_gsl_vector_int_to_f(VALUE obj) { gsl_vector_int *v; gsl_vector *vnew; size_t i; Data_Get_Struct(obj, gsl_vector_int, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) gsl_vector_set(vnew, i, (double) gsl_vector_int_get(v, i)); if (VECTOR_INT_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, vnew); else return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } static VALUE rb_gsl_vector_int_to_complex(VALUE obj) { gsl_vector_int *v; gsl_vector_complex *vnew; gsl_complex z; size_t i; Data_Get_Struct(obj, gsl_vector_int, v); vnew = gsl_vector_complex_alloc(v->size); for (i = 0; i < v->size; i++) { GSL_SET_REAL(&z, (double) gsl_vector_int_get(v, i)); GSL_SET_IMAG(&z, 0.0); gsl_vector_complex_set(vnew, i, z); } if (VECTOR_INT_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, vnew); else return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_int_coerce(VALUE obj, VALUE other) { gsl_vector_int *v = NULL, *vnew = NULL; VALUE vv; Data_Get_Struct(obj, gsl_vector_int, v); switch (TYPE(other)) { case T_FIXNUM: vnew = gsl_vector_int_alloc(v->size); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_int_alloc failed"); gsl_vector_int_set_all(vnew, FIX2INT(other)); vv = Data_Wrap_Struct(VECTOR_INT_ROW_COL(obj), 0, gsl_vector_int_free, vnew); return rb_ary_new3(2, vv, obj); break; default: return rb_ary_new3(2, other, rb_gsl_vector_int_to_f(obj)); } // return rb_ary_new3(2, other, rb_gsl_vector_int_to_f(obj)); } VALUE rb_gsl_vector_add(VALUE obj, VALUE b); VALUE rb_gsl_vector_sub(VALUE obj, VALUE b); VALUE rb_gsl_vector_mul(VALUE obj, VALUE b); VALUE rb_gsl_vector_div(VALUE obj, VALUE b); static VALUE rb_gsl_vector_int_add(VALUE obj, VALUE b) { gsl_vector_int *v, *vnew, *vb; switch (TYPE(b)) { case T_FIXNUM: return rb_gsl_vector_int_add_constant(obj, b); break; case T_FLOAT: return rb_gsl_vector_add_constant(rb_gsl_vector_int_to_f(obj), b); break; default: if (rb_obj_is_kind_of(b, cgsl_vector_int)) { Data_Get_Struct(obj, gsl_vector_int, v); Data_Get_Struct(b, gsl_vector_int, vb); vnew = gsl_vector_int_alloc(v->size); gsl_vector_int_memcpy(vnew, v); gsl_vector_int_add(vnew, vb); return Data_Wrap_Struct(VECTOR_INT_ROW_COL(obj), 0, gsl_vector_int_free, vnew); } else { return rb_gsl_vector_add(rb_gsl_vector_int_to_f(obj), b); } break; } } static VALUE rb_gsl_vector_int_sub(VALUE obj, VALUE b) { gsl_vector_int *v, *vnew, *vb; switch (TYPE(b)) { case T_FIXNUM: return rb_gsl_vector_int_add_constant(obj, INT2FIX(-FIX2INT(b))); break; case T_FLOAT: return rb_gsl_vector_add_constant(rb_gsl_vector_int_to_f(obj), rb_float_new(-NUM2DBL(b))); break; default: if (rb_obj_is_kind_of(b, cgsl_vector_int)) { Data_Get_Struct(obj, gsl_vector_int, v); Data_Get_Struct(b, gsl_vector_int, vb); vnew = gsl_vector_int_alloc(v->size); gsl_vector_int_memcpy(vnew, v); gsl_vector_int_sub(vnew, vb); return Data_Wrap_Struct(VECTOR_INT_ROW_COL(obj), 0, gsl_vector_int_free, vnew); } else { return rb_gsl_vector_sub(rb_gsl_vector_int_to_f(obj), b); } break; } } gsl_vector_int* mygsl_vector_int_mul_matrix(gsl_vector_int *v, gsl_matrix_int *m); static VALUE rb_gsl_vector_int_mul(VALUE obj, VALUE b) { VALUE argv[2]; gsl_vector_int *v, *vnew, *v2; gsl_matrix_int *m; int val; size_t i, j; switch (TYPE(b)) { case T_FIXNUM: case T_FLOAT: return rb_gsl_vector_int_scale(obj, b); break; default: if (VECTOR_INT_ROW_P(obj) && VECTOR_INT_COL_P(b)) { argv[0] = obj; argv[1] = b; return rb_gsl_vector_int_inner_product(2, argv, CLASS_OF(obj)); } else if (VECTOR_INT_ROW_P(obj) && MATRIX_INT_P(b)) { Data_Get_Struct(obj, gsl_vector_int, v); Data_Get_Struct(b, gsl_matrix_int, m); vnew = mygsl_vector_int_mul_matrix(v, m); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, vnew); } else if (VECTOR_INT_COL_P(obj) && VECTOR_INT_ROW_P(b)) { Data_Get_Struct(obj, gsl_vector_int, v); Data_Get_Struct(b, gsl_vector_int, v2); if (v->size != v2->size) rb_raise(rb_eIndexError, "Vector sizes does not match."); m = gsl_matrix_int_alloc(v->size, v2->size); for (i = 0; i < v->size; i++) { for (j = 0; j < v2->size; j++) { val = gsl_vector_int_get(v, i)*gsl_vector_int_get(v2, j); gsl_matrix_int_set(m, i, j, val); } } return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, m); } else { return rb_gsl_vector_mul(rb_gsl_vector_int_to_f(obj), b); } break; } } static VALUE rb_gsl_vector_int_div(VALUE obj, VALUE b) { return rb_gsl_vector_div(rb_gsl_vector_int_to_f(obj), b); } void Init_gsl_vector_int(VALUE module) { rb_define_method(cgsl_vector_int, "to_f", rb_gsl_vector_int_to_f, 0); rb_define_method(cgsl_vector_int, "to_i", rb_gsl_vector_int_to_i, 0); rb_define_method(cgsl_vector_int, "to_complex", rb_gsl_vector_int_to_complex, 0); /*****/ rb_define_method(cgsl_vector_int, "coerce", rb_gsl_vector_int_coerce, 1); rb_define_method(cgsl_vector_int, "add", rb_gsl_vector_int_add, 1); rb_define_method(cgsl_vector_int, "sub", rb_gsl_vector_int_sub, 1); rb_define_method(cgsl_vector_int, "mul", rb_gsl_vector_int_mul, 1); rb_define_method(cgsl_vector_int, "div", rb_gsl_vector_int_div, 1); rb_define_alias(cgsl_vector_int, "+", "add"); rb_define_alias(cgsl_vector_int, "-", "sub"); rb_define_alias(cgsl_vector_int, "*", "mul"); rb_define_alias(cgsl_vector_int, "/", "div"); Init_gsl_vector_int_init(module); } gsl-1.15.3/ext/sf_erfc.c0000644000175000017500000000504412220252463014320 0ustar boutilboutil/* sf_erfc.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_erf(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_erf, x); } static VALUE rb_gsl_sf_erf_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_erf_e, x); } static VALUE rb_gsl_sf_erfc(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_erfc, x); } static VALUE rb_gsl_sf_erfc_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_erfc_e, x); } static VALUE rb_gsl_sf_log_erfc(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_log_erfc, x); } static VALUE rb_gsl_sf_log_erfc_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_log_erfc_e, x); } static VALUE rb_gsl_sf_erf_Z(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_erf_Z, x); } static VALUE rb_gsl_sf_erf_Z_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_erf_Z_e, x); } static VALUE rb_gsl_sf_erf_Q(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_erf_Q, x); } static VALUE rb_gsl_sf_erf_Q_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_erf_Q_e, x); } #ifdef GSL_1_4_LATER static VALUE rb_gsl_sf_hazard(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_hazard, x); } static VALUE rb_gsl_sf_hazard_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_hazard_e, x); } #endif void Init_gsl_sf_erfc(VALUE module) { rb_define_module_function(module, "erf", rb_gsl_sf_erf, 1); rb_define_module_function(module, "erf_e", rb_gsl_sf_erf_e, 1); rb_define_module_function(module, "erfc", rb_gsl_sf_erfc, 1); rb_define_module_function(module, "erfc_e", rb_gsl_sf_erfc_e, 1); rb_define_module_function(module, "log_erfc", rb_gsl_sf_log_erfc, 1); rb_define_module_function(module, "log_erfc_e", rb_gsl_sf_log_erfc_e, 1); rb_define_module_function(module, "erf_Z", rb_gsl_sf_erf_Z, 1); rb_define_module_function(module, "erf_Z_e", rb_gsl_sf_erf_Z_e, 1); rb_define_module_function(module, "erf_Q", rb_gsl_sf_erf_Q, 1); rb_define_module_function(module, "erf_Q_e", rb_gsl_sf_erf_Q_e, 1); #ifdef GSL_1_4_LATER rb_define_module_function(module, "hazard", rb_gsl_sf_hazard, 1); rb_define_module_function(module, "hazard_e", rb_gsl_sf_hazard_e, 1); #endif } gsl-1.15.3/ext/sf_dawson.c0000644000175000017500000000153312220252463014673 0ustar boutilboutil/* sf_dawson.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_dawson(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_dawson, x); } static VALUE rb_gsl_sf_dawson_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_dawson_e, x); } void Init_gsl_sf_dawson(VALUE module) { rb_define_module_function(module, "dawson", rb_gsl_sf_dawson, 1); rb_define_module_function(module, "dawson_e", rb_gsl_sf_dawson_e, 1); } gsl-1.15.3/ext/fft.c0000644000175000017500000010726112220252463013474 0ustar boutilboutil/* fft.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_fft.h" VALUE mgsl_fft; VALUE cgsl_fft_wavetable; VALUE cgsl_fft_complex_wavetable, cgsl_fft_complex_workspace; VALUE cgsl_fft_real_wavetable, cgsl_fft_halfcomplex_wavetable; VALUE cgsl_fft_real_workspace; extern VALUE cgsl_vector_int; extern VALUE cgsl_vector_complex; static void GSL_FFT_Workspace_free(GSL_FFT_Workspace *space); static VALUE rb_gsl_fft_complex_wavetable_new(VALUE klass, VALUE n) { CHECK_FIXNUM(n); return Data_Wrap_Struct(cgsl_fft_complex_wavetable, 0, gsl_fft_complex_wavetable_free, gsl_fft_complex_wavetable_alloc(FIX2INT(n))); } static VALUE rb_gsl_fft_real_wavetable_new(VALUE klass, VALUE n) { CHECK_FIXNUM(n); return Data_Wrap_Struct(klass, 0, gsl_fft_real_wavetable_free, gsl_fft_real_wavetable_alloc(FIX2INT(n))); } static VALUE rb_gsl_fft_halfcomplex_wavetable_new(VALUE klass, VALUE n) { CHECK_FIXNUM(n); return Data_Wrap_Struct(klass, 0, gsl_fft_halfcomplex_wavetable_free, gsl_fft_halfcomplex_wavetable_alloc(FIX2INT(n))); } static void GSL_FFT_Wavetable_free(GSL_FFT_Wavetable *table) { gsl_fft_complex_wavetable_free((gsl_fft_complex_wavetable *) table); } static VALUE rb_gsl_fft_complex_workspace_new(VALUE klass, VALUE n) { CHECK_FIXNUM(n); return Data_Wrap_Struct(klass, 0, gsl_fft_complex_workspace_free, gsl_fft_complex_workspace_alloc(FIX2INT(n))); } static VALUE rb_gsl_fft_real_workspace_new(VALUE klass, VALUE n) { CHECK_FIXNUM(n); return Data_Wrap_Struct(klass, 0, gsl_fft_real_workspace_free, gsl_fft_real_workspace_alloc(FIX2INT(n))); } static void GSL_FFT_Workspace_free(GSL_FFT_Workspace *space) { gsl_fft_complex_workspace_free((gsl_fft_complex_workspace *) space); } // The FFT methods used to allow passing stride and n values as optional // parameters to control which elements get transformed. This created problems // for Views which can have their own stride, so support for stride and n // parameters to the transform methods is being dropped. This method used to // be called to determine the stride and n values to use based on the // parameters and/or the vector itself (depending on how many parameters were // passed). Now this function is somewhat unneceesary, but to simplify the code // refactoring, it has been left in place for the time being. Eventually it // can be refactored away completely. static VALUE get_complex_stride_n(VALUE obj, gsl_vector_complex **vin, gsl_complex_packed_array *data, size_t *stride, size_t *n) { gsl_vector_complex *v = NULL; // obj must be a GSL::Vector::Complex CHECK_VECTOR_COMPLEX(obj); Data_Get_Struct(obj, gsl_vector_complex, v); if(vin) *vin = v; *data = (gsl_complex_packed_array) v->data; *stride = v->stride; *n = v->size; return obj; } static VALUE rb_fft_complex_radix2(VALUE obj, int (*trans)(gsl_complex_packed_array, size_t, size_t), int flag) { size_t stride, n; gsl_complex_packed_array data; gsl_vector_complex *vin, *vout; VALUE ary; ary = get_complex_stride_n(obj, &vin, &data, &stride, &n); if (flag == RB_GSL_FFT_COPY) { vout = gsl_vector_complex_alloc(n); gsl_vector_complex_memcpy(vout, vin); (*trans)(vout->data, vout->stride /*1*/, vout->size /*n*/); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout); } else { /* in-place */ (*trans)(data, stride, n); return ary; } } static VALUE rb_gsl_fft_complex_radix2_forward(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_forward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_radix2_forward2(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_forward, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_complex_radix2_transform(VALUE obj, VALUE val_sign) { size_t stride, n; gsl_complex_packed_array data; gsl_fft_direction sign; gsl_vector_complex *vin, *vout; sign = NUM2INT(val_sign); get_complex_stride_n(obj, &vin, &data, &stride, &n); vout = gsl_vector_complex_alloc(n); gsl_vector_complex_memcpy(vout, vin); gsl_fft_complex_radix2_transform(vout->data, vout->stride /*1*/, vout->size /*n*/, sign); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout); } static VALUE rb_gsl_fft_complex_radix2_transform2(VALUE obj, VALUE val_sign) { size_t stride, n; gsl_complex_packed_array data; gsl_fft_direction sign; VALUE ary; sign = NUM2INT(val_sign); ary = get_complex_stride_n(obj, NULL, &data, &stride, &n); gsl_fft_complex_radix2_transform(data, stride, n, sign); return ary; } static VALUE rb_gsl_fft_complex_radix2_backward(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_backward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_radix2_inverse(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_inverse, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_radix2_dif_forward(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_dif_forward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_radix2_backward2(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_backward, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_complex_radix2_inverse2(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_inverse, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_complex_radix2_dif_forward2(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_dif_forward, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_complex_radix2_dif_transform(VALUE obj, VALUE val_sign) { size_t stride, n; gsl_complex_packed_array data; gsl_vector_complex *vin, *vout; gsl_fft_direction sign; sign = NUM2INT(val_sign); get_complex_stride_n(obj, &vin, &data, &stride, &n); vout = gsl_vector_complex_alloc(n); gsl_vector_complex_memcpy(vout, vin); gsl_fft_complex_radix2_dif_transform(vout->data, vout->stride /*1*/, vout->size /*n*/, sign); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout); } /* in-place */ static VALUE rb_gsl_fft_complex_radix2_dif_transform2(VALUE obj, VALUE val_sign) { size_t stride, n; gsl_complex_packed_array data; gsl_fft_direction sign; VALUE ary; sign = NUM2INT(val_sign); ary = get_complex_stride_n(obj, NULL, &data, &stride, &n); gsl_fft_complex_radix2_dif_transform(data, stride, n, sign); return ary; } static VALUE rb_gsl_fft_complex_radix2_dif_backward(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_dif_backward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_radix2_dif_inverse(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_dif_inverse, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_radix2_dif_backward2(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_dif_backward, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_complex_radix2_dif_inverse2(VALUE obj) { return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_dif_inverse, RB_GSL_FFT_INPLACE); } static VALUE rb_GSL_FFT_Wavetable_n(VALUE obj) { GSL_FFT_Wavetable *table; Data_Get_Struct(obj, GSL_FFT_Wavetable, table); return INT2FIX(table->n); } static VALUE rb_GSL_FFT_Wavetable_nf(VALUE obj) { GSL_FFT_Wavetable *table; Data_Get_Struct(obj, GSL_FFT_Wavetable, table); return INT2FIX(table->nf); } static VALUE rb_GSL_FFT_Wavetable_factor(VALUE obj) { GSL_FFT_Wavetable *table; gsl_vector_int *v; size_t i; Data_Get_Struct(obj, GSL_FFT_Wavetable, table); v = gsl_vector_int_alloc(table->nf); for (i = 0; i < table->nf; i++) gsl_vector_int_set(v, i, table->factor[i]); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v); } enum { NONE_OF_TWO = 0, ALLOC_SPACE = 1, ALLOC_TABLE = 2, BOTH_OF_TWO = 3, } FFTComplexStructAllocFlag; static void gsl_fft_free(int flag, GSL_FFT_Wavetable *table, GSL_FFT_Workspace *space); // Parse argc, argv. obj must be GSL::Vector::Complex. // This can be simplified at some point. // See comments preceding get_complex_stride_n() static int gsl_fft_get_argv_complex(int argc, VALUE *argv, VALUE obj, gsl_vector_complex ** vin, gsl_complex_packed_array *data, size_t *stride, size_t *n, gsl_fft_complex_wavetable **table, gsl_fft_complex_workspace **space) { int flag = NONE_OF_TWO, flagtmp, i, itmp = argc, itmp2 = 0, ccc; int flagw = 0; CHECK_VECTOR_COMPLEX(obj); ccc = argc; flagtmp = 0; flagw = 0; for (i = argc-1; i >= itmp2; i--) { if (rb_obj_is_kind_of(argv[i], cgsl_fft_complex_workspace)) { Data_Get_Struct(argv[i], gsl_fft_complex_workspace, *space); flagtmp = 1; flagw = 1; itmp = i; ccc--; break; } } flagtmp = 0; for (i = itmp-1; i >= itmp2; i--) { if (rb_obj_is_kind_of(argv[i], cgsl_fft_complex_wavetable)) { Data_Get_Struct(argv[i], gsl_fft_complex_wavetable, *table); flagtmp = 1; ccc--; break; } } get_complex_stride_n(obj, vin, data, stride, n); if (flagw == 0) { *space = gsl_fft_complex_workspace_alloc(*n); flag += ALLOC_SPACE; } if (flagtmp == 0) { *table = gsl_fft_complex_wavetable_alloc(*n); flag += ALLOC_TABLE; } if (*table == NULL) { rb_raise(rb_eRuntimeError, "something wrong with wavetable"); } if (*space == NULL) { rb_raise(rb_eRuntimeError, "something wrong with workspace"); } return flag; } // Parse argc, argv. obj must be GSL::Vector of real data static int gsl_fft_get_argv_real(int argc, VALUE *argv, VALUE obj, double **ptr, size_t *stride, size_t *n, gsl_fft_real_wavetable **table, gsl_fft_real_workspace **space, int *naflag) { int flag = NONE_OF_TWO, flagtmp, i, itmp = argc, itmp2 = 0, ccc; int flagw = 0; *naflag = 0; *ptr = get_ptr_double3(obj, n, stride, naflag); ccc = argc; flagtmp = 0; flagw = 0; for (i = argc-1; i >= itmp2; i--) { if (rb_obj_is_kind_of(argv[i], cgsl_fft_real_workspace)) { Data_Get_Struct(argv[i], gsl_fft_real_workspace, *space); flagtmp = 1; flagw = 1; itmp = i; ccc--; break; } } flagtmp = 0; for (i = itmp-1; i >= itmp2; i--) { if (rb_obj_is_kind_of(argv[i], cgsl_fft_real_wavetable)) { Data_Get_Struct(argv[i], gsl_fft_real_wavetable, *table); flagtmp = 1; ccc--; break; } } if (flagw == 0) { *space = gsl_fft_real_workspace_alloc(*n); flag += ALLOC_SPACE; } if (flagtmp == 0) { *table = gsl_fft_real_wavetable_alloc(*n); flag += ALLOC_TABLE; } if (*table == NULL) { rb_raise(rb_eRuntimeError, "something wrong with wavetable"); } if (*space == NULL) { rb_raise(rb_eRuntimeError, "something wrong with workspace"); } return flag; } // Parse argc, argv. obj must be GSL::Vector of halfcomplex data static int gsl_fft_get_argv_halfcomplex(int argc, VALUE *argv, VALUE obj, double **ptr, size_t *stride, size_t *n, gsl_fft_halfcomplex_wavetable **table, gsl_fft_real_workspace **space, int *naflag) { int flag = NONE_OF_TWO, flagtmp, i, itmp = argc, itmp2 = 0, ccc; int flagw = 0; *ptr = get_ptr_double3(obj, n, stride, naflag); ccc = argc; flagtmp = 0; flagw = 0; for (i = argc-1; i >= itmp2; i--) { if (rb_obj_is_kind_of(argv[i], cgsl_fft_real_workspace)) { Data_Get_Struct(argv[i], gsl_fft_real_workspace, *space); flagtmp = 1; flagw = 1; itmp = i; ccc--; break; } } flagtmp = 0; for (i = itmp-1; i >= itmp2; i--) { if (rb_obj_is_kind_of(argv[i], cgsl_fft_halfcomplex_wavetable)) { Data_Get_Struct(argv[i], gsl_fft_halfcomplex_wavetable, *table); flagtmp = 1; ccc--; break; } } if (flagw == 0) { *space = gsl_fft_real_workspace_alloc(*n); flag += ALLOC_SPACE; } if (flagtmp == 0) { *table = gsl_fft_halfcomplex_wavetable_alloc(*n); flag += ALLOC_TABLE; } if (*table == NULL) { rb_raise(rb_eRuntimeError, "something wrong with wavetable"); } if (*space == NULL) { rb_raise(rb_eRuntimeError, "something wrong with workspace"); } return flag; } static void gsl_fft_free(int flag, GSL_FFT_Wavetable *table, GSL_FFT_Workspace *space) { switch (flag) { case ALLOC_TABLE: GSL_FFT_Wavetable_free(table); break; case ALLOC_SPACE: GSL_FFT_Workspace_free(space); break; case BOTH_OF_TWO: GSL_FFT_Wavetable_free(table); GSL_FFT_Workspace_free(space); break; default: /* never happens */ break; } } static VALUE rb_fft_complex_trans(int argc, VALUE *argv, VALUE obj, int (*transform)(gsl_complex_packed_array, size_t, size_t, const gsl_fft_complex_wavetable *, gsl_fft_complex_workspace *), int sss) { int flag = 0; // local variable "status" was defined and set, but never used //int status; size_t stride, n; gsl_complex_packed_array data; gsl_vector_complex *vin, *vout; gsl_fft_complex_wavetable *table = NULL; gsl_fft_complex_workspace *space = NULL; flag = gsl_fft_get_argv_complex(argc, argv, obj, &vin, &data, &stride, &n, &table, &space); if (sss == RB_GSL_FFT_COPY) { vout = gsl_vector_complex_alloc(n); gsl_vector_complex_memcpy(vout, vin); /*status =*/ (*transform)(vout->data, vout->stride /*1*/, vout->size /*n*/, table, space); gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout); } else { /* in-place */ /*status =*/ (*transform)(data, stride, n, table, space); gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space); return obj; } } static VALUE rb_gsl_fft_complex_forward(int argc, VALUE *argv, VALUE obj) { return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_forward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_forward2(int argc, VALUE *argv, VALUE obj) { return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_forward, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_complex_transform(int argc, VALUE *argv, VALUE obj) { int flag = 0; // local variable "status" was defined and set, but never used //int status; size_t stride, n; gsl_vector_complex *vin, *vout; gsl_fft_direction sign; gsl_complex_packed_array data; gsl_fft_complex_wavetable *table = NULL; gsl_fft_complex_workspace *space = NULL; CHECK_FIXNUM(argv[argc-1]); sign = FIX2INT(argv[argc-1]); flag = gsl_fft_get_argv_complex(argc-1, argv, obj, &vin, &data, &stride, &n, &table, &space); vout = gsl_vector_complex_alloc(n); gsl_vector_complex_memcpy(vout, vin); /*status =*/ gsl_fft_complex_transform(vout->data, stride, n, table, space, sign); gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout); } /* in-place */ static VALUE rb_gsl_fft_complex_transform2(int argc, VALUE *argv, VALUE obj) { int flag = 0; // local variable "status" was defined and set, but never used //int status; size_t stride, n; gsl_fft_direction sign; gsl_complex_packed_array data; gsl_fft_complex_wavetable *table = NULL; gsl_fft_complex_workspace *space = NULL; CHECK_FIXNUM(argv[argc-1]); sign = FIX2INT(argv[argc-1]); flag = gsl_fft_get_argv_complex(argc-1, argv, obj, NULL, &data, &stride, &n, &table, &space); /*status =*/ gsl_fft_complex_transform(data, stride, n, table, space, sign); gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space); return obj; } static VALUE rb_gsl_fft_complex_backward(int argc, VALUE *argv, VALUE obj) { return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_backward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_backward2(int argc, VALUE *argv, VALUE obj) { return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_backward, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_complex_inverse(int argc, VALUE *argv, VALUE obj) { return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_inverse, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_complex_inverse2(int argc, VALUE *argv, VALUE obj) { return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_inverse, RB_GSL_FFT_INPLACE); } // The FFT methods used to allow passing stride and n values as optional // parameters to control which elements get transformed. This created problems // for Views which can have their own stride, so support for stride and n // parameters to the transform methods is being dropped. This method used to // be called to determine the stride and n values to use based on the // parameters and/or the vector itself (depending on how many parameters were // passed). Now this function is somewhat unneceesary, but to simplify the code // refactoring, it has been left in place for the time being. Eventually it // can be refactored away completely. // // obj must be GSL::Vector of real or halfcomplex data static VALUE get_ptr_stride_n(VALUE obj, double **ptr, size_t *stride, size_t *n, int *flag) { *flag = 0; *ptr = get_ptr_double3(obj, n, stride, flag); return obj; } static VALUE rb_fft_radix2(VALUE obj, int (*trans)(double [], size_t, size_t), int sss) { size_t stride, n; gsl_vector *vnew; gsl_vector_view vv; double *ptr1, *ptr2; int flag; #ifdef HAVE_NARRAY_H int shape[1]; #endif VALUE ary; get_ptr_stride_n(obj, &ptr1, &stride, &n, &flag); if (flag == 0) { if (sss == RB_GSL_FFT_COPY) { vnew = gsl_vector_alloc(n); vv.vector.data = ptr1; vv.vector.stride = stride; vv.vector.size = n; gsl_vector_memcpy(vnew, &vv.vector); ptr2 = vnew->data; stride = 1; ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else { ary = obj; ptr2 = ptr1; } #ifdef HAVE_NARRAY_H } else if (flag == 1) { if (sss == RB_GSL_FFT_COPY) { shape[0] = n; ary = na_make_object(NA_DFLOAT, 1, shape, cNArray); ptr2 = NA_PTR_TYPE(ary, double*); memcpy(ptr2, ptr1, sizeof(double)*n); stride = 1; } else { ary = obj; ptr2 = NA_PTR_TYPE(ary, double*); } #endif } else { rb_raise(rb_eRuntimeError, "something wrong"); } (*trans)(ptr2, stride, n); return ary; } static VALUE rb_gsl_fft_real_radix2_transform(VALUE obj) { return rb_fft_radix2(obj, gsl_fft_real_radix2_transform, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_real_radix2_transform2(VALUE obj) { return rb_fft_radix2(obj, gsl_fft_real_radix2_transform, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_halfcomplex_radix2_inverse(VALUE obj) { return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_inverse, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_halfcomplex_radix2_inverse2(VALUE obj) { return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_inverse, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_halfcomplex_radix2_backward(VALUE obj) { return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_backward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_halfcomplex_radix2_backward2(VALUE obj) { return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_backward, RB_GSL_FFT_INPLACE); } /*****/ static VALUE rb_fft_real_trans(int argc, VALUE *argv, VALUE obj, int (*trans)(double [], size_t, size_t, const gsl_fft_real_wavetable *, gsl_fft_real_workspace *), int sss) { int flag = 0, naflag = 0; // local variable "status" was defined and set, but never used //int status; size_t stride, n; gsl_vector *vnew; gsl_vector_view vv; double *ptr1, *ptr2; #ifdef HAVE_NARRAY_H int shape[1]; #endif gsl_fft_real_wavetable *table = NULL; gsl_fft_real_workspace *space = NULL; VALUE ary; flag = gsl_fft_get_argv_real(argc, argv, obj, &ptr1, &stride, &n, &table, &space, &naflag); if (naflag == 0) { if (sss == RB_GSL_FFT_COPY) { vnew = gsl_vector_alloc(n); vv.vector.data = ptr1; vv.vector.stride = stride; vv.vector.size = n; gsl_vector_memcpy(vnew, &vv.vector); ptr2 = vnew->data; stride = 1; ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else { ptr2 = ptr1; ary = obj; } #ifdef HAVE_NARRAY_H } else if (naflag == 1) { if (sss == RB_GSL_FFT_COPY) { shape[0] = n; ary = na_make_object(NA_DFLOAT, 1, shape, cNArray); ptr2 = NA_PTR_TYPE(ary, double*); memcpy(ptr2, ptr1, sizeof(double)*n); stride = 1; } else { ptr2 = ptr1; ary = obj; } #endif } else { rb_raise(rb_eRuntimeError, "something wrong"); } /*status =*/ (*trans)(ptr2, stride, n, table, space); gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space); return ary; } static VALUE rb_gsl_fft_real_transform(int argc, VALUE *argv, VALUE obj) { return rb_fft_real_trans(argc, argv, obj, gsl_fft_real_transform, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_real_transform2(int argc, VALUE *argv, VALUE obj) { return rb_fft_real_trans(argc, argv, obj, gsl_fft_real_transform, RB_GSL_FFT_INPLACE); } static VALUE rb_fft_halfcomplex_trans(int argc, VALUE *argv, VALUE obj, int (*trans)(double [], size_t, size_t, const gsl_fft_halfcomplex_wavetable *, gsl_fft_real_workspace *), int sss) { int flag = 0, naflag = 0; // local variable "status" was defined and set, but never used //int status; size_t stride, n; gsl_vector *vnew; gsl_vector_view vv; double *ptr1, *ptr2; #ifdef HAVE_NARRAY_H int shape[1]; #endif gsl_fft_halfcomplex_wavetable *table = NULL; gsl_fft_real_workspace *space = NULL; VALUE ary; flag = gsl_fft_get_argv_halfcomplex(argc, argv, obj, &ptr1, &stride, &n, &table, &space, &naflag); if (naflag == 0) { if (sss == RB_GSL_FFT_COPY) { vnew = gsl_vector_alloc(n); vv.vector.data = ptr1; vv.vector.stride = stride; vv.vector.size = n; gsl_vector_memcpy(vnew, &vv.vector); ptr2 = vnew->data; stride = 1; ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else { ptr2 = ptr1; ary = obj; } #ifdef HAVE_NARRAY_H } else if (naflag == 1) { if (sss == RB_GSL_FFT_COPY) { shape[0] = n; ary = na_make_object(NA_DFLOAT, 1, shape, cNArray); ptr2 = NA_PTR_TYPE(ary, double*); memcpy(ptr2, ptr1, sizeof(double)*n); stride = 1; } else { ptr2 = ptr1; ary = obj; } #endif } else { rb_raise(rb_eRuntimeError, "something wrong"); } /*status =*/ (*trans)(ptr2, stride, n, table, space); gsl_fft_free(flag, (GSL_FFT_Wavetable *) table, (GSL_FFT_Workspace *) space); return ary; } static VALUE rb_gsl_fft_halfcomplex_transform(int argc, VALUE *argv, VALUE obj) { return rb_fft_halfcomplex_trans(argc, argv, obj, gsl_fft_halfcomplex_transform, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_halfcomplex_transform2(int argc, VALUE *argv, VALUE obj) { return rb_fft_halfcomplex_trans(argc, argv, obj, gsl_fft_halfcomplex_transform, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_halfcomplex_backward(int argc, VALUE *argv, VALUE obj) { return rb_fft_halfcomplex_trans(argc, argv, obj, gsl_fft_halfcomplex_backward, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_halfcomplex_backward2(int argc, VALUE *argv, VALUE obj) { return rb_fft_halfcomplex_trans(argc, argv, obj, gsl_fft_halfcomplex_backward, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_halfcomplex_inverse(int argc, VALUE *argv, VALUE obj) { return rb_fft_halfcomplex_trans(argc, argv, obj, gsl_fft_halfcomplex_inverse, RB_GSL_FFT_COPY); } static VALUE rb_gsl_fft_halfcomplex_inverse2(int argc, VALUE *argv, VALUE obj) { return rb_fft_halfcomplex_trans(argc, argv, obj, gsl_fft_halfcomplex_inverse, RB_GSL_FFT_INPLACE); } static VALUE rb_gsl_fft_real_unpack(VALUE obj) { gsl_vector *v; gsl_vector_complex *vout; CHECK_VECTOR(obj); Data_Get_Struct(obj, gsl_vector, v); vout = gsl_vector_complex_alloc(v->size); gsl_fft_real_unpack(v->data, (gsl_complex_packed_array) vout->data, v->stride, v->size); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout); } static VALUE rb_gsl_fft_halfcomplex_unpack(VALUE obj) { gsl_vector *v; gsl_vector_complex *vout; CHECK_VECTOR(obj); Data_Get_Struct(obj, gsl_vector, v); vout = gsl_vector_complex_alloc(v->size); gsl_fft_halfcomplex_unpack(v->data, (gsl_complex_packed_array) vout->data, v->stride, v->size); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout); } /* Convert a halfcomplex data to Numerical Recipes style */ static VALUE rb_gsl_fft_halfcomplex_to_nrc(VALUE obj) { gsl_vector *v, *vnew; size_t i, k; CHECK_VECTOR(obj); Data_Get_Struct(obj, gsl_vector, v); vnew = gsl_vector_alloc(v->size); gsl_vector_set(vnew, 0, gsl_vector_get(v, 0)); /* DC */ gsl_vector_set(vnew, 1, gsl_vector_get(v, v->size/2)); /* Nyquist freq */ for (i = 2, k = 1; i < vnew->size; i+=2, k++) { gsl_vector_set(vnew, i, gsl_vector_get(v, k)); gsl_vector_set(vnew, i+1, -gsl_vector_get(v, v->size-k)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } static VALUE rb_gsl_fft_halfcomplex_amp_phase(VALUE obj) { gsl_vector *v; gsl_vector *amp, *phase; double re, im; VALUE vamp, vphase; size_t i; CHECK_VECTOR(obj); Data_Get_Struct(obj, gsl_vector, v); amp = gsl_vector_alloc(v->size/2); phase = gsl_vector_alloc(v->size/2); gsl_vector_set(amp, 0, gsl_vector_get(v, 0)); gsl_vector_set(phase, 0, 0); gsl_vector_set(amp, amp->size-1, gsl_vector_get(v, v->size-1)); gsl_vector_set(phase, phase->size-1, 0); for (i = 1; i < v->size-1; i+=2) { re = gsl_vector_get(v, i); im = gsl_vector_get(v, i+1); gsl_vector_set(amp, i/2+1, sqrt(re*re + im*im)); gsl_vector_set(phase, i/2+1, atan2(im, re)); } vamp = Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, amp); vphase = Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, phase); return rb_ary_new3(2, vamp, vphase); } void Init_gsl_fft(VALUE module) { mgsl_fft = rb_define_module_under(module, "FFT"); /*****/ rb_define_const(mgsl_fft, "Forward", INT2FIX(forward)); rb_define_const(mgsl_fft, "FORWARD", INT2FIX(forward)); rb_define_const(mgsl_fft, "Backward", INT2FIX(backward)); rb_define_const(mgsl_fft, "BACKWARD", INT2FIX(backward)); /* Transforms for complex vectors */ rb_define_method(cgsl_vector_complex, "radix2_forward", rb_gsl_fft_complex_radix2_forward, 0); rb_define_method(cgsl_vector_complex, "radix2_transform", rb_gsl_fft_complex_radix2_transform, 1); rb_define_method(cgsl_vector_complex, "radix2_backward", rb_gsl_fft_complex_radix2_backward, 0); rb_define_method(cgsl_vector_complex, "radix2_inverse", rb_gsl_fft_complex_radix2_inverse, 0); rb_define_method(cgsl_vector_complex, "radix2_dif_forward", rb_gsl_fft_complex_radix2_dif_forward, 0); rb_define_method(cgsl_vector_complex, "radix2_dif_transform", rb_gsl_fft_complex_radix2_dif_transform, 1); rb_define_method(cgsl_vector_complex, "radix2_dif_backward", rb_gsl_fft_complex_radix2_dif_backward, 0); rb_define_method(cgsl_vector_complex, "radix2_dif_inverse", rb_gsl_fft_complex_radix2_dif_inverse, 0); /* In-place radix-2 transforms for complex vectors */ rb_define_method(cgsl_vector_complex, "radix2_forward!", rb_gsl_fft_complex_radix2_forward2, 0); rb_define_method(cgsl_vector_complex, "radix2_transform!", rb_gsl_fft_complex_radix2_transform2, 1); rb_define_method(cgsl_vector_complex, "radix2_backward!", rb_gsl_fft_complex_radix2_backward2, 0); rb_define_method(cgsl_vector_complex, "radix2_inverse!", rb_gsl_fft_complex_radix2_inverse2, 0); rb_define_method(cgsl_vector_complex, "radix2_dif_forward!", rb_gsl_fft_complex_radix2_dif_forward2, 0); rb_define_method(cgsl_vector_complex, "radix2_dif_transform!", rb_gsl_fft_complex_radix2_dif_transform2, 1); rb_define_method(cgsl_vector_complex, "radix2_dif_backward!", rb_gsl_fft_complex_radix2_dif_backward2, 0); rb_define_method(cgsl_vector_complex, "radix2_dif_inverse!", rb_gsl_fft_complex_radix2_dif_inverse2, 0); // class GSL::FFT::Wavetable < GSL::Object // // Useful since some functionality is shared among // GSL::FFT::Complex::Wavetable // GSL::FFT::Real::Wavetable // GSL::FFT::HalfComplex::Wavetable cgsl_fft_wavetable = rb_define_class_under(mgsl_fft, "Wavetable", cGSL_Object); // No alloc // TODO Make GSL::FFT::Wavetable#initialize private? rb_define_method(cgsl_fft_wavetable, "n", rb_GSL_FFT_Wavetable_n, 0); rb_define_method(cgsl_fft_wavetable, "nf", rb_GSL_FFT_Wavetable_nf, 0); rb_define_method(cgsl_fft_wavetable, "factor", rb_GSL_FFT_Wavetable_factor, 0); // class GSL::FFT::ComplexWavetable < GSL::FFT::Wavetable cgsl_fft_complex_wavetable = rb_define_class_under(mgsl_fft, "ComplexWavetable", cgsl_fft_wavetable); rb_define_singleton_method(cgsl_fft_complex_wavetable, "alloc", rb_gsl_fft_complex_wavetable_new, 1); // class GSL::FFT::ComplexWorkspace < GSL::Object cgsl_fft_complex_workspace = rb_define_class_under(mgsl_fft, "ComplexWorkspace", cGSL_Object); rb_define_singleton_method(cgsl_fft_complex_workspace, "alloc", rb_gsl_fft_complex_workspace_new, 1); rb_define_method(cgsl_vector_complex, "forward", rb_gsl_fft_complex_forward, -1); rb_define_method(cgsl_vector_complex, "transform", rb_gsl_fft_complex_transform, -1); rb_define_method(cgsl_vector_complex, "backward", rb_gsl_fft_complex_backward, -1); rb_define_method(cgsl_vector_complex, "inverse", rb_gsl_fft_complex_inverse, -1); rb_define_method(cgsl_vector_complex, "forward!", rb_gsl_fft_complex_forward2, -1); rb_define_method(cgsl_vector_complex, "transform!", rb_gsl_fft_complex_transform2, -1); rb_define_method(cgsl_vector_complex, "backward!", rb_gsl_fft_complex_backward2, -1); rb_define_method(cgsl_vector_complex, "inverse!", rb_gsl_fft_complex_inverse2, -1); /*****/ // TODO Do these method names need the "real_" and "halfcomplex_" prefixes? rb_define_method(cgsl_vector, "real_radix2_transform", rb_gsl_fft_real_radix2_transform, 0); rb_define_alias(cgsl_vector, "radix2_transform", "real_radix2_transform"); rb_define_alias(cgsl_vector, "radix2_forward", "real_radix2_transform"); rb_define_method(cgsl_vector, "real_radix2_inverse", rb_gsl_fft_halfcomplex_radix2_inverse, 0); rb_define_alias(cgsl_vector, "radix2_inverse", "real_radix2_inverse"); rb_define_alias(cgsl_vector, "halfcomplex_radix2_inverse", "real_radix2_inverse"); rb_define_method(cgsl_vector, "real_radix2_backward", rb_gsl_fft_halfcomplex_radix2_backward, 0); rb_define_alias(cgsl_vector, "radix2_backward", "real_radix2_backward"); rb_define_alias(cgsl_vector, "halfcomplex_radix2_backward", "real_radix2_backward"); // TODO Do these method names need the "real_" and "halfcomplex_" prefixes? rb_define_method(cgsl_vector, "real_radix2_transform!", rb_gsl_fft_real_radix2_transform2, 0); rb_define_alias(cgsl_vector, "radix2_transform!", "real_radix2_transform!"); rb_define_alias(cgsl_vector, "radix2_forward!", "real_radix2_transform!"); rb_define_method(cgsl_vector, "real_radix2_inverse!", rb_gsl_fft_halfcomplex_radix2_inverse2, 0); rb_define_alias(cgsl_vector, "radix2_inverse!", "real_radix2_inverse!"); rb_define_alias(cgsl_vector, "halfcomplex_radix2_inverse!", "real_radix2_inverse!"); rb_define_method(cgsl_vector, "real_radix2_backward!", rb_gsl_fft_halfcomplex_radix2_backward2, 0); rb_define_alias(cgsl_vector, "radix2_backward!", "real_radix2_backward!"); rb_define_alias(cgsl_vector, "halfcomplex_radix2_backward!", "real_radix2_backward!"); /*****/ // class GSL::FFT::RealWavetable < GSL::FFT::Wavetable cgsl_fft_real_wavetable = rb_define_class_under(mgsl_fft, "RealWavetable", cgsl_fft_wavetable); rb_define_singleton_method(cgsl_fft_real_wavetable, "alloc", rb_gsl_fft_real_wavetable_new, 1); // class GSL::FFT::HalfComplexWavetable < GSL::FFT::Wavetable cgsl_fft_halfcomplex_wavetable = rb_define_class_under(mgsl_fft, "HalfComplexWavetable", cgsl_fft_wavetable); rb_define_singleton_method(cgsl_fft_halfcomplex_wavetable, "alloc", rb_gsl_fft_halfcomplex_wavetable_new, 1); /*****/ // class GSL::FFT::RealWorkspace < GSL::Object cgsl_fft_real_workspace = rb_define_class_under(mgsl_fft, "RealWorkspace", cGSL_Object); rb_define_singleton_method(cgsl_fft_real_workspace, "alloc", rb_gsl_fft_real_workspace_new, 1); /*****/ // TODO Do these method names need the "real_" and "halfcomplex_" prefixes? rb_define_method(cgsl_vector, "real_transform", rb_gsl_fft_real_transform, -1); rb_define_alias(cgsl_vector, "transform", "real_transform"); rb_define_alias(cgsl_vector, "forward", "real_transform"); rb_define_alias(cgsl_vector, "fft_forward", "real_transform"); rb_define_alias(cgsl_vector, "fft", "real_transform"); rb_define_method(cgsl_vector, "halfcomplex_transform", rb_gsl_fft_halfcomplex_transform, -1); rb_define_method(cgsl_vector, "halfcomplex_backward", rb_gsl_fft_halfcomplex_backward, -1); rb_define_alias(cgsl_vector, "backward", "halfcomplex_backward"); rb_define_alias(cgsl_vector, "fft_backward", "halfcomplex_backward"); rb_define_method(cgsl_vector, "halfcomplex_inverse", rb_gsl_fft_halfcomplex_inverse, -1); rb_define_alias(cgsl_vector, "fft_inverse", "halfcomplex_inverse"); rb_define_alias(cgsl_vector, "ifft", "halfcomplex_inverse"); rb_define_alias(cgsl_vector, "inverse", "halfcomplex_inverse"); rb_define_method(cgsl_vector, "real_transform!", rb_gsl_fft_real_transform2, -1); rb_define_alias(cgsl_vector, "transform!", "real_transform!"); rb_define_alias(cgsl_vector, "forward!", "real_transform!"); rb_define_alias(cgsl_vector, "fft_forward!", "real_transform!"); rb_define_alias(cgsl_vector, "fft!", "real_transform!"); rb_define_method(cgsl_vector, "halfcomplex_transform!", rb_gsl_fft_halfcomplex_transform2, -1); rb_define_method(cgsl_vector, "halfcomplex_backward!", rb_gsl_fft_halfcomplex_backward2, -1); rb_define_alias(cgsl_vector, "backward!", "halfcomplex_backward!"); rb_define_alias(cgsl_vector, "fft_backward!", "halfcomplex_backward!"); rb_define_method(cgsl_vector, "halfcomplex_inverse!", rb_gsl_fft_halfcomplex_inverse2, -1); rb_define_alias(cgsl_vector, "fft_inverse!", "halfcomplex_inverse!"); rb_define_alias(cgsl_vector, "ifft!", "halfcomplex_inverse!"); rb_define_alias(cgsl_vector, "inverse!", "halfcomplex_inverse!"); /***/ rb_define_method(cgsl_vector, "fft_real_unpack", rb_gsl_fft_real_unpack, 0); rb_define_alias(cgsl_vector, "real_unpack", "fft_real_unpack"); rb_define_alias(cgsl_vector, "real_to_complex", "fft_real_unpack"); rb_define_alias(cgsl_vector, "r_to_c", "fft_real_unpack"); rb_define_method(cgsl_vector, "fft_halfcomplex_unpack", rb_gsl_fft_halfcomplex_unpack, 0); rb_define_alias(cgsl_vector, "halfcomplex_unpack", "fft_halfcomplex_unpack"); rb_define_alias(cgsl_vector, "halfcomplex_to_complex", "fft_halfcomplex_unpack"); rb_define_alias(cgsl_vector, "hc_to_c", "fft_halfcomplex_unpack"); /*****/ rb_define_method(cgsl_vector, "to_nrc_order", rb_gsl_fft_halfcomplex_to_nrc, 0); rb_define_method(cgsl_vector, "halfcomplex_amp_phase", rb_gsl_fft_halfcomplex_amp_phase, 0); rb_define_alias(cgsl_vector, "hc_amp_phase", "halfcomplex_amp_phase"); } gsl-1.15.3/ext/sf_clausen.c0000644000175000017500000000141112220252463015025 0ustar boutilboutil/* sf_clausen.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_clausen(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_clausen, x); } static VALUE rb_gsl_sf_clausen_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_clausen_e, x); } void Init_gsl_sf_clausen(VALUE module) { rb_define_module_function(module, "clausen", rb_gsl_sf_clausen, 1); rb_define_module_function(module, "clausen_e", rb_gsl_sf_clausen_e, 1); } gsl-1.15.3/ext/blas2.c0000644000175000017500000010531112220252463013712 0ustar boutilboutil/* blas2.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include #include "rb_gsl_common.h" #include "rb_gsl_complex.h" #include "rb_gsl_array.h" static void define_const(VALUE module); static void define_const(VALUE module) { rb_define_const(module, "CblasRowMajor", INT2FIX(CblasRowMajor)); rb_define_const(module, "CblasColMajor", INT2FIX(CblasColMajor)); rb_define_const(module, "RowMajor", INT2FIX(CblasRowMajor)); rb_define_const(module, "ColMajor", INT2FIX(CblasColMajor)); rb_define_const(module, "CblasNoTrans", INT2FIX(CblasNoTrans)); rb_define_const(module, "CblasTrans", INT2FIX(CblasTrans)); rb_define_const(module, "CblasConjTrans", INT2FIX(CblasConjTrans)); rb_define_const(module, "NoTrans", INT2FIX(CblasNoTrans)); rb_define_const(module, "Trans", INT2FIX(CblasTrans)); rb_define_const(module, "ConjTrans", INT2FIX(CblasConjTrans)); rb_define_const(module, "CblasUpper", INT2FIX(CblasUpper)); rb_define_const(module, "CblasLower", INT2FIX(CblasLower)); rb_define_const(module, "Upper", INT2FIX(CblasUpper)); rb_define_const(module, "Lower", INT2FIX(CblasLower)); rb_define_const(module, "CblasNonUnit", INT2FIX(CblasNonUnit)); rb_define_const(module, "CblasUnit", INT2FIX(CblasUnit)); rb_define_const(module, "NonUnit", INT2FIX(CblasNonUnit)); rb_define_const(module, "Unit", INT2FIX(CblasUnit)); rb_define_const(module, "CblasLeft", INT2FIX(CblasLeft)); rb_define_const(module, "CblasRight", INT2FIX(CblasRight)); rb_define_const(module, "Left", INT2FIX(CblasLeft)); rb_define_const(module, "Right", INT2FIX(CblasRight)); } static VALUE rb_gsl_blas_dgemv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *y = NULL; double a, b; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_MATRIX(argv[2]); CHECK_VECTOR(argv[3]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_VECTOR(argv[2]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_vector, x); istart = 3; break; } switch (argc - istart) { case 2: Need_Float(argv[istart]); CHECK_VECTOR(argv[istart+1]); b = NUM2DBL(argv[istart]); Data_Get_Struct(argv[istart+1], gsl_vector, y); break; case 0: b = 0.0; y = gsl_vector_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } gsl_blas_dgemv(type, a, A, x, b, y); if (flag == 1) return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, y); else return argv[argc-1]; } static VALUE rb_gsl_blas_dgemv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *y, *ynew; double a, b; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_MATRIX(argv[2]); CHECK_VECTOR(argv[3]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_VECTOR(argv[2]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_vector, x); istart = 3; break; } switch (argc - istart) { case 2: Need_Float(argv[istart]); CHECK_VECTOR(argv[istart+1]); b = NUM2DBL(argv[istart]); Data_Get_Struct(argv[istart+1], gsl_vector, y); break; case 0: b = 0.0; y = gsl_vector_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } ynew = gsl_vector_alloc(y->size); gsl_vector_memcpy(ynew, y); gsl_blas_dgemv(type, a, A, x, b, ynew); if (flag == 1) gsl_vector_free(y); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, ynew); } static VALUE rb_gsl_blas_zgemv(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a, *b, z; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_MATRIX_COMPLEX(argv[2]); CHECK_VECTOR_COMPLEX(argv[3]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix_complex, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_VECTOR_COMPLEX(argv[2]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_vector_complex, x); istart = 3; break; } switch (argc - istart) { case 2: CHECK_COMPLEX(argv[istart]); CHECK_VECTOR_COMPLEX(argv[istart+1]); Data_Get_Struct(argv[istart], gsl_complex, b); Data_Get_Struct(argv[istart+1], gsl_vector_complex, y); break; case 0: z = gsl_complex_rect(0.0, 0.0); b = &z; y = gsl_vector_complex_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } gsl_blas_zgemv(type, *a, A, x, *b, y); if (flag == 1) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, y); else return argv[argc-1]; } static VALUE rb_gsl_blas_zgemv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *y, *ynew; gsl_complex *a, *b, z; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_MATRIX_COMPLEX(argv[2]); CHECK_VECTOR_COMPLEX(argv[3]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix_complex, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_VECTOR_COMPLEX(argv[2]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_vector_complex, x); istart = 3; break; } switch (argc - istart) { case 2: CHECK_COMPLEX(argv[istart]); CHECK_VECTOR_COMPLEX(argv[istart+1]); Data_Get_Struct(argv[istart], gsl_complex, b); Data_Get_Struct(argv[istart+1], gsl_vector_complex, y); break; case 0: z = gsl_complex_rect(0.0, 0.0); b = &z; y = gsl_vector_complex_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } ynew = gsl_vector_complex_alloc(y->size); gsl_vector_complex_memcpy(ynew, y); gsl_blas_zgemv(type, *a, A, x, *b, ynew); if (flag == 1) gsl_vector_complex_free(y); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, ynew); } static VALUE rb_gsl_blas_dtrmv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX(argv[3]); CHECK_VECTOR(argv[4]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_vector, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR(argv[3]); Data_Get_Struct(obj, gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); gsl_blas_dtrmv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, x); return argv[argc-1]; } static VALUE rb_gsl_blas_dtrmv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *xnew; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX(argv[3]); CHECK_VECTOR(argv[4]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_vector, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR(argv[3]); Data_Get_Struct(obj, gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); xnew = gsl_vector_alloc(x->size); gsl_vector_memcpy(xnew, x); gsl_blas_dtrmv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, xnew); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew); } static VALUE rb_gsl_blas_ztrmv(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_VECTOR_COMPLEX(argv[4]); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_vector_complex, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR_COMPLEX(argv[3]); Data_Get_Struct(obj, gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); gsl_blas_ztrmv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, x); return argv[argc-1]; } static VALUE rb_gsl_blas_ztrmv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *xnew; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_VECTOR_COMPLEX(argv[4]); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_vector_complex, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR_COMPLEX(argv[3]); Data_Get_Struct(obj, gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); xnew = gsl_vector_complex_alloc(x->size); gsl_vector_complex_memcpy(xnew, x); gsl_blas_ztrmv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, xnew); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, xnew); } static VALUE rb_gsl_blas_dtrsv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX(argv[3]); CHECK_VECTOR(argv[4]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_vector, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR(argv[3]); Data_Get_Struct(obj, gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); gsl_blas_dtrsv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, x); return argv[argc-1]; } static VALUE rb_gsl_blas_dtrsv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *xnew; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX(argv[3]); CHECK_VECTOR(argv[4]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_vector, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR(argv[3]); Data_Get_Struct(obj, gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); xnew = gsl_vector_alloc(x->size); gsl_vector_memcpy(xnew, x); gsl_blas_dtrsv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, xnew); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew); } static VALUE rb_gsl_blas_ztrsv(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_VECTOR_COMPLEX(argv[4]); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_vector_complex, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR_COMPLEX(argv[3]); Data_Get_Struct(obj, gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); gsl_blas_ztrsv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, x); return argv[argc-1]; } static VALUE rb_gsl_blas_ztrsv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *xnew; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 5)", argc); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_VECTOR_COMPLEX(argv[4]); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_vector_complex, x); break; default: if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); CHECK_VECTOR_COMPLEX(argv[3]); Data_Get_Struct(obj, gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); break; } CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); xnew = gsl_vector_complex_alloc(x->size); gsl_vector_complex_memcpy(xnew, x); gsl_blas_ztrsv(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), A, xnew); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, xnew); } static VALUE rb_gsl_blas_dsymv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *y = NULL; double a, b; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_MATRIX(argv[2]); CHECK_VECTOR(argv[3]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_VECTOR(argv[2]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_vector, x); istart = 3; break; } switch (argc - istart) { case 2: Need_Float(argv[istart]); CHECK_VECTOR(argv[istart+1]); b = NUM2DBL(argv[istart]); Data_Get_Struct(argv[istart+1], gsl_vector, y); break; case 0: b = 0.0; y = gsl_vector_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } gsl_blas_dsymv(type, a, A, x, b, y); if (flag == 1) return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, y); else return argv[argc-1]; } static VALUE rb_gsl_blas_dsymv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *y, *ynew; double a, b; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_MATRIX(argv[2]); CHECK_VECTOR(argv[3]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_matrix, A); Data_Get_Struct(argv[3], gsl_vector, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); CHECK_VECTOR(argv[2]); type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_vector, x); istart = 3; break; } switch (argc - istart) { case 2: Need_Float(argv[istart]); CHECK_VECTOR(argv[istart+1]); b = NUM2DBL(argv[istart]); Data_Get_Struct(argv[istart+1], gsl_vector, y); break; case 0: b = 0.0; y = gsl_vector_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } ynew = gsl_vector_alloc(y->size); gsl_vector_memcpy(ynew, y); gsl_blas_dsymv(type, a, A, x, b, ynew); if (flag == 1) gsl_vector_free(y); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, ynew); } static VALUE rb_gsl_blas_zhemv(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a, *b, z; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_MATRIX_COMPLEX(argv[2]); CHECK_VECTOR_COMPLEX(argv[3]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix_complex, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_VECTOR_COMPLEX(argv[2]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_vector_complex, x); istart = 3; break; } switch (argc - istart) { case 2: CHECK_COMPLEX(argv[istart]); CHECK_VECTOR_COMPLEX(argv[istart+1]); Data_Get_Struct(argv[istart], gsl_complex, b); Data_Get_Struct(argv[istart+1], gsl_vector_complex, y); break; case 0: z = gsl_complex_rect(0.0, 0.0); b = &z; y = gsl_vector_complex_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } gsl_blas_zhemv(type, *a, A, x, *b, y); if (flag == 1) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, y); else return argv[argc-1]; } static VALUE rb_gsl_blas_zhemv2(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *y, *ynew; gsl_complex *a, *b, z; int type, istart, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_MATRIX_COMPLEX(argv[2]); CHECK_VECTOR_COMPLEX(argv[3]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_matrix_complex, A); Data_Get_Struct(argv[3], gsl_vector_complex, x); istart = 4; break; default: Data_Get_Struct(obj, gsl_matrix_complex, A); if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 3)", argc); CHECK_FIXNUM(argv[0]); CHECK_COMPLEX(argv[1]); CHECK_VECTOR_COMPLEX(argv[2]); type = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_complex, a); Data_Get_Struct(argv[2], gsl_vector_complex, x); istart = 3; break; } switch (argc - istart) { case 2: CHECK_COMPLEX(argv[istart]); CHECK_VECTOR_COMPLEX(argv[istart+1]); Data_Get_Struct(argv[istart], gsl_complex, b); Data_Get_Struct(argv[istart+1], gsl_vector_complex, y); break; case 0: z = gsl_complex_rect(0.0, 0.0); b = &z; y = gsl_vector_complex_alloc(x->size); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } ynew = gsl_vector_complex_alloc(y->size); gsl_vector_complex_memcpy(ynew, y); gsl_blas_zhemv(type, *a, A, x, *b, ynew); if (flag == 1) gsl_vector_complex_free(y); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, ynew); } static VALUE rb_gsl_blas_dger(VALUE obj, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *y = NULL; double a; Need_Float(aa); CHECK_VECTOR(xx); CHECK_VECTOR(yy); CHECK_MATRIX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); Data_Get_Struct(AA, gsl_matrix, A); gsl_blas_dger(a, x, y, A); return AA; } static VALUE rb_gsl_blas_dger2(VALUE obj, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix *A = NULL, *Anew = NULL; gsl_vector *x = NULL, *y = NULL; double a; Need_Float(aa); CHECK_VECTOR(xx); CHECK_VECTOR(yy); CHECK_MATRIX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); Data_Get_Struct(AA, gsl_matrix, A); Anew = gsl_matrix_alloc(A->size1, A->size2); gsl_matrix_memcpy(Anew, A); gsl_blas_dger(a, x, y, Anew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Anew); } static VALUE rb_gsl_blas_zgeru(VALUE obj, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a; CHECK_COMPLEX(aa); CHECK_VECTOR_COMPLEX(xx);CHECK_VECTOR_COMPLEX(yy); CHECK_MATRIX_COMPLEX(AA); Data_Get_Struct(aa, gsl_complex, a); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(yy, gsl_vector_complex, y); Data_Get_Struct(AA, gsl_matrix_complex, A); gsl_blas_zgeru(*a, x, y, A); return AA; } static VALUE rb_gsl_blas_zgeru2(VALUE obj, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix_complex *A = NULL, *Anew = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a; CHECK_COMPLEX(aa); CHECK_VECTOR_COMPLEX(xx);CHECK_VECTOR_COMPLEX(yy); CHECK_MATRIX_COMPLEX(AA); Data_Get_Struct(aa, gsl_complex, a); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(yy, gsl_vector_complex, y); Data_Get_Struct(AA, gsl_matrix_complex, A); Anew = gsl_matrix_complex_alloc(A->size1, A->size2); gsl_matrix_complex_memcpy(Anew, A); gsl_blas_zgeru(*a, x, y, Anew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Anew); } static VALUE rb_gsl_blas_zgerc(VALUE obj, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a; CHECK_COMPLEX(aa); CHECK_VECTOR_COMPLEX(xx);CHECK_VECTOR_COMPLEX(yy); CHECK_MATRIX_COMPLEX(AA); Data_Get_Struct(aa, gsl_complex, a); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(yy, gsl_vector_complex, y); Data_Get_Struct(AA, gsl_matrix_complex, A); gsl_blas_zgerc(*a, x, y, A); return AA; } static VALUE rb_gsl_blas_zgerc2(VALUE obj, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix_complex *A = NULL, *Anew = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a; CHECK_COMPLEX(aa); CHECK_VECTOR_COMPLEX(xx);CHECK_VECTOR_COMPLEX(yy); CHECK_MATRIX_COMPLEX(AA); Data_Get_Struct(aa, gsl_complex, a); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(yy, gsl_vector_complex, y); Data_Get_Struct(AA, gsl_matrix_complex, A); Anew = gsl_matrix_complex_alloc(A->size1, A->size2); gsl_matrix_complex_memcpy(Anew, A); gsl_blas_zgerc(*a, x, y, Anew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Anew); } static VALUE rb_gsl_blas_dsyr(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE AA) { gsl_matrix *A = NULL; gsl_vector *x = NULL; double a; CHECK_FIXNUM(tt); Need_Float(aa); CHECK_VECTOR(xx); CHECK_MATRIX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(AA, gsl_matrix, A); gsl_blas_dsyr(FIX2INT(tt), a, x, A); return AA; } static VALUE rb_gsl_blas_dsyr_a(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE AA) { gsl_matrix *A = NULL, *Anew = NULL; gsl_vector *x = NULL; double a; CHECK_FIXNUM(tt); Need_Float(aa); CHECK_VECTOR(xx); CHECK_MATRIX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(AA, gsl_matrix, A); Anew = gsl_matrix_alloc(A->size1, A->size2); gsl_matrix_memcpy(Anew, A); gsl_blas_dsyr(FIX2INT(tt), a, x, Anew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Anew); } static VALUE rb_gsl_blas_zher(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE AA) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL; double a; CHECK_FIXNUM(tt); Need_Float(aa); CHECK_VECTOR_COMPLEX(xx); CHECK_MATRIX_COMPLEX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(AA, gsl_matrix_complex, A); gsl_blas_zher(FIX2INT(tt), a, x, A); return AA; } static VALUE rb_gsl_blas_zher_a(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE AA) { gsl_matrix_complex *A = NULL, *Anew = NULL; gsl_vector_complex *x = NULL; double a; CHECK_FIXNUM(tt); Need_Float(aa); CHECK_VECTOR_COMPLEX(xx); CHECK_MATRIX_COMPLEX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(AA, gsl_matrix_complex, A); Anew = gsl_matrix_complex_alloc(A->size1, A->size2); gsl_matrix_complex_memcpy(Anew, A); gsl_blas_zher(FIX2INT(tt), a, x, Anew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Anew); } static VALUE rb_gsl_blas_dsyr2(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix *A = NULL; gsl_vector *x = NULL, *y = NULL; double a; CHECK_FIXNUM(tt); Need_Float(aa); CHECK_VECTOR(xx); CHECK_VECTOR(yy); CHECK_MATRIX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); Data_Get_Struct(AA, gsl_matrix, A); gsl_blas_dsyr2(FIX2INT(tt), a, x, y, A); return AA; } static VALUE rb_gsl_blas_dsyr2_a(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix *A = NULL, *Anew = NULL; gsl_vector *x = NULL, *y = NULL; double a; CHECK_FIXNUM(tt); Need_Float(aa); CHECK_VECTOR(xx); CHECK_VECTOR(yy); CHECK_MATRIX(AA); a = NUM2DBL(aa); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); Data_Get_Struct(AA, gsl_matrix, A); Anew = gsl_matrix_alloc(A->size1, A->size2); gsl_matrix_memcpy(Anew, A); gsl_blas_dsyr2(FIX2INT(tt), a, x, y, Anew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Anew); } static VALUE rb_gsl_blas_zher2(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix_complex *A = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a; CHECK_FIXNUM(tt); CHECK_COMPLEX(aa); CHECK_VECTOR_COMPLEX(xx); CHECK_VECTOR_COMPLEX(yy); CHECK_MATRIX_COMPLEX(AA); Data_Get_Struct(aa, gsl_complex, a); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(yy, gsl_vector_complex, y); Data_Get_Struct(AA, gsl_matrix_complex, A); gsl_blas_zher2(FIX2INT(tt), *a, x, y, A); return AA; } static VALUE rb_gsl_blas_zher2_a(VALUE obj, VALUE tt, VALUE aa, VALUE xx, VALUE yy, VALUE AA) { gsl_matrix_complex *A = NULL, *Anew = NULL; gsl_vector_complex *x = NULL, *y = NULL; gsl_complex *a; CHECK_FIXNUM(tt); CHECK_COMPLEX(aa); CHECK_VECTOR_COMPLEX(xx); CHECK_VECTOR_COMPLEX(yy); CHECK_MATRIX_COMPLEX(AA); Data_Get_Struct(aa, gsl_complex, a); Data_Get_Struct(xx, gsl_vector_complex, x); Data_Get_Struct(yy, gsl_vector_complex, y); Data_Get_Struct(AA, gsl_matrix_complex, A); Anew = gsl_matrix_complex_alloc(A->size1, A->size2); gsl_matrix_complex_memcpy(Anew, A); gsl_blas_zher2(FIX2INT(tt), *a, x, y, Anew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Anew); } void Init_gsl_blas2(VALUE module) { define_const(module); rb_define_module_function(module, "dgemv!", rb_gsl_blas_dgemv, -1); rb_define_method(cgsl_matrix, "blas_dgemv!", rb_gsl_blas_dgemv, -1); rb_define_alias(cgsl_matrix, "dgemv!", "blas_dgemv!"); rb_define_alias(cgsl_matrix, "gemv!", "blas_dgemv!"); rb_define_module_function(module, "dgemv", rb_gsl_blas_dgemv2, -1); rb_define_method(cgsl_matrix, "blas_dgemv", rb_gsl_blas_dgemv2, -1); rb_define_alias(cgsl_matrix, "dgemv", "blas_dgemv"); rb_define_alias(cgsl_matrix, "gemv", "blas_dgemv"); rb_define_module_function(module, "zgemv!", rb_gsl_blas_zgemv, -1); rb_define_method(cgsl_matrix_complex, "blas_zgemv!", rb_gsl_blas_zgemv, -1); rb_define_alias(cgsl_matrix_complex, "zgemv!", "blas_zgemv!"); rb_define_alias(cgsl_matrix_complex, "gemv!", "blas_zgemv!"); rb_define_module_function(module, "zgemv", rb_gsl_blas_zgemv2, -1); rb_define_method(cgsl_matrix_complex, "blas_zgemv", rb_gsl_blas_zgemv2, -1); rb_define_alias(cgsl_matrix_complex, "zgemv", "blas_zgemv"); rb_define_alias(cgsl_matrix_complex, "gemv", "blas_zgemv"); rb_define_module_function(module, "dtrmv!", rb_gsl_blas_dtrmv, -1); rb_define_method(cgsl_matrix, "blas_dtrmv!", rb_gsl_blas_dtrmv, -1); rb_define_alias(cgsl_matrix, "dtrmv!", "blas_dtrmv!"); rb_define_alias(cgsl_matrix, "trmv!", "blas_dtrmv!"); rb_define_module_function(module, "dtrmv", rb_gsl_blas_dtrmv2, -1); rb_define_method(cgsl_matrix, "blas_dtrmv", rb_gsl_blas_dtrmv2, -1); rb_define_alias(cgsl_matrix, "dtrmv", "blas_dtrmv"); rb_define_alias(cgsl_matrix, "trmv", "blas_dtrmv"); rb_define_module_function(module, "ztrmv!", rb_gsl_blas_ztrmv, -1); rb_define_method(cgsl_matrix_complex, "blas_ztrmv!", rb_gsl_blas_ztrmv, -1); rb_define_alias(cgsl_matrix_complex, "ztrmv!", "blas_ztrmv!"); rb_define_module_function(module, "ztrmv", rb_gsl_blas_ztrmv2, -1); rb_define_method(cgsl_matrix_complex, "blas_ztrmv", rb_gsl_blas_ztrmv2, -1); rb_define_alias(cgsl_matrix_complex, "ztrmv", "blas_ztrmv"); rb_define_alias(cgsl_matrix_complex, "trmv", "blas_ztrmv"); rb_define_module_function(module, "dtrsv!", rb_gsl_blas_dtrsv, -1); rb_define_method(cgsl_matrix, "blas_dtrsv!", rb_gsl_blas_dtrsv, -1); rb_define_alias(cgsl_matrix, "dtrsv!", "blas_dtrsv!"); rb_define_alias(cgsl_matrix, "trsv!", "blas_dtrsv!"); rb_define_module_function(module, "dtrsv", rb_gsl_blas_dtrsv2, -1); rb_define_method(cgsl_matrix, "blas_dtrsv", rb_gsl_blas_dtrsv2, -1); rb_define_alias(cgsl_matrix, "dtrsv", "blas_dtrsv"); rb_define_alias(cgsl_matrix, "trsv", "blas_dtrsv"); rb_define_module_function(module, "ztrsv!", rb_gsl_blas_ztrsv, -1); rb_define_method(cgsl_matrix_complex, "blas_ztrsv!", rb_gsl_blas_ztrsv, -1); rb_define_alias(cgsl_matrix_complex, "ztrsv!", "blas_ztrsv!"); rb_define_alias(cgsl_matrix_complex, "trsv!", "blas_ztrsv!"); rb_define_module_function(module, "ztrsv", rb_gsl_blas_ztrsv2, -1); rb_define_method(cgsl_matrix_complex, "blas_ztrsv", rb_gsl_blas_ztrsv2, -1); rb_define_alias(cgsl_matrix_complex, "ztrsv", "blas_ztrsv"); rb_define_alias(cgsl_matrix_complex, "trsv", "blas_ztrsv"); rb_define_module_function(module, "dsymv!", rb_gsl_blas_dsymv, -1); rb_define_method(cgsl_matrix, "blas_dsymv!", rb_gsl_blas_dsymv, -1); rb_define_alias(cgsl_matrix, "dsymv!", "blas_dsymv!"); rb_define_alias(cgsl_matrix, "symv!", "blas_dsymv!"); rb_define_module_function(module, "dsymv", rb_gsl_blas_dsymv2, -1); rb_define_method(cgsl_matrix, "blas_dsymv", rb_gsl_blas_dsymv2, -1); rb_define_alias(cgsl_matrix, "dsymv", "blas_dsymv"); rb_define_alias(cgsl_matrix, "symv", "blas_dsymv"); rb_define_module_function(module, "zhemv!", rb_gsl_blas_zhemv, -1); rb_define_method(cgsl_matrix_complex, "blas_zhemv!", rb_gsl_blas_zhemv, -1); rb_define_alias(cgsl_matrix_complex, "zhemv!", "blas_zhemv!"); rb_define_alias(cgsl_matrix_complex, "symv!", "blas_zhemv!"); rb_define_module_function(module, "zhemv", rb_gsl_blas_zhemv2, -1); rb_define_method(cgsl_matrix_complex, "blas_zhemv", rb_gsl_blas_zhemv2, -1); rb_define_alias(cgsl_matrix_complex, "zhemv", "blas_zhemv"); rb_define_alias(cgsl_matrix_complex, "symv", "blas_zhemv"); rb_define_module_function(module, "dger!", rb_gsl_blas_dger, 4); rb_define_module_function(module, "dger", rb_gsl_blas_dger2, 4); rb_define_module_function(module, "zgeru!", rb_gsl_blas_zgeru, 4); rb_define_module_function(module, "zgeru", rb_gsl_blas_zgeru2, 4); rb_define_module_function(module, "zgerc!", rb_gsl_blas_zgerc, 4); rb_define_module_function(module, "zgerc", rb_gsl_blas_zgerc2, 4); rb_define_module_function(module, "dsyr!", rb_gsl_blas_dsyr, 4); rb_define_module_function(module, "dsyr", rb_gsl_blas_dsyr_a, 4); rb_define_module_function(module, "zher!", rb_gsl_blas_zher, 4); rb_define_module_function(module, "zher", rb_gsl_blas_zher_a, 4); rb_define_module_function(module, "dsyr2!", rb_gsl_blas_dsyr2, 4); rb_define_module_function(module, "dsyr2", rb_gsl_blas_dsyr2_a, 4); rb_define_module_function(module, "zher2!", rb_gsl_blas_zher2, 4); rb_define_module_function(module, "zher2", rb_gsl_blas_zher2_a, 4); } gsl-1.15.3/ext/combination.c0000644000175000017500000002060412220252463015212 0ustar boutilboutil/* combination.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #ifdef GSL_1_1_LATER #include "rb_gsl_common.h" #include "rb_gsl_array.h" static VALUE cgsl_combination_data; static VALUE rb_gsl_combination_new(VALUE klass, VALUE n, VALUE k) { gsl_combination *c = NULL; CHECK_FIXNUM(n);CHECK_FIXNUM(k); c = gsl_combination_alloc(FIX2INT(n), FIX2INT(k)); return Data_Wrap_Struct(klass, 0, gsl_combination_free, c); } static VALUE rb_gsl_combination_calloc(VALUE klass, VALUE n, VALUE k) { gsl_combination *c = NULL; CHECK_FIXNUM(n);CHECK_FIXNUM(k); c = gsl_combination_calloc(FIX2INT(n), FIX2INT(k)); return Data_Wrap_Struct(klass, 0, gsl_combination_free, c); } static VALUE rb_gsl_combination_init_first(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); gsl_combination_init_first(c); return obj; } static VALUE rb_gsl_combination_init_last(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); gsl_combination_init_last(c); return obj; } #ifdef GSL_1_4_LATER /* singleton */ static VALUE rb_gsl_combination_memcpy(VALUE klass, VALUE dst, VALUE src) { gsl_combination *c, *c2; if (!rb_obj_is_kind_of(dst, klass)) rb_raise(rb_eTypeError, "wrong argument type %s (Combination expected)", rb_class2name(CLASS_OF(dst))); if (!rb_obj_is_kind_of(src, klass)) rb_raise(rb_eTypeError, "wrong argument type %s (Combination expected)", rb_class2name(CLASS_OF(src))); Data_Get_Struct(dst, gsl_combination, c2); Data_Get_Struct(src, gsl_combination, c); gsl_combination_memcpy(c2, c); return dst; } static VALUE rb_gsl_combination_clone(VALUE obj) { gsl_combination *c, *c2; Data_Get_Struct(obj, gsl_combination, c); c2 = gsl_combination_alloc(c->n, c->k); gsl_combination_memcpy(c2, c); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_combination_free, c2); } #endif static VALUE rb_gsl_combination_get(VALUE obj, VALUE ii) { gsl_combination *c = NULL; size_t i; CHECK_FIXNUM(ii); Data_Get_Struct(obj, gsl_combination, c); i = FIX2INT(ii); if (i > c->n) rb_raise(rb_eIndexError, "index out of range"); return INT2FIX(gsl_combination_get(c, i)); } static VALUE rb_gsl_combination_set(VALUE obj, VALUE ii, VALUE val) { gsl_combination *c = NULL; size_t i; CHECK_FIXNUM(ii); CHECK_FIXNUM(val); Data_Get_Struct(obj, gsl_combination, c); i = FIX2INT(ii); c->data[i] = FIX2INT(val); return obj; } static VALUE rb_gsl_combination_n(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); return INT2FIX(gsl_combination_n(c)); } static VALUE rb_gsl_combination_k(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); return INT2FIX(gsl_combination_k(c)); } static VALUE rb_gsl_combination_data(VALUE obj) { gsl_combination *c = NULL; gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_combination, c); p = ALLOC(gsl_permutation); p->size = c->k; p->data = c->data; return Data_Wrap_Struct(cgsl_combination_data, 0, free, p); } static VALUE rb_gsl_combination_valid(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); return INT2FIX(gsl_combination_valid(c)); } static VALUE rb_gsl_combination_valid2(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); if(gsl_combination_valid(c)) return Qtrue; else return Qfalse; } static VALUE rb_gsl_combination_next(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); return INT2FIX(gsl_combination_next(c)); } static VALUE rb_gsl_combination_prev(VALUE obj) { gsl_combination *c = NULL; Data_Get_Struct(obj, gsl_combination, c); return INT2FIX(gsl_combination_prev(c)); } static VALUE rb_gsl_combination_fwrite(VALUE obj, VALUE io) { gsl_combination *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_combination, h); f = rb_gsl_open_writefile(io, &flag); status = gsl_combination_fwrite(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_combination_fread(VALUE obj, VALUE io) { gsl_combination *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_combination, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_combination_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_combination_fprintf(int argc, VALUE *argv, VALUE obj) { gsl_combination *h = NULL; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); Data_Get_Struct(obj, gsl_combination, h); fp = rb_gsl_open_writefile(argv[0], &flag); switch (argc) { case 1: status = gsl_combination_fprintf(fp, h, "%u\n"); break; default: Check_Type(argv[1], T_STRING); status = gsl_combination_fprintf(fp, h, STR2CSTR(argv[1])); break; } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_combination_printf(int argc, VALUE *argv, VALUE obj) { gsl_combination *h = NULL; int status; Data_Get_Struct(obj, gsl_combination, h); switch (argc) { case 0: status = gsl_combination_fprintf(stdout, h, "%u\n"); break; default: Check_Type(argv[0], T_STRING); status = gsl_combination_fprintf(stdout, h, STR2CSTR(argv[0])); break; } return INT2FIX(status); } static VALUE rb_gsl_combination_fscanf(VALUE obj, VALUE io) { gsl_combination *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_combination, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_combination_fscanf(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_combination_equal(VALUE obj, VALUE other) { gsl_combination *p1 = NULL, *p2 = NULL; size_t i; Data_Get_Struct(obj, gsl_combination, p1); Data_Get_Struct(other, gsl_combination, p2); if (p1->k != p2->k) return Qfalse; for (i = 0; i < p1->k; i++) if (p1->data[i] != p2->data[i]) return Qfalse; return Qtrue; } void Init_gsl_combination(VALUE module) { VALUE cgsl_combination; cgsl_combination = rb_define_class_under(module, "Combination", cGSL_Object); cgsl_combination_data = rb_define_class_under(cgsl_combination, "Data", cgsl_permutation); rb_define_singleton_method(cgsl_combination, "new", rb_gsl_combination_new, 2); rb_define_singleton_method(cgsl_combination, "alloc", rb_gsl_combination_new, 2); rb_define_singleton_method(cgsl_combination, "calloc", rb_gsl_combination_calloc, 2); rb_define_method(cgsl_combination, "init_first", rb_gsl_combination_init_first, 0); rb_define_method(cgsl_combination, "init_last", rb_gsl_combination_init_last, 0); #ifdef GSL_1_4_LATER rb_define_singleton_method(cgsl_combination, "memcpy", rb_gsl_combination_memcpy, 2); rb_define_method(cgsl_combination, "clone", rb_gsl_combination_clone, 0); #endif rb_define_method(cgsl_combination, "get", rb_gsl_combination_get, 1); rb_define_alias(cgsl_combination, "[]", "get"); rb_define_method(cgsl_combination, "set", rb_gsl_combination_set, 2); rb_define_alias(cgsl_combination, "[]=", "set"); rb_define_method(cgsl_combination, "n", rb_gsl_combination_n, 0); rb_define_method(cgsl_combination, "k", rb_gsl_combination_k, 0); rb_define_method(cgsl_combination, "data", rb_gsl_combination_data, 0); rb_define_method(cgsl_combination, "valid", rb_gsl_combination_valid, 0); rb_define_method(cgsl_combination, "valid?", rb_gsl_combination_valid2, 0); rb_define_method(cgsl_combination, "next", rb_gsl_combination_next, 0); rb_define_method(cgsl_combination, "prev", rb_gsl_combination_prev, 0); rb_define_method(cgsl_combination, "fwrite", rb_gsl_combination_fwrite, 1); rb_define_method(cgsl_combination, "fread", rb_gsl_combination_fread, 1); rb_define_method(cgsl_combination, "fprintf", rb_gsl_combination_fprintf, -1); rb_define_method(cgsl_combination, "printf", rb_gsl_combination_printf, -1); rb_define_method(cgsl_combination, "fscanf", rb_gsl_combination_fscanf, 1); rb_define_method(cgsl_combination, "equal?", rb_gsl_combination_equal, 1); rb_define_alias(cgsl_combination, "==", "equal?"); } #endif gsl-1.15.3/ext/const.c0000644000175000017500000011005612220252463014037 0ustar boutilboutil/* const.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_const.h" static void rb_gsl_const_mks(VALUE module); static void rb_gsl_const_cgs(VALUE module); static void rb_gsl_const_num(VALUE module); void Init_gsl_const_additional(VALUE mmks, VALUE mcgs, VALUE mnum); #ifdef GSL_CONST_OLD static void rb_gsl_const_mks(VALUE module) { rb_define_const(module, "SPEED_OF_LIGHT", rb_float_new(GSL_CONST_MKS_SPEED_OF_LIGHT)); rb_define_const(module, "GRAVITATIONAL_CONSTANT", rb_float_new(GSL_CONST_MKS_GRAVITATIONAL_CONSTANT)); rb_define_const(module, "PLANCKS_CONSTANT_H", rb_float_new(GSL_CONST_MKS_PLANCKS_CONSTANT_H)); rb_define_const(module, "PLANCKS_CONSTANT_HBAR", rb_float_new(GSL_CONST_MKS_PLANCKS_CONSTANT_HBAR)); rb_define_const(module, "VACUUM_PERMEABILITY", rb_float_new(GSL_CONST_MKS_VACUUM_PERMEABILITY)); rb_define_const(module, "ASTRONOMICAL_UNIT", rb_float_new(GSL_CONST_MKS_ASTRONOMICAL_UNIT)); rb_define_const(module, "LIGHT_YEAR", rb_float_new(GSL_CONST_MKS_LIGHT_YEAR)); rb_define_const(module, "PARSEC", rb_float_new(GSL_CONST_MKS_PARSEC)); rb_define_const(module, "GRAV_ACCEL", rb_float_new(GSL_CONST_MKS_GRAV_ACCEL)); rb_define_const(module, "ELECTRON_VOLT", rb_float_new(GSL_CONST_MKS_ELECTRON_VOLT)); rb_define_const(module, "MASS_ELECTRON", rb_float_new(GSL_CONST_MKS_MASS_ELECTRON)); rb_define_const(module, "MASS_MUON", rb_float_new(GSL_CONST_MKS_MASS_MUON)); rb_define_const(module, "MASS_PROTON", rb_float_new(GSL_CONST_MKS_MASS_PROTON)); rb_define_const(module, "MASS_NEUTRON", rb_float_new(GSL_CONST_MKS_MASS_NEUTRON)); rb_define_const(module, "RYDBERG", rb_float_new(GSL_CONST_MKS_RYDBERG)); rb_define_const(module, "BOLTZMANN", rb_float_new(GSL_CONST_MKS_BOLTZMANN)); rb_define_const(module, "MOLAR_GAS", rb_float_new(GSL_CONST_MKS_MOLAR_GAS)); rb_define_const(module, "BOHR_MAGNETON", rb_float_new(GSL_CONST_MKS_BOHR_MAGNETON)); rb_define_const(module, "NUCLEAR_MAGNETON", rb_float_new(GSL_CONST_MKS_NUCLEAR_MAGNETON)); rb_define_const(module, "ELECTRON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_MKS_ELECTRON_MAGNETIC_MOMENT)); rb_define_const(module, "PROTON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_MKS_PROTON_MAGNETIC_MOMENT)); rb_define_const(module, "STANDARD_GAS_VOLUME", rb_float_new(GSL_CONST_MKS_STANDARD_GAS_VOLUME)); rb_define_const(module, "MINUTE", rb_float_new(GSL_CONST_MKS_MINUTE)); rb_define_const(module, "HOUR", rb_float_new(GSL_CONST_MKS_HOUR)); rb_define_const(module, "DAY", rb_float_new(GSL_CONST_MKS_DAY)); rb_define_const(module, "WEEK", rb_float_new(GSL_CONST_MKS_WEEK)); rb_define_const(module, "INCH", rb_float_new(GSL_CONST_MKS_INCH)); rb_define_const(module, "FOOT", rb_float_new(GSL_CONST_MKS_FOOT)); rb_define_const(module, "YARD", rb_float_new(GSL_CONST_MKS_YARD)); rb_define_const(module, "MILE", rb_float_new(GSL_CONST_MKS_MILE)); rb_define_const(module, "NAUTICAL_MILE", rb_float_new(GSL_CONST_MKS_NAUTICAL_MILE)); rb_define_const(module, "FATHOM", rb_float_new(GSL_CONST_MKS_FATHOM)); rb_define_const(module, "MIL", rb_float_new(GSL_CONST_MKS_MIL)); rb_define_const(module, "POINT", rb_float_new(GSL_CONST_MKS_POINT)); rb_define_const(module, "TEXPOINT", rb_float_new(GSL_CONST_MKS_TEXPOINT)); rb_define_const(module, "MICRON", rb_float_new(GSL_CONST_MKS_MICRON)); rb_define_const(module, "ANGSTROM", rb_float_new(GSL_CONST_MKS_ANGSTROM)); rb_define_const(module, "HECTARE", rb_float_new(GSL_CONST_MKS_HECTARE)); rb_define_const(module, "ACRE", rb_float_new(GSL_CONST_MKS_ACRE)); #ifdef GSL_0_9_4_LATER rb_define_const(module, "BARN", rb_float_new(GSL_CONST_MKS_BARN)); rb_define_const(module, "BTU", rb_float_new(GSL_CONST_MKS_BTU)); rb_define_const(module, "SOLAR_MASS", rb_float_new(GSL_CONST_MKS_SOLAR_MASS)); #else rb_define_const(module, "BARN", rb_float_new(1.0e-28)); rb_define_const(module, "BTU", rb_float_new(1.05505585262e3)); #endif rb_define_const(module, "LITER", rb_float_new(GSL_CONST_MKS_LITER)); rb_define_const(module, "US_GALLON", rb_float_new(GSL_CONST_MKS_US_GALLON)); rb_define_const(module, "QUART", rb_float_new(GSL_CONST_MKS_QUART)); rb_define_const(module, "PINT", rb_float_new(GSL_CONST_MKS_PINT)); rb_define_const(module, "CUP", rb_float_new(GSL_CONST_MKS_CUP)); rb_define_const(module, "FLUID_OUNCE", rb_float_new(GSL_CONST_MKS_FLUID_OUNCE)); rb_define_const(module, "TABLESPOON", rb_float_new(GSL_CONST_MKS_TABLESPOON)); rb_define_const(module, "CANADIAN_GALLON", rb_float_new(GSL_CONST_MKS_CANADIAN_GALLON)); rb_define_const(module, "UK_GALLON", rb_float_new(GSL_CONST_MKS_UK_GALLON)); rb_define_const(module, "KILOMETERS_PER_HOUR", rb_float_new(GSL_CONST_MKS_MILES_PER_HOUR)); rb_define_const(module, "MILES_PER_HOUR", rb_float_new(GSL_CONST_MKS_KILOMETERS_PER_HOUR)); rb_define_const(module, "KNOT", rb_float_new(GSL_CONST_MKS_KNOT)); rb_define_const(module, "POUND_MASS", rb_float_new(GSL_CONST_MKS_POUND_MASS)); rb_define_const(module, "POUND_OUNCE", rb_float_new(GSL_CONST_MKS_OUNCE_MASS)); rb_define_const(module, "POUND_TON", rb_float_new(GSL_CONST_MKS_TON)); rb_define_const(module, "POUND_METRIC_TON", rb_float_new(GSL_CONST_MKS_METRIC_TON)); rb_define_const(module, "POUND_UK_TON", rb_float_new(GSL_CONST_MKS_UK_TON)); rb_define_const(module, "POUND_TROY_OUNCE", rb_float_new(GSL_CONST_MKS_TROY_OUNCE)); rb_define_const(module, "CARAT", rb_float_new(GSL_CONST_MKS_CARAT)); rb_define_const(module, "UNIFIED_ATOMIC_MASS", rb_float_new(GSL_CONST_MKS_UNIFIED_ATOMIC_MASS)); rb_define_const(module, "GRAM_FORCE", rb_float_new(GSL_CONST_MKS_GRAM_FORCE)); rb_define_const(module, "POUND_FORCE", rb_float_new(GSL_CONST_MKS_POUND_FORCE)); rb_define_const(module, "KILOPOUND_FORCE", rb_float_new(GSL_CONST_MKS_KILOPOUND_FORCE)); rb_define_const(module, "POUNDAL", rb_float_new(GSL_CONST_MKS_POUNDAL)); rb_define_const(module, "CALORIE", rb_float_new(GSL_CONST_MKS_CALORIE)); rb_define_const(module, "THERM", rb_float_new(GSL_CONST_MKS_THERM)); rb_define_const(module, "HORSEPOWER", rb_float_new(GSL_CONST_MKS_HORSEPOWER)); rb_define_const(module, "BAR", rb_float_new(GSL_CONST_MKS_BAR)); rb_define_const(module, "STD_ATMOSPHERE", rb_float_new(GSL_CONST_MKS_STD_ATMOSPHERE)); rb_define_const(module, "TORR", rb_float_new(GSL_CONST_MKS_TORR)); rb_define_const(module, "METER_OF_MERCURY", rb_float_new(GSL_CONST_MKS_METER_OF_MERCURY)); rb_define_const(module, "INCH_OF_MERCURY", rb_float_new(GSL_CONST_MKS_INCH_OF_MERCURY)); rb_define_const(module, "INCH_OF_WATER", rb_float_new(GSL_CONST_MKS_INCH_OF_WATER)); rb_define_const(module, "PSI", rb_float_new(GSL_CONST_MKS_PSI)); rb_define_const(module, "POISE", rb_float_new(GSL_CONST_MKS_POISE)); rb_define_const(module, "STOKES", rb_float_new(GSL_CONST_MKS_STOKES)); rb_define_const(module, "FARADAY", rb_float_new(GSL_CONST_MKS_FARADAY)); rb_define_const(module, "ELECTRON_CHARGE", rb_float_new(GSL_CONST_MKS_ELECTRON_CHARGE)); rb_define_const(module, "GAUSS", rb_float_new(GSL_CONST_MKS_GAUSS)); rb_define_const(module, "STILB", rb_float_new(GSL_CONST_MKS_STILB)); rb_define_const(module, "LUMEN", rb_float_new(GSL_CONST_MKS_LUMEN)); rb_define_const(module, "LUX", rb_float_new(GSL_CONST_MKS_LUX)); rb_define_const(module, "PHOT", rb_float_new(GSL_CONST_MKS_PHOT)); rb_define_const(module, "FOOTCANDLE", rb_float_new(GSL_CONST_MKS_FOOTCANDLE)); rb_define_const(module, "LAMBERT", rb_float_new(GSL_CONST_MKS_LAMBERT)); rb_define_const(module, "CURIE", rb_float_new(GSL_CONST_MKS_CURIE)); rb_define_const(module, "ROENTGEN", rb_float_new(GSL_CONST_MKS_ROENTGEN)); rb_define_const(module, "RAD", rb_float_new(GSL_CONST_MKS_RAD)); #ifdef GSL_1_1_LATER rb_define_const(module, "VACUUM_PERMITTIVITY", rb_float_new(GSL_CONST_MKS_VACUUM_PERMITTIVITY)); rb_define_const(module, "BOHR_RADIUS", rb_float_new(GSL_CONST_MKS_BOHR_RADIUS)); #endif #ifdef GSL_1_2_LATER rb_define_const(module, "NEWTON", rb_float_new(GSL_CONST_MKS_NEWTON)); rb_define_const(module, "DYNE", rb_float_new(GSL_CONST_MKS_DYNE)); rb_define_const(module, "JOULE", rb_float_new(GSL_CONST_MKS_JOULE)); rb_define_const(module, "ERG", rb_float_new(GSL_CONST_MKS_ERG)); #endif #ifdef GSL_1_8_LATER rb_define_const(module, "DEBYE", rb_float_new(GSL_CONST_MKS_DEBYE)); #endif } static void rb_gsl_const_cgs(VALUE module) { rb_define_const(module, "SPEED_OF_LIGHT", rb_float_new(GSL_CONST_CGS_SPEED_OF_LIGHT)); rb_define_const(module, "GRAVITATIONAL_CONSTANT", rb_float_new(GSL_CONST_CGS_GRAVITATIONAL_CONSTANT)); rb_define_const(module, "PLANCKS_CONSTANT_H", rb_float_new(GSL_CONST_CGS_PLANCKS_CONSTANT_H)); rb_define_const(module, "PLANCKS_CONSTANT_HBAR", rb_float_new(GSL_CONST_CGS_PLANCKS_CONSTANT_HBAR)); rb_define_const(module, "ASTRONOMICAL_UNIT", rb_float_new(GSL_CONST_CGS_ASTRONOMICAL_UNIT)); rb_define_const(module, "LIGHT_YEAR", rb_float_new(GSL_CONST_CGS_LIGHT_YEAR)); rb_define_const(module, "PARSEC", rb_float_new(GSL_CONST_CGS_PARSEC)); rb_define_const(module, "GRAV_ACCEL", rb_float_new(GSL_CONST_CGS_GRAV_ACCEL)); rb_define_const(module, "ELECTRON_VOLT", rb_float_new(GSL_CONST_CGS_ELECTRON_VOLT)); rb_define_const(module, "MASS_ELECTRON", rb_float_new(GSL_CONST_CGS_MASS_ELECTRON)); rb_define_const(module, "MASS_MUON", rb_float_new(GSL_CONST_CGS_MASS_MUON)); rb_define_const(module, "MASS_PROTON", rb_float_new(GSL_CONST_CGS_MASS_PROTON)); rb_define_const(module, "MASS_NEUTRON", rb_float_new(GSL_CONST_CGS_MASS_NEUTRON)); rb_define_const(module, "RYDBERG", rb_float_new(GSL_CONST_CGS_RYDBERG)); rb_define_const(module, "BOHR_MAGNETON", rb_float_new(GSL_CONST_CGS_BOHR_MAGNETON)); rb_define_const(module, "NUCLEAR_MAGNETON", rb_float_new(GSL_CONST_CGS_NUCLEAR_MAGNETON)); rb_define_const(module, "ELECTRON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_CGS_ELECTRON_MAGNETIC_MOMENT)); rb_define_const(module, "PROTON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_CGS_PROTON_MAGNETIC_MOMENT)); rb_define_const(module, "STANDARD_GAS_VOLUME", rb_float_new(GSL_CONST_CGS_STANDARD_GAS_VOLUME)); rb_define_const(module, "MINUTE", rb_float_new(GSL_CONST_CGS_MINUTE)); rb_define_const(module, "HOUR", rb_float_new(GSL_CONST_CGS_HOUR)); rb_define_const(module, "DAY", rb_float_new(GSL_CONST_CGS_DAY)); rb_define_const(module, "WEEK", rb_float_new(GSL_CONST_CGS_WEEK)); rb_define_const(module, "INCH", rb_float_new(GSL_CONST_CGS_INCH)); rb_define_const(module, "FOOT", rb_float_new(GSL_CONST_CGS_FOOT)); rb_define_const(module, "YARD", rb_float_new(GSL_CONST_CGS_YARD)); rb_define_const(module, "MILE", rb_float_new(GSL_CONST_CGS_MILE)); rb_define_const(module, "NAUTICAL_MILE", rb_float_new(GSL_CONST_CGS_NAUTICAL_MILE)); rb_define_const(module, "FATHOM", rb_float_new(GSL_CONST_CGS_FATHOM)); rb_define_const(module, "MIL", rb_float_new(GSL_CONST_CGS_MIL)); rb_define_const(module, "POINT", rb_float_new(GSL_CONST_CGS_POINT)); rb_define_const(module, "TEXPOINT", rb_float_new(GSL_CONST_CGS_TEXPOINT)); rb_define_const(module, "MICRON", rb_float_new(GSL_CONST_CGS_MICRON)); rb_define_const(module, "ANGSTROM", rb_float_new(GSL_CONST_CGS_ANGSTROM)); rb_define_const(module, "HECTARE", rb_float_new(GSL_CONST_CGS_HECTARE)); rb_define_const(module, "ACRE", rb_float_new(GSL_CONST_CGS_ACRE)); #ifdef GSL_0_9_4_LATER rb_define_const(module, "BARN", rb_float_new(GSL_CONST_CGS_BARN)); rb_define_const(module, "BTU", rb_float_new(GSL_CONST_CGS_BTU)); rb_define_const(module, "SOLAR_MASS", rb_float_new(GSL_CONST_CGS_SOLAR_MASS)); #else rb_define_const(module, "BARN", rb_float_new(1e-24)); rb_define_const(module, "BTU", rb_float_new(1.05505585262e10)); #endif rb_define_const(module, "LITER", rb_float_new(GSL_CONST_CGS_LITER)); rb_define_const(module, "US_GALLON", rb_float_new(GSL_CONST_CGS_US_GALLON)); rb_define_const(module, "QUART", rb_float_new(GSL_CONST_CGS_QUART)); rb_define_const(module, "PINT", rb_float_new(GSL_CONST_CGS_PINT)); rb_define_const(module, "CUP", rb_float_new(GSL_CONST_CGS_CUP)); rb_define_const(module, "FLUID_OUNCE", rb_float_new(GSL_CONST_CGS_FLUID_OUNCE)); rb_define_const(module, "TABLESPOON", rb_float_new(GSL_CONST_CGS_TABLESPOON)); rb_define_const(module, "CANADIAN_GALLON", rb_float_new(GSL_CONST_CGS_CANADIAN_GALLON)); rb_define_const(module, "UK_GALLON", rb_float_new(GSL_CONST_CGS_UK_GALLON)); rb_define_const(module, "KILOMETERS_PER_HOUR", rb_float_new(GSL_CONST_CGS_MILES_PER_HOUR)); rb_define_const(module, "MILES_PER_HOUR", rb_float_new(GSL_CONST_CGS_KILOMETERS_PER_HOUR)); rb_define_const(module, "KNOT", rb_float_new(GSL_CONST_CGS_KNOT)); rb_define_const(module, "POUND_MASS", rb_float_new(GSL_CONST_CGS_POUND_MASS)); rb_define_const(module, "POUND_OUNCE", rb_float_new(GSL_CONST_CGS_OUNCE_MASS)); rb_define_const(module, "POUND_TON", rb_float_new(GSL_CONST_CGS_TON)); rb_define_const(module, "POUND_METRIC_TON", rb_float_new(GSL_CONST_CGS_METRIC_TON)); rb_define_const(module, "POUND_UK_TON", rb_float_new(GSL_CONST_CGS_UK_TON)); rb_define_const(module, "POUND_TROY_OUNCE", rb_float_new(GSL_CONST_CGS_TROY_OUNCE)); rb_define_const(module, "CARAT", rb_float_new(GSL_CONST_CGS_CARAT)); rb_define_const(module, "UNIFIED_ATOMIC_MASS", rb_float_new(GSL_CONST_CGS_UNIFIED_ATOMIC_MASS)); rb_define_const(module, "GRAM_FORCE", rb_float_new(GSL_CONST_CGS_GRAM_FORCE)); rb_define_const(module, "POUND_FORCE", rb_float_new(GSL_CONST_CGS_POUND_FORCE)); rb_define_const(module, "KILOPOUND_FORCE", rb_float_new(GSL_CONST_CGS_KILOPOUND_FORCE)); rb_define_const(module, "POUNDAL", rb_float_new(GSL_CONST_CGS_POUNDAL)); rb_define_const(module, "CALORIE", rb_float_new(GSL_CONST_CGS_CALORIE)); rb_define_const(module, "THERM", rb_float_new(GSL_CONST_CGS_THERM)); rb_define_const(module, "HORSEPOWER", rb_float_new(GSL_CONST_CGS_HORSEPOWER)); rb_define_const(module, "BAR", rb_float_new(GSL_CONST_CGS_BAR)); rb_define_const(module, "STD_ATMOSPHERE", rb_float_new(GSL_CONST_CGS_STD_ATMOSPHERE)); rb_define_const(module, "TORR", rb_float_new(GSL_CONST_CGS_TORR)); rb_define_const(module, "METER_OF_MERCURY", rb_float_new(GSL_CONST_CGS_METER_OF_MERCURY)); rb_define_const(module, "INCH_OF_MERCURY", rb_float_new(GSL_CONST_CGS_INCH_OF_MERCURY)); rb_define_const(module, "INCH_OF_WATER", rb_float_new(GSL_CONST_CGS_INCH_OF_WATER)); rb_define_const(module, "PSI", rb_float_new(GSL_CONST_CGS_PSI)); rb_define_const(module, "POISE", rb_float_new(GSL_CONST_CGS_POISE)); rb_define_const(module, "STOKES", rb_float_new(GSL_CONST_CGS_STOKES)); rb_define_const(module, "FARADAY", rb_float_new(GSL_CONST_CGS_FARADAY)); rb_define_const(module, "ELECTRON_CHARGE", rb_float_new(GSL_CONST_CGS_ELECTRON_CHARGE)); rb_define_const(module, "ELECTRON_CHARGE_ESU", rb_float_new(GSL_CONST_CGS_ELECTRON_CHARGE*GSL_CONST_CGS_SPEED_OF_LIGHT)); rb_define_const(module, "GAUSS", rb_float_new(GSL_CONST_CGS_GAUSS)); rb_define_const(module, "STILB", rb_float_new(GSL_CONST_CGS_STILB)); rb_define_const(module, "LUMEN", rb_float_new(GSL_CONST_CGS_LUMEN)); rb_define_const(module, "LUX", rb_float_new(GSL_CONST_CGS_LUX)); rb_define_const(module, "PHOT", rb_float_new(GSL_CONST_CGS_PHOT)); rb_define_const(module, "FOOTCANDLE", rb_float_new(GSL_CONST_CGS_FOOTCANDLE)); rb_define_const(module, "LAMBERT", rb_float_new(GSL_CONST_CGS_LAMBERT)); rb_define_const(module, "CURIE", rb_float_new(GSL_CONST_CGS_CURIE)); rb_define_const(module, "ROENTGEN", rb_float_new(GSL_CONST_CGS_ROENTGEN)); rb_define_const(module, "RAD", rb_float_new(GSL_CONST_CGS_RAD)); rb_define_const(module, "BOLTZMANN", rb_float_new(GSL_CONST_CGS_BOLTZMANN)); rb_define_const(module, "MOLAR_GAS", rb_float_new(GSL_CONST_CGS_MOLAR_GAS)); #ifdef GSL_1_1_LATER rb_define_const(module, "BOHR_RADIUS", rb_float_new(GSL_CONST_CGS_BOHR_RADIUS)); #endif #ifdef GSL_1_2_LATER rb_define_const(module, "NEWTON", rb_float_new(GSL_CONST_CGS_NEWTON)); rb_define_const(module, "DYNE", rb_float_new(GSL_CONST_CGS_DYNE)); rb_define_const(module, "JOULE", rb_float_new(GSL_CONST_CGS_JOULE)); rb_define_const(module, "ERG", rb_float_new(GSL_CONST_CGS_ERG)); #endif } static void rb_gsl_const_num(VALUE module) { rb_define_const(module, "AVOGADRO", rb_float_new(GSL_CONST_NUM_AVOGADRO)); rb_define_const(module, "FINE_STRUCTURE", rb_float_new(GSL_CONST_NUM_FINE_STRUCTURE)); #ifdef GSL_1_2_LATER rb_define_const(module, "YOTTA", rb_float_new(GSL_CONST_NUM_YOTTA)); rb_define_const(module, "ZETTA", rb_float_new(GSL_CONST_NUM_ZETTA)); rb_define_const(module, "EXA", rb_float_new(GSL_CONST_NUM_EXA)); rb_define_const(module, "PETA", rb_float_new(GSL_CONST_NUM_PETA)); rb_define_const(module, "TERA", rb_float_new(GSL_CONST_NUM_TERA)); rb_define_const(module, "GIGA", rb_float_new(GSL_CONST_NUM_GIGA)); rb_define_const(module, "MEGA", rb_float_new(GSL_CONST_NUM_MEGA)); rb_define_const(module, "KILO", rb_float_new(GSL_CONST_NUM_KILO)); rb_define_const(module, "MILLI", rb_float_new(GSL_CONST_NUM_MILLI)); rb_define_const(module, "MICRO", rb_float_new(GSL_CONST_NUM_MICRO)); rb_define_const(module, "NANO", rb_float_new(GSL_CONST_NUM_NANO)); rb_define_const(module, "PICO", rb_float_new(GSL_CONST_NUM_PICO)); rb_define_const(module, "FEMTO", rb_float_new(GSL_CONST_NUM_FEMTO)); rb_define_const(module, "ATTO", rb_float_new(GSL_CONST_NUM_ATTO)); rb_define_const(module, "ZEPTO", rb_float_new(GSL_CONST_NUM_ZEPTO)); rb_define_const(module, "YOCTO", rb_float_new(GSL_CONST_NUM_YOCTO)); #endif } void Init_gsl_const(VALUE module) { VALUE mgsl_const; VALUE mgsl_const_mks, mgsl_const_cgs, mgsl_const_num; mgsl_const = rb_define_module_under(module, "CONST"); mgsl_const_mks = rb_define_module_under(mgsl_const, "MKSA"); rb_gsl_const_mks(mgsl_const_mks); mgsl_const_cgs = rb_define_module_under(mgsl_const, "CGSM"); rb_gsl_const_cgs(mgsl_const_cgs); mgsl_const_num = rb_define_module_under(mgsl_const, "NUM"); rb_gsl_const_num(mgsl_const_num); Init_gsl_const_additional(mgsl_const_mks, mgsl_const_cgs, mgsl_const_num); } #else static void rb_gsl_const_mks(VALUE module) { rb_define_const(module, "SPEED_OF_LIGHT", rb_float_new(GSL_CONST_MKSA_SPEED_OF_LIGHT)); rb_define_const(module, "GRAVITATIONAL_CONSTANT", rb_float_new(GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT)); rb_define_const(module, "PLANCKS_CONSTANT_H", rb_float_new(GSL_CONST_MKSA_PLANCKS_CONSTANT_H)); rb_define_const(module, "PLANCKS_CONSTANT_HBAR", rb_float_new(GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR)); rb_define_const(module, "VACUUM_PERMEABILITY", rb_float_new(GSL_CONST_MKSA_VACUUM_PERMEABILITY)); rb_define_const(module, "VACUUM_PERMITTIVITY", rb_float_new(GSL_CONST_MKSA_VACUUM_PERMITTIVITY)); rb_define_const(module, "ASTRONOMICAL_UNIT", rb_float_new(GSL_CONST_MKSA_ASTRONOMICAL_UNIT)); rb_define_const(module, "LIGHT_YEAR", rb_float_new(GSL_CONST_MKSA_LIGHT_YEAR)); rb_define_const(module, "PARSEC", rb_float_new(GSL_CONST_MKSA_PARSEC)); rb_define_const(module, "GRAV_ACCEL", rb_float_new(GSL_CONST_MKSA_GRAV_ACCEL)); rb_define_const(module, "ELECTRON_VOLT", rb_float_new(GSL_CONST_MKSA_ELECTRON_VOLT)); rb_define_const(module, "MASS_ELECTRON", rb_float_new(GSL_CONST_MKSA_MASS_ELECTRON)); rb_define_const(module, "MASS_MUON", rb_float_new(GSL_CONST_MKSA_MASS_MUON)); rb_define_const(module, "MASS_PROTON", rb_float_new(GSL_CONST_MKSA_MASS_PROTON)); rb_define_const(module, "MASS_NEUTRON", rb_float_new(GSL_CONST_MKSA_MASS_NEUTRON)); rb_define_const(module, "RYDBERG", rb_float_new(GSL_CONST_MKSA_RYDBERG)); rb_define_const(module, "BOHR_MAGNETON", rb_float_new(GSL_CONST_MKSA_BOHR_MAGNETON)); rb_define_const(module, "NUCLEAR_MAGNETON", rb_float_new(GSL_CONST_MKSA_NUCLEAR_MAGNETON)); rb_define_const(module, "ELECTRON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT)); rb_define_const(module, "PROTON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT)); rb_define_const(module, "STANDARD_GAS_VOLUME", rb_float_new(GSL_CONST_MKSA_STANDARD_GAS_VOLUME)); rb_define_const(module, "MINUTE", rb_float_new(GSL_CONST_MKSA_MINUTE)); rb_define_const(module, "HOUR", rb_float_new(GSL_CONST_MKSA_HOUR)); rb_define_const(module, "DAY", rb_float_new(GSL_CONST_MKSA_DAY)); rb_define_const(module, "WEEK", rb_float_new(GSL_CONST_MKSA_WEEK)); rb_define_const(module, "INCH", rb_float_new(GSL_CONST_MKSA_INCH)); rb_define_const(module, "FOOT", rb_float_new(GSL_CONST_MKSA_FOOT)); rb_define_const(module, "YARD", rb_float_new(GSL_CONST_MKSA_YARD)); rb_define_const(module, "MILE", rb_float_new(GSL_CONST_MKSA_MILE)); rb_define_const(module, "NAUTICAL_MILE", rb_float_new(GSL_CONST_MKSA_NAUTICAL_MILE)); rb_define_const(module, "FATHOM", rb_float_new(GSL_CONST_MKSA_FATHOM)); rb_define_const(module, "MIL", rb_float_new(GSL_CONST_MKSA_MIL)); rb_define_const(module, "POINT", rb_float_new(GSL_CONST_MKSA_POINT)); rb_define_const(module, "TEXPOINT", rb_float_new(GSL_CONST_MKSA_TEXPOINT)); rb_define_const(module, "MICRON", rb_float_new(GSL_CONST_MKSA_MICRON)); rb_define_const(module, "ANGSTROM", rb_float_new(GSL_CONST_MKSA_ANGSTROM)); rb_define_const(module, "HECTARE", rb_float_new(GSL_CONST_MKSA_HECTARE)); rb_define_const(module, "ACRE", rb_float_new(GSL_CONST_MKSA_ACRE)); rb_define_const(module, "BARN", rb_float_new(GSL_CONST_MKSA_BARN)); rb_define_const(module, "LITER", rb_float_new(GSL_CONST_MKSA_LITER)); rb_define_const(module, "US_GALLON", rb_float_new(GSL_CONST_MKSA_US_GALLON)); rb_define_const(module, "QUART", rb_float_new(GSL_CONST_MKSA_QUART)); rb_define_const(module, "PINT", rb_float_new(GSL_CONST_MKSA_PINT)); rb_define_const(module, "CUP", rb_float_new(GSL_CONST_MKSA_CUP)); rb_define_const(module, "FLUID_OUNCE", rb_float_new(GSL_CONST_MKSA_FLUID_OUNCE)); rb_define_const(module, "TABLESPOON", rb_float_new(GSL_CONST_MKSA_TABLESPOON)); rb_define_const(module, "CANADIAN_GALLON", rb_float_new(GSL_CONST_MKSA_CANADIAN_GALLON)); rb_define_const(module, "UK_GALLON", rb_float_new(GSL_CONST_MKSA_UK_GALLON)); rb_define_const(module, "KILOMETERS_PER_HOUR", rb_float_new(GSL_CONST_MKSA_MILES_PER_HOUR)); rb_define_const(module, "MILES_PER_HOUR", rb_float_new(GSL_CONST_MKSA_KILOMETERS_PER_HOUR)); rb_define_const(module, "KNOT", rb_float_new(GSL_CONST_MKSA_KNOT)); rb_define_const(module, "POUND_MASS", rb_float_new(GSL_CONST_MKSA_POUND_MASS)); rb_define_const(module, "POUND_OUNCE", rb_float_new(GSL_CONST_MKSA_OUNCE_MASS)); rb_define_const(module, "POUND_TON", rb_float_new(GSL_CONST_MKSA_TON)); rb_define_const(module, "POUND_METRIC_TON", rb_float_new(GSL_CONST_MKSA_METRIC_TON)); rb_define_const(module, "POUND_UK_TON", rb_float_new(GSL_CONST_MKSA_UK_TON)); rb_define_const(module, "POUND_TROY_OUNCE", rb_float_new(GSL_CONST_MKSA_TROY_OUNCE)); rb_define_const(module, "CARAT", rb_float_new(GSL_CONST_MKSA_CARAT)); rb_define_const(module, "UNIFIED_ATOMIC_MASS", rb_float_new(GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS)); rb_define_const(module, "GRAM_FORCE", rb_float_new(GSL_CONST_MKSA_GRAM_FORCE)); rb_define_const(module, "POUND_FORCE", rb_float_new(GSL_CONST_MKSA_POUND_FORCE)); rb_define_const(module, "KILOPOUND_FORCE", rb_float_new(GSL_CONST_MKSA_KILOPOUND_FORCE)); rb_define_const(module, "POUNDAL", rb_float_new(GSL_CONST_MKSA_POUNDAL)); rb_define_const(module, "CALORIE", rb_float_new(GSL_CONST_MKSA_CALORIE)); rb_define_const(module, "BTU", rb_float_new(GSL_CONST_MKSA_BTU)); rb_define_const(module, "THERM", rb_float_new(GSL_CONST_MKSA_THERM)); rb_define_const(module, "HORSEPOWER", rb_float_new(GSL_CONST_MKSA_HORSEPOWER)); rb_define_const(module, "BAR", rb_float_new(GSL_CONST_MKSA_BAR)); rb_define_const(module, "STD_ATMOSPHERE", rb_float_new(GSL_CONST_MKSA_STD_ATMOSPHERE)); rb_define_const(module, "TORR", rb_float_new(GSL_CONST_MKSA_TORR)); rb_define_const(module, "METER_OF_MERCURY", rb_float_new(GSL_CONST_MKSA_METER_OF_MERCURY)); rb_define_const(module, "INCH_OF_MERCURY", rb_float_new(GSL_CONST_MKSA_INCH_OF_MERCURY)); rb_define_const(module, "INCH_OF_WATER", rb_float_new(GSL_CONST_MKSA_INCH_OF_WATER)); rb_define_const(module, "PSI", rb_float_new(GSL_CONST_MKSA_PSI)); rb_define_const(module, "POISE", rb_float_new(GSL_CONST_MKSA_POISE)); rb_define_const(module, "STOKES", rb_float_new(GSL_CONST_MKSA_STOKES)); rb_define_const(module, "FARADAY", rb_float_new(GSL_CONST_MKSA_FARADAY)); rb_define_const(module, "ELECTRON_CHARGE", rb_float_new(GSL_CONST_MKSA_ELECTRON_CHARGE)); rb_define_const(module, "GAUSS", rb_float_new(GSL_CONST_MKSA_GAUSS)); rb_define_const(module, "STILB", rb_float_new(GSL_CONST_MKSA_STILB)); rb_define_const(module, "LUMEN", rb_float_new(GSL_CONST_MKSA_LUMEN)); rb_define_const(module, "LUX", rb_float_new(GSL_CONST_MKSA_LUX)); rb_define_const(module, "PHOT", rb_float_new(GSL_CONST_MKSA_PHOT)); rb_define_const(module, "FOOTCANDLE", rb_float_new(GSL_CONST_MKSA_FOOTCANDLE)); rb_define_const(module, "LAMBERT", rb_float_new(GSL_CONST_MKSA_LAMBERT)); rb_define_const(module, "CURIE", rb_float_new(GSL_CONST_MKSA_CURIE)); rb_define_const(module, "ROENTGEN", rb_float_new(GSL_CONST_MKSA_ROENTGEN)); rb_define_const(module, "RAD", rb_float_new(GSL_CONST_MKSA_RAD)); rb_define_const(module, "SOLAR_MASS", rb_float_new(GSL_CONST_MKSA_SOLAR_MASS)); rb_define_const(module, "BOLTZMANN", rb_float_new(GSL_CONST_MKSA_BOLTZMANN)); rb_define_const(module, "MOLAR_GAS", rb_float_new(GSL_CONST_MKSA_MOLAR_GAS)); rb_define_const(module, "BOHR_RADIUS", rb_float_new(GSL_CONST_MKSA_BOHR_RADIUS)); rb_define_const(module, "NEWTON", rb_float_new(GSL_CONST_MKSA_NEWTON)); rb_define_const(module, "DYNE", rb_float_new(GSL_CONST_MKSA_DYNE)); rb_define_const(module, "JOULE", rb_float_new(GSL_CONST_MKSA_JOULE)); rb_define_const(module, "ERG", rb_float_new(GSL_CONST_MKSA_ERG)); #ifdef GSL_1_4_9_LATER rb_define_const(module, "STEFAN_BOLTZMANN_CONSTANT", rb_float_new(GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT)); rb_define_const(module, "THOMSON_CROSS_SECTION", rb_float_new(GSL_CONST_MKSA_THOMSON_CROSS_SECTION)); #endif #ifdef GSL_1_8_LATER rb_define_const(module, "DEBYE", rb_float_new(GSL_CONST_MKSA_DEBYE)); #endif } static void rb_gsl_const_cgs(VALUE module) { rb_define_const(module, "SPEED_OF_LIGHT", rb_float_new(GSL_CONST_CGSM_SPEED_OF_LIGHT)); rb_define_const(module, "GRAVITATIONAL_CONSTANT", rb_float_new(GSL_CONST_CGSM_GRAVITATIONAL_CONSTANT)); rb_define_const(module, "PLANCKS_CONSTANT_H", rb_float_new(GSL_CONST_CGSM_PLANCKS_CONSTANT_H)); rb_define_const(module, "PLANCKS_CONSTANT_HBAR", rb_float_new(GSL_CONST_CGSM_PLANCKS_CONSTANT_HBAR)); rb_define_const(module, "ASTRONOMICAL_UNIT", rb_float_new(GSL_CONST_CGSM_ASTRONOMICAL_UNIT)); rb_define_const(module, "LIGHT_YEAR", rb_float_new(GSL_CONST_CGSM_LIGHT_YEAR)); rb_define_const(module, "PARSEC", rb_float_new(GSL_CONST_CGSM_PARSEC)); rb_define_const(module, "GRAV_ACCEL", rb_float_new(GSL_CONST_CGSM_GRAV_ACCEL)); rb_define_const(module, "ELECTRON_VOLT", rb_float_new(GSL_CONST_CGSM_ELECTRON_VOLT)); rb_define_const(module, "MASS_ELECTRON", rb_float_new(GSL_CONST_CGSM_MASS_ELECTRON)); rb_define_const(module, "MASS_MUON", rb_float_new(GSL_CONST_CGSM_MASS_MUON)); rb_define_const(module, "MASS_PROTON", rb_float_new(GSL_CONST_CGSM_MASS_PROTON)); rb_define_const(module, "MASS_NEUTRON", rb_float_new(GSL_CONST_CGSM_MASS_NEUTRON)); rb_define_const(module, "RYDBERG", rb_float_new(GSL_CONST_CGSM_RYDBERG)); rb_define_const(module, "BOHR_MAGNETON", rb_float_new(GSL_CONST_CGSM_BOHR_MAGNETON)); rb_define_const(module, "NUCLEAR_MAGNETON", rb_float_new(GSL_CONST_CGSM_NUCLEAR_MAGNETON)); rb_define_const(module, "ELECTRON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_CGSM_ELECTRON_MAGNETIC_MOMENT)); rb_define_const(module, "PROTON_MAGNETIC_MOMENT", rb_float_new(GSL_CONST_CGSM_PROTON_MAGNETIC_MOMENT)); rb_define_const(module, "STANDARD_GAS_VOLUME", rb_float_new(GSL_CONST_CGSM_STANDARD_GAS_VOLUME)); rb_define_const(module, "MINUTE", rb_float_new(GSL_CONST_CGSM_MINUTE)); rb_define_const(module, "HOUR", rb_float_new(GSL_CONST_CGSM_HOUR)); rb_define_const(module, "DAY", rb_float_new(GSL_CONST_CGSM_DAY)); rb_define_const(module, "WEEK", rb_float_new(GSL_CONST_CGSM_WEEK)); rb_define_const(module, "INCH", rb_float_new(GSL_CONST_CGSM_INCH)); rb_define_const(module, "FOOT", rb_float_new(GSL_CONST_CGSM_FOOT)); rb_define_const(module, "YARD", rb_float_new(GSL_CONST_CGSM_YARD)); rb_define_const(module, "MILE", rb_float_new(GSL_CONST_CGSM_MILE)); rb_define_const(module, "NAUTICAL_MILE", rb_float_new(GSL_CONST_CGSM_NAUTICAL_MILE)); rb_define_const(module, "FATHOM", rb_float_new(GSL_CONST_CGSM_FATHOM)); rb_define_const(module, "MIL", rb_float_new(GSL_CONST_CGSM_MIL)); rb_define_const(module, "POINT", rb_float_new(GSL_CONST_CGSM_POINT)); rb_define_const(module, "TEXPOINT", rb_float_new(GSL_CONST_CGSM_TEXPOINT)); rb_define_const(module, "MICRON", rb_float_new(GSL_CONST_CGSM_MICRON)); rb_define_const(module, "ANGSTROM", rb_float_new(GSL_CONST_CGSM_ANGSTROM)); rb_define_const(module, "HECTARE", rb_float_new(GSL_CONST_CGSM_HECTARE)); rb_define_const(module, "ACRE", rb_float_new(GSL_CONST_CGSM_ACRE)); rb_define_const(module, "BARN", rb_float_new(GSL_CONST_CGSM_BARN)); rb_define_const(module, "LITER", rb_float_new(GSL_CONST_CGSM_LITER)); rb_define_const(module, "US_GALLON", rb_float_new(GSL_CONST_CGSM_US_GALLON)); rb_define_const(module, "QUART", rb_float_new(GSL_CONST_CGSM_QUART)); rb_define_const(module, "PINT", rb_float_new(GSL_CONST_CGSM_PINT)); rb_define_const(module, "CUP", rb_float_new(GSL_CONST_CGSM_CUP)); rb_define_const(module, "FLUID_OUNCE", rb_float_new(GSL_CONST_CGSM_FLUID_OUNCE)); rb_define_const(module, "TABLESPOON", rb_float_new(GSL_CONST_CGSM_TABLESPOON)); rb_define_const(module, "CANADIAN_GALLON", rb_float_new(GSL_CONST_CGSM_CANADIAN_GALLON)); rb_define_const(module, "UK_GALLON", rb_float_new(GSL_CONST_CGSM_UK_GALLON)); rb_define_const(module, "KILOMETERS_PER_HOUR", rb_float_new(GSL_CONST_CGSM_MILES_PER_HOUR)); rb_define_const(module, "MILES_PER_HOUR", rb_float_new(GSL_CONST_CGSM_KILOMETERS_PER_HOUR)); rb_define_const(module, "KNOT", rb_float_new(GSL_CONST_CGSM_KNOT)); rb_define_const(module, "POUND_MASS", rb_float_new(GSL_CONST_CGSM_POUND_MASS)); rb_define_const(module, "POUND_OUNCE", rb_float_new(GSL_CONST_CGSM_OUNCE_MASS)); rb_define_const(module, "POUND_TON", rb_float_new(GSL_CONST_CGSM_TON)); rb_define_const(module, "POUND_METRIC_TON", rb_float_new(GSL_CONST_CGSM_METRIC_TON)); rb_define_const(module, "POUND_UK_TON", rb_float_new(GSL_CONST_CGSM_UK_TON)); rb_define_const(module, "POUND_TROY_OUNCE", rb_float_new(GSL_CONST_CGSM_TROY_OUNCE)); rb_define_const(module, "CARAT", rb_float_new(GSL_CONST_CGSM_CARAT)); rb_define_const(module, "UNIFIED_ATOMIC_MASS", rb_float_new(GSL_CONST_CGSM_UNIFIED_ATOMIC_MASS)); rb_define_const(module, "GRAM_FORCE", rb_float_new(GSL_CONST_CGSM_GRAM_FORCE)); rb_define_const(module, "POUND_FORCE", rb_float_new(GSL_CONST_CGSM_POUND_FORCE)); rb_define_const(module, "KILOPOUND_FORCE", rb_float_new(GSL_CONST_CGSM_KILOPOUND_FORCE)); rb_define_const(module, "POUNDAL", rb_float_new(GSL_CONST_CGSM_POUNDAL)); rb_define_const(module, "CALORIE", rb_float_new(GSL_CONST_CGSM_CALORIE)); rb_define_const(module, "BTU", rb_float_new(GSL_CONST_CGSM_BTU)); rb_define_const(module, "THERM", rb_float_new(GSL_CONST_CGSM_THERM)); rb_define_const(module, "HORSEPOWER", rb_float_new(GSL_CONST_CGSM_HORSEPOWER)); rb_define_const(module, "BAR", rb_float_new(GSL_CONST_CGSM_BAR)); rb_define_const(module, "STD_ATMOSPHERE", rb_float_new(GSL_CONST_CGSM_STD_ATMOSPHERE)); rb_define_const(module, "TORR", rb_float_new(GSL_CONST_CGSM_TORR)); rb_define_const(module, "METER_OF_MERCURY", rb_float_new(GSL_CONST_CGSM_METER_OF_MERCURY)); rb_define_const(module, "INCH_OF_MERCURY", rb_float_new(GSL_CONST_CGSM_INCH_OF_MERCURY)); rb_define_const(module, "INCH_OF_WATER", rb_float_new(GSL_CONST_CGSM_INCH_OF_WATER)); rb_define_const(module, "PSI", rb_float_new(GSL_CONST_CGSM_PSI)); rb_define_const(module, "POISE", rb_float_new(GSL_CONST_CGSM_POISE)); rb_define_const(module, "STOKES", rb_float_new(GSL_CONST_CGSM_STOKES)); rb_define_const(module, "FARADAY", rb_float_new(GSL_CONST_CGSM_FARADAY)); rb_define_const(module, "ELECTRON_CHARGE", rb_float_new(GSL_CONST_CGSM_ELECTRON_CHARGE)); rb_define_const(module, "ELECTRON_CHARGE_ESU", rb_float_new(GSL_CONST_CGSM_ELECTRON_CHARGE*GSL_CONST_CGSM_SPEED_OF_LIGHT)); #ifndef GSL_1_13_LATER rb_define_const(module, "GAUSS", rb_float_new(GSL_CONST_CGSM_GAUSS)); #endif rb_define_const(module, "STILB", rb_float_new(GSL_CONST_CGSM_STILB)); rb_define_const(module, "LUMEN", rb_float_new(GSL_CONST_CGSM_LUMEN)); rb_define_const(module, "LUX", rb_float_new(GSL_CONST_CGSM_LUX)); rb_define_const(module, "PHOT", rb_float_new(GSL_CONST_CGSM_PHOT)); rb_define_const(module, "FOOTCANDLE", rb_float_new(GSL_CONST_CGSM_FOOTCANDLE)); rb_define_const(module, "LAMBERT", rb_float_new(GSL_CONST_CGSM_LAMBERT)); rb_define_const(module, "CURIE", rb_float_new(GSL_CONST_CGSM_CURIE)); rb_define_const(module, "ROENTGEN", rb_float_new(GSL_CONST_CGSM_ROENTGEN)); rb_define_const(module, "RAD", rb_float_new(GSL_CONST_CGSM_RAD)); rb_define_const(module, "SOLAR_MASS", rb_float_new(GSL_CONST_CGSM_SOLAR_MASS)); rb_define_const(module, "BOLTZMANN", rb_float_new(GSL_CONST_CGSM_BOLTZMANN)); rb_define_const(module, "MOLAR_GAS", rb_float_new(GSL_CONST_CGSM_MOLAR_GAS)); rb_define_const(module, "BOHR_RADIUS", rb_float_new(GSL_CONST_CGSM_BOHR_RADIUS)); rb_define_const(module, "NEWTON", rb_float_new(GSL_CONST_CGSM_NEWTON)); rb_define_const(module, "DYNE", rb_float_new(GSL_CONST_CGSM_DYNE)); rb_define_const(module, "JOULE", rb_float_new(GSL_CONST_CGSM_JOULE)); rb_define_const(module, "ERG", rb_float_new(GSL_CONST_CGSM_ERG)); #ifdef GSL_1_4_9_LATER rb_define_const(module, "STEFAN_BOLTZMANN_CONSTANT", rb_float_new(GSL_CONST_CGSM_STEFAN_BOLTZMANN_CONSTANT)); rb_define_const(module, "THOMSON_CROSS_SECTION", rb_float_new(GSL_CONST_CGSM_THOMSON_CROSS_SECTION)); #endif } static void rb_gsl_const_num(VALUE module) { rb_define_const(module, "AVOGADRO", rb_float_new(GSL_CONST_NUM_AVOGADRO)); rb_define_const(module, "FINE_STRUCTURE", rb_float_new(GSL_CONST_NUM_FINE_STRUCTURE)); rb_define_const(module, "YOTTA", rb_float_new(GSL_CONST_NUM_YOTTA)); rb_define_const(module, "ZETTA", rb_float_new(GSL_CONST_NUM_ZETTA)); rb_define_const(module, "EXA", rb_float_new(GSL_CONST_NUM_EXA)); rb_define_const(module, "PETA", rb_float_new(GSL_CONST_NUM_PETA)); rb_define_const(module, "TERA", rb_float_new(GSL_CONST_NUM_TERA)); rb_define_const(module, "GIGA", rb_float_new(GSL_CONST_NUM_GIGA)); rb_define_const(module, "MEGA", rb_float_new(GSL_CONST_NUM_MEGA)); rb_define_const(module, "KILO", rb_float_new(GSL_CONST_NUM_KILO)); rb_define_const(module, "MILLI", rb_float_new(GSL_CONST_NUM_MILLI)); rb_define_const(module, "MICRO", rb_float_new(GSL_CONST_NUM_MICRO)); rb_define_const(module, "NANO", rb_float_new(GSL_CONST_NUM_NANO)); rb_define_const(module, "PICO", rb_float_new(GSL_CONST_NUM_PICO)); rb_define_const(module, "FEMTO", rb_float_new(GSL_CONST_NUM_FEMTO)); rb_define_const(module, "ATTO", rb_float_new(GSL_CONST_NUM_ATTO)); rb_define_const(module, "ZEPTO", rb_float_new(GSL_CONST_NUM_ZEPTO)); rb_define_const(module, "YOCTO", rb_float_new(GSL_CONST_NUM_YOCTO)); } void Init_gsl_const(VALUE module) { VALUE mgsl_const; VALUE mgsl_const_mks, mgsl_const_cgs, mgsl_const_num; mgsl_const = rb_define_module_under(module, "CONST"); mgsl_const_mks = rb_define_module_under(mgsl_const, "MKSA"); rb_gsl_const_mks(mgsl_const_mks); mgsl_const_cgs = rb_define_module_under(mgsl_const, "CGSM"); rb_gsl_const_cgs(mgsl_const_cgs); mgsl_const_num = rb_define_module_under(mgsl_const, "NUM"); rb_gsl_const_num(mgsl_const_num); Init_gsl_const_additional(mgsl_const_mks, mgsl_const_cgs, mgsl_const_num); } #endif gsl-1.15.3/ext/tamu_anova.c0000644000175000017500000000270212220252463015041 0ustar boutilboutil#include "rb_gsl.h" #ifdef HAVE_TAMU_ANOVA_TAMU_ANOVA_H VALUE rb_tamu_anova_alloc(int argc, VALUE *argv, VALUE klass) { gsl_vector *data; gsl_vector_long *factor; long I, J; struct tamu_anova_table *table; switch (argc) { case 3: case 4: Data_Get_Struct(argv[0], gsl_vector, data); Data_Get_Struct(argv[1], gsl_vector_long, factor); if (argc == 3) { I = data->size; J = NUM2INT(argv[2]); } else { I = NUM2INT(argv[2]); J = NUM2INT(argv[3]); } table = (struct tamu_anova_table *) malloc(sizeof(struct tamu_anova_table)); *table = tamu_anova(data->data, factor->data, I, J); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 3 or 4)", argc); break; } return Data_Wrap_Struct(klass, 0, free, table); } VALUE rb_tamu_anova_printtable(VALUE *vTable) { struct tamu_anova_table *table; Data_Get_Struct(vTable, struct tamu_anova_table, table); tamu_anova_printtable(*table); return Qtrue; } #endif void Init_tamu_anova(VALUE module) { #ifdef HAVE_TAMU_ANOVA_TAMU_ANOVA_H VALUE mTAMU_ANOVA; VALUE cTable; mTAMU_ANOVA = rb_define_module_under(module, "TAMU_ANOVA"); cTable = rb_define_class_under(mTAMU_ANOVA, "Table", cGSL_Object); rb_define_singleton_method(cTable, "alloc", rb_tamu_anova_alloc, -1); rb_define_singleton_method(cTable, "oneway", rb_tamu_anova_alloc, -1); rb_define_method(cTable, "print", rb_tamu_anova_printtable, 0); #endif } gsl-1.15.3/ext/array.c0000644000175000017500000004402412220252463014030 0ustar boutilboutil/* array.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_common.h" #include "rb_gsl_array.h" #include "rb_gsl_complex.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif /* global variables */ VALUE cgsl_block, cgsl_block_int; VALUE cgsl_block_uchar; VALUE cgsl_block_complex; VALUE cgsl_vector, cgsl_vector_view; VALUE cgsl_vector_view_ro; VALUE cgsl_vector_col_view_ro; VALUE cgsl_matrix_view_ro; VALUE cgsl_vector_complex; VALUE cgsl_vector_complex_view; VALUE cgsl_matrix; VALUE cgsl_matrix_view; VALUE cgsl_matrix_complex; VALUE cgsl_matrix_complex_view; VALUE cgsl_vector_complex_view_ro; VALUE cgsl_matrix_complex_view_ro; VALUE cgsl_permutation; VALUE cgsl_index; VALUE cgsl_vector_col, cgsl_vector_col_view; VALUE cgsl_vector_complex_col, cgsl_vector_complex_col_view; VALUE cgsl_vector_int, cgsl_vector_int_col; VALUE cgsl_vector_int_view, cgsl_vector_int_col_view; VALUE cgsl_vector_int_view_ro, cgsl_vector_int_col_view_ro; VALUE cgsl_matrix_int, cgsl_matrix_int_view, cgsl_matrix_int_view_ro; double* get_vector_ptr(VALUE ary, size_t *stride, size_t *n) { gsl_vector *v = NULL; gsl_vector_complex *vc = NULL; gsl_matrix *m; #ifdef HAVE_NARRAY_H VALUE ary2; #endif if (VECTOR_P(ary)) { Data_Get_Struct(ary, gsl_vector, v); *stride = v->stride; *n = v->size; return v->data; } else if (VECTOR_COMPLEX_P(ary)) { Data_Get_Struct(ary, gsl_vector_complex, vc); *stride = vc->stride; *n = vc->size*2; return vc->data; } else if (MATRIX_P(ary)) { Data_Get_Struct(ary, gsl_matrix, m); *stride = 1; *n = m->size1*m->size2; return m->data; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(ary)) { *n = NA_TOTAL(ary); *stride = 1; ary2 = na_change_type(ary, NA_DFLOAT); return NA_PTR_TYPE(ary2,double*); #endif } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(ary))); } } gsl_vector* get_cvector(VALUE obj) { gsl_vector *v = NULL; if (rb_obj_is_kind_of(obj, cgsl_vector)) { Data_Get_Struct(obj, gsl_vector, v); #ifdef HAVE_NARRAY_H } else if (NA_IsArray(obj)) { v = make_cvector_from_rarrays(obj); #endif } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(obj))); } return v; } VALUE make_rarray_from_cvector(const gsl_vector *v) { size_t i; VALUE ary; ary = rb_ary_new2(v->size); for (i = 0; i < v->size; i++) { rb_ary_store(ary, i, rb_float_new(gsl_vector_get(v, i))); } return ary; } VALUE make_rarray_from_cvector_int(const gsl_vector_int *v) { size_t i; VALUE ary; ary = rb_ary_new2(v->size); for (i = 0; i < v->size; i++) { rb_ary_store(ary, i, INT2FIX(gsl_vector_int_get(v, i))); } return ary; } VALUE make_rarray_from_cpermutation(const gsl_permutation *v) { size_t i; VALUE ary; ary = rb_ary_new2(v->size); for (i = 0; i < v->size; i++) { rb_ary_store(ary, i, rb_float_new(gsl_permutation_get(v, i))); } return ary; } gsl_vector* get_vector(VALUE ary) { gsl_vector *v = NULL; if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary); if (TYPE(ary) == T_ARRAY) { return make_cvector_from_rarray(ary); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(ary)) { return make_cvector_from_narray(ary); #endif } else if (VECTOR_P(ary)) { Data_Get_Struct(ary, gsl_vector, v); return v; } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(ary))); } } gsl_vector* make_cvector_from_rarrays(VALUE ary) { if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary); if (TYPE(ary) == T_ARRAY) { return make_cvector_from_rarray(ary); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(ary)) { return make_cvector_from_narray(ary); #endif } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(ary))); } } void cvector_set_from_carray(gsl_vector *v, const double *a) { size_t i; for (i = 0; i < v->size; i++) gsl_vector_set(v, i, a[i]); } void carray_set_from_cvector(double *a, const gsl_vector *v) { size_t i; for (i = 0; i < v->size; i++) a[i] = gsl_vector_get(v, i); } void carray_set_from_rarrays(double *a, VALUE ary) { if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary); if (TYPE(ary) == T_ARRAY) { return carray_set_from_rarray(a, ary); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(ary)) { return carray_set_from_narray(a, ary); #endif } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(ary))); } } void carray_set_from_rarray(double *a, VALUE ary) { size_t i, size; VALUE val; if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary); Check_Type(ary, T_ARRAY); // size = RARRAY(ary)->len; size = RARRAY_LEN(ary); if (size == 0) return; for (i = 0; i < size; i++) { val = rb_ary_entry(ary, i); Need_Float(val); a[i] = NUM2DBL(val); // a[i] = RFLOAT(val)->value; } } #ifdef HAVE_NARRAY_H /* NArray -> CArray */ void carray_set_from_narray(double *a, VALUE ary) { int size; VALUE ary2; if (!NA_IsNArray(ary)) rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(ary))); size = NA_TOTAL(ary); if (size == 0) return; ary2 = na_change_type(ary, NA_DFLOAT); memcpy(a, NA_PTR_TYPE(ary2,double*), size*sizeof(double)); } /* NArray -> GSL::Vector */ gsl_vector* make_cvector_from_narray(VALUE ary) { gsl_vector *v = NULL; size_t size; VALUE ary2; if (!NA_IsNArray(ary)) rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(ary))); size = NA_TOTAL(ary); v = gsl_vector_alloc(size); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); ary2 = na_change_type(ary, NA_DFLOAT); memcpy(v->data, NA_PTR_TYPE(ary2,double*), size*sizeof(double)); /* cvector_set_from_narray(v, ary);*/ return v; } #endif gsl_vector_complex* make_vector_complex_clone(const gsl_vector_complex *v) { gsl_vector_complex *vnew = NULL; vnew = gsl_vector_complex_alloc(v->size); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_vector_complex_memcpy(vnew, v); return vnew; } gsl_matrix* make_matrix_clone(const gsl_matrix *m) { gsl_matrix *mnew = NULL; mnew = gsl_matrix_alloc(m->size1, m->size2); if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); gsl_matrix_memcpy(mnew, m); return mnew; } gsl_matrix_int* make_matrix_int_clone(const gsl_matrix_int *m) { gsl_matrix_int *mnew = NULL; mnew = gsl_matrix_int_alloc(m->size1, m->size2); if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); gsl_matrix_int_memcpy(mnew, m); return mnew; } VALUE make_matrix_clone2(VALUE vm) { gsl_matrix *m = NULL, *mnew = NULL; Data_Get_Struct(vm, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); gsl_matrix_memcpy(mnew, m); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);; } gsl_matrix_complex* make_matrix_complex_clone(const gsl_matrix_complex *m) { gsl_matrix_complex *mnew = NULL; mnew = gsl_matrix_complex_alloc(m->size1, m->size2); if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_memcpy(mnew, m); return mnew; } gsl_vector_complex* vector_to_complex(const gsl_vector *v) { gsl_vector_complex *cv = NULL; gsl_complex z; size_t i; cv = gsl_vector_complex_alloc(v->size); if (cv == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); for (i = 0; i < v->size; i++) { z = gsl_complex_rect(gsl_vector_get(v, i), 0.0); gsl_vector_complex_set(cv, i, z); } return cv; } gsl_matrix_complex* matrix_to_complex(const gsl_matrix *m) { gsl_matrix_complex *cm = NULL; gsl_complex z; size_t i, j; cm = gsl_matrix_complex_alloc(m->size1, m->size2); if (cm == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { z = gsl_complex_rect(gsl_matrix_get(m, i, j), 0.0); gsl_matrix_complex_set(cm, i, j, z); } } return cm; } void gsl_matrix_complex_mul(gsl_matrix_complex *mnew, const gsl_matrix_complex *m, const gsl_matrix_complex *mb) { gsl_complex a, b, c, sum; size_t i, j, k; for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { sum = gsl_complex_rect(0.0, 0.0); for (k = 0; k < m->size2; k++) { a = gsl_matrix_complex_get(m, j, k); b = gsl_matrix_complex_get(mb, k, i); c = gsl_complex_mul(a, b); sum = gsl_complex_add(sum, c); } gsl_matrix_complex_set(mnew, j, i, sum); } } } void gsl_matrix_mul_vector(gsl_vector *vnew, const gsl_matrix *m, const gsl_vector *v) { size_t i, j; double val; for (i = 0; i < m->size1; i++) { val = 0; for (j = 0; j < m->size2; j++) val += gsl_matrix_get(m, i, j)*gsl_vector_get(v, j); gsl_vector_set(vnew, i, val); } } void gsl_matrix_int_mul_vector(gsl_vector_int *vnew, const gsl_matrix_int *m, const gsl_vector_int *v) { size_t i, j; int val; for (i = 0; i < m->size1; i++) { val = 0; for (j = 0; j < m->size2; j++) val += gsl_matrix_int_get(m, i, j)*gsl_vector_int_get(v, j); gsl_vector_int_set(vnew, i, val); } } void gsl_matrix_complex_mul_vector(gsl_vector_complex *vnew, const gsl_matrix_complex *m, const gsl_vector_complex *v) { gsl_complex a, b, c, sum; size_t i, j; for (i = 0; i < m->size1; i++) { sum = gsl_complex_rect(0.0, 0.0); for (j = 0; j < m->size2; j++) { a = gsl_matrix_complex_get(m, i, j); b = gsl_vector_complex_get(v, j); c = gsl_complex_mul(a, b); sum = gsl_complex_add(sum, c); } gsl_vector_complex_set(vnew, i, sum); } } /*****/ #ifndef GSL_1_12_LATER int gsl_vector_complex_add(gsl_vector_complex *cv, const gsl_vector_complex *cv2) { size_t i; gsl_complex a, b, c; for (i = 0; i < cv->size; i++) { a = gsl_vector_complex_get(cv, i); b = gsl_vector_complex_get(cv2, i); c = gsl_complex_add(a, b); gsl_vector_complex_set(cv, i, c); } return 0; } int gsl_vector_complex_add_constant(gsl_vector_complex *cv, gsl_complex b) { size_t i; gsl_complex a, c; for (i = 0; i < cv->size; i++) { a = gsl_vector_complex_get(cv, i); c = gsl_complex_add(a, b); gsl_vector_complex_set(cv, i, c); } return 0; } int gsl_vector_complex_scale(gsl_vector_complex *cv, gsl_complex b) { size_t i; gsl_complex a, c; for (i = 0; i < cv->size; i++) { a = gsl_vector_complex_get(cv, i); c = gsl_complex_mul(a, b); gsl_vector_complex_set(cv, i, c); } return 0; } int gsl_vector_complex_sub(gsl_vector_complex *cv, const gsl_vector_complex *cv2) { size_t i; gsl_complex a, b, c; for (i = 0; i < cv->size; i++) { a = gsl_vector_complex_get(cv, i); b = gsl_vector_complex_get(cv2, i); c = gsl_complex_sub(a, b); gsl_vector_complex_set(cv, i, c); } return 0; } int gsl_vector_complex_mul(gsl_vector_complex *cv, const gsl_vector_complex *cv2) { size_t i; gsl_complex a, b, c; for (i = 0; i < cv->size; i++) { a = gsl_vector_complex_get(cv, i); b = gsl_vector_complex_get(cv2, i); c = gsl_complex_mul(a, b); gsl_vector_complex_set(cv, i, c); } return 0; } int gsl_vector_complex_div(gsl_vector_complex *cv, const gsl_vector_complex *cv2) { size_t i; gsl_complex a, b, c; for (i = 0; i < cv->size; i++) { a = gsl_vector_complex_get(cv, i); b = gsl_vector_complex_get(cv2, i); c = gsl_complex_div(a, b); gsl_vector_complex_set(cv, i, c); } return 0; } #endif VALUE rb_gsl_range2ary(VALUE obj) { // double beg, en; // size_t n; // int step; VALUE ary; if (CLASS_OF(obj) != rb_cRange) rb_raise(rb_eTypeError, "wrong argument type %s (Range expected)", rb_class2name(CLASS_OF(obj))); ary = rb_funcall(obj, rb_gsl_id_to_a, 0); return ary; } void get_range_beg_en_n(VALUE range, double *beg, double *en, size_t *n, int *step); VALUE rb_gsl_range2vector(VALUE obj) { double beg, en; size_t n; int i, step; gsl_vector *v; if (CLASS_OF(obj) != rb_cRange) rb_raise(rb_eTypeError, "wrong argument type %s (Range expected)", rb_class2name(CLASS_OF(obj))); get_range_beg_en_n(obj, &beg, &en, &n, &step); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, (double) (beg+i)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } void get_range_int_beg_en_n(VALUE range, int *beg, int *en, size_t *n, int *step); VALUE rb_gsl_range2vector_int(VALUE obj) { int beg, en, i, step; size_t n; gsl_vector_int *v; if (CLASS_OF(obj) != rb_cRange) rb_raise(rb_eTypeError, "wrong argument type %s (Range expected)", rb_class2name(CLASS_OF(obj))); get_range_int_beg_en_n(obj, &beg, &en, &n, &step); v = gsl_vector_int_alloc(n); for (i = 0; i < n; i++) gsl_vector_int_set(v, i, beg+i); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v); } gsl_vector_int_view* rb_gsl_vector_int_view_alloc(size_t n) { gsl_vector_int_view *v; v = ALLOC(gsl_vector_int_view); v->vector.size = n; v->vector.stride = 1; v->vector.owner = 0; return v; } void rb_gsl_vector_int_view_free(gsl_vector_int_view *v) { free((gsl_vector_int_view *) v); } gsl_matrix_view* rb_gsl_matrix_view_alloc() { gsl_matrix_view *mv = NULL; mv = ALLOC(gsl_matrix_view); if (mv == NULL) rb_raise(rb_eRuntimeError, "malloc failed"); return mv; } void rb_gsl_matrix_view_free(gsl_matrix_view * mv) { free((gsl_matrix_view *) mv); } gsl_matrix_int_view* rb_gsl_matrix_int_view_alloc() { gsl_matrix_int_view *mv = NULL; mv = ALLOC(gsl_matrix_int_view); if (mv == NULL) rb_raise(rb_eRuntimeError, "malloc failed"); return mv; } void rb_gsl_matrix_int_view_free(gsl_matrix_int_view * mv) { free((gsl_matrix_int_view *) mv); } void Init_gsl_array(VALUE module) { cgsl_block = rb_define_class_under(module, "Block", cGSL_Object); cgsl_block_int = rb_define_class_under(cgsl_block, "Int", cGSL_Object); cgsl_block_uchar = rb_define_class_under(cgsl_block, "Byte", cGSL_Object); cgsl_block_complex = rb_define_class_under(cgsl_block, "Complex", cgsl_block); cgsl_vector = rb_define_class_under(module, "Vector", cGSL_Object); cgsl_vector_col = rb_define_class_under(cgsl_vector, "Col", cgsl_vector); cgsl_vector_complex = rb_define_class_under(cgsl_vector, "Complex", cGSL_Object); cgsl_vector_complex_col = rb_define_class_under(cgsl_vector_complex, "Col", cgsl_vector_complex); cgsl_matrix = rb_define_class_under(module, "Matrix", cGSL_Object); cgsl_matrix_complex = rb_define_class_under(cgsl_matrix, "Complex", cGSL_Object); cgsl_vector_view = rb_define_class_under(cgsl_vector, "View", cgsl_vector); cgsl_vector_col_view = rb_define_class_under(cgsl_vector_col, "View", cgsl_vector_col); cgsl_vector_complex_view = rb_define_class_under(cgsl_vector_complex, "View", cgsl_vector_complex); cgsl_vector_complex_col_view = rb_define_class_under(cgsl_vector_complex_col, "View", cgsl_vector_complex_col); cgsl_vector_int = rb_define_class_under(cgsl_vector, "Int", cGSL_Object); cgsl_vector_int_col = rb_define_class_under(cgsl_vector_int, "Col", cgsl_vector_int); cgsl_vector_int_view = rb_define_class_under(cgsl_vector_int, "View", cgsl_vector_int); cgsl_vector_int_col_view = rb_define_class_under(cgsl_vector_int_col, "View", cgsl_vector_int_col); /*****/ cgsl_matrix_view = rb_define_class_under(cgsl_matrix, "View", cgsl_matrix); cgsl_matrix_complex_view = rb_define_class_under(cgsl_matrix_complex, "View", cgsl_matrix_complex); cgsl_permutation = rb_define_class_under(module, "Permutation", cGSL_Object); cgsl_index = rb_define_class_under(module, "Index", cgsl_permutation); cgsl_vector_view_ro = rb_define_class_under(cgsl_vector_view, "ReadOnly", cgsl_vector_view); cgsl_vector_col_view_ro = rb_define_class_under(cgsl_vector_col_view, "ReadOnly", cgsl_vector_col_view); cgsl_vector_int_view_ro = rb_define_class_under(cgsl_vector_int_view, "ReadOnly", cgsl_vector_int_view); cgsl_vector_int_col_view_ro = rb_define_class_under(cgsl_vector_int_col_view, "ReadOnly", cgsl_vector_int_col_view); cgsl_matrix_view_ro = rb_define_class_under(cgsl_matrix_view, "ReadOnly", cgsl_matrix_view); cgsl_vector_complex_view_ro = rb_define_class_under(cgsl_vector_complex_view, "ReadOnly", cgsl_vector_complex_view); cgsl_matrix_complex_view_ro = rb_define_class_under(cgsl_matrix_complex_view, "ReadOnly", cgsl_matrix_complex_view); /*****/ cgsl_matrix_int = rb_define_class_under(cgsl_matrix, "Int", cGSL_Object); cgsl_matrix_int_view = rb_define_class_under(cgsl_matrix_int, "View", cgsl_matrix_int); cgsl_matrix_int_view_ro = rb_define_class_under(cgsl_matrix_int_view, "ReadOnly", cgsl_matrix_int_view); /*****/ Init_gsl_block_init(module); Init_gsl_block_int_init(module); Init_gsl_block_uchar_init(module); Init_gsl_vector(module); Init_gsl_vector_int(module); Init_gsl_vector_complex(module); Init_gsl_matrix(module); Init_gsl_matrix_int(module); Init_gsl_matrix_complex(module); Init_gsl_permutation(module); #ifdef GSL_1_1_LATER Init_gsl_combination(module); #endif Init_gsl_array_complex(module); Init_gsl_matrix_nmf(); rb_define_method(cgsl_vector_view_ro, "set", rb_gsl_obj_read_only, -1); rb_define_method(cgsl_matrix_view_ro, "set", rb_gsl_obj_read_only, -1); rb_define_method(cgsl_vector_int_view_ro, "set", rb_gsl_obj_read_only, -1); rb_define_method(cgsl_matrix_int_view_ro, "set", rb_gsl_obj_read_only, -1); rb_define_method(cgsl_vector_complex_view_ro, "set", rb_gsl_obj_read_only, -1); rb_define_method(cgsl_matrix_complex_view_ro, "set", rb_gsl_obj_read_only, -1); } gsl-1.15.3/ext/histogram_oper.c0000644000175000017500000000661012220252463015733 0ustar boutilboutil/* gsl_histogram_oper.c * Copyright (C) 2000 Simone Piccardi * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /*************************************************************** * * File gsl_histogram_oper.c: * Routine to make operation on histograms. * Need GSL library and header. * Contains the routines: * gsl_histogram_same_binning check if two histograms have the same binning * gsl_histogram_add add two histograms * gsl_histogram_sub subctract two histograms * gsl_histogram_mult multiply two histograms * gsl_histogram_div divide two histograms * gsl_histogram_scale scale histogram contents * * Author: S. Piccardi * Jan. 2000 * ***************************************************************/ #include #include #include #include /* * gsl_histogram_same_binning: * control if two histograms have the * same binning */ int mygsl_histogram_equal_bins_p (const gsl_histogram * h1, const gsl_histogram * h2) { if (h1->n != h2->n) { return 0; } { size_t i; /* init ranges */ for (i = 0; i <= h1->n; i++) { if (gsl_fcmp(h1->range[i],h2->range[i], 1e-12)) { return 0; } } } return 1; } /* * gsl_histogram_add: * add two histograms */ int mygsl_histogram_add (gsl_histogram * h1, const gsl_histogram * h2) { size_t i; if (!mygsl_histogram_equal_bins_p (h1, h2)) { GSL_ERROR ("histograms have different binning", GSL_EINVAL); } for (i = 0; i < h1->n; i++) { h1->bin[i] += h2->bin[i]; } return GSL_SUCCESS; } /* * gsl_histogram_sub: * subtract two histograms */ int mygsl_histogram_sub (gsl_histogram * h1, const gsl_histogram * h2) { size_t i; if (!mygsl_histogram_equal_bins_p (h1, h2)) { GSL_ERROR ("histograms have different binning", GSL_EINVAL); } for (i = 0; i < h1->n; i++) { h1->bin[i] -= h2->bin[i]; } return GSL_SUCCESS; } /* * gsl_histogram_mult: * multiply two histograms */ int mygsl_histogram_mul (gsl_histogram * h1, const gsl_histogram * h2) { size_t i; if (!mygsl_histogram_equal_bins_p (h1, h2)) { GSL_ERROR ("histograms have different binning", GSL_EINVAL); } for (i = 0; i < h1->n; i++) { h1->bin[i] *= h2->bin[i]; } return GSL_SUCCESS; } /* * gsl_histogram_div: * divide two histograms */ int mygsl_histogram_div (gsl_histogram * h1, const gsl_histogram * h2) { size_t i; if (!mygsl_histogram_equal_bins_p (h1, h2)) { GSL_ERROR ("histograms have different binning", GSL_EINVAL); } for (i = 0; i < h1->n; i++) { h1->bin[i] /= h2->bin[i]; } return GSL_SUCCESS; } gsl-1.15.3/ext/sf_legendre.c0000644000175000017500000003512012220252463015164 0ustar boutilboutil/* legendre.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" EXTERN VALUE cgsl_vector; static VALUE rb_gsl_sf_legendre_P1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_legendre_P1, x); } static VALUE rb_gsl_sf_legendre_P1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_legendre_P1_e, x); } static VALUE rb_gsl_sf_legendre_P2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_legendre_P2, x); } static VALUE rb_gsl_sf_legendre_P2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_legendre_P2_e, x); } static VALUE rb_gsl_sf_legendre_P3(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_legendre_P3, x); } static VALUE rb_gsl_sf_legendre_P3_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_legendre_P3_e, x); } static VALUE rb_gsl_sf_legendre_Pl(VALUE obj, VALUE l, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_legendre_Pl, l, x); } static VALUE rb_gsl_sf_legendre_Pl_e(VALUE obj, VALUE l, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_legendre_Pl_e, l, x); } static VALUE rb_gsl_sf_legendre_Pl_array(VALUE obj, VALUE lmax, VALUE x) { gsl_vector *v = NULL; CHECK_FIXNUM(lmax); Need_Float(x); v = gsl_vector_alloc(FIX2INT(lmax) + 1); gsl_sf_legendre_Pl_array(FIX2INT(lmax), NUM2DBL(x), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_sf_legendre_Q0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_legendre_Q0, x); } static VALUE rb_gsl_sf_legendre_Q0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_legendre_Q0_e, x); } static VALUE rb_gsl_sf_legendre_Q1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_legendre_Q1, x); } static VALUE rb_gsl_sf_legendre_Q1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_legendre_Q1_e, x); } static VALUE rb_gsl_sf_legendre_Ql(VALUE obj, VALUE l, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_legendre_Ql, l, x); } static VALUE rb_gsl_sf_legendre_Ql_e(VALUE obj, VALUE l, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_legendre_Ql_e, l, x); } static VALUE rb_gsl_sf_legendre_Plm(VALUE obj, VALUE l, VALUE m, VALUE x) { return rb_gsl_sf_eval_int_int_double(gsl_sf_legendre_Plm, l, m, x); } static VALUE rb_gsl_sf_legendre_Plm_e(VALUE obj, VALUE l, VALUE m, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; CHECK_FIXNUM(l); CHECK_FIXNUM(m); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = gsl_sf_legendre_Plm_e(FIX2INT(l), FIX2INT(m), NUM2DBL(x), rslt); return rb_ary_new3(2, v, INT2FIX(status)); } static VALUE rb_gsl_sf_legendre_Plm_array(VALUE obj, VALUE lmax, VALUE m, VALUE x) { gsl_vector *v = NULL; int size; int ll, mm; CHECK_FIXNUM(lmax); CHECK_FIXNUM(m); Need_Float(x); ll = FIX2INT(lmax); mm = FIX2INT(m); size = gsl_sf_legendre_array_size(ll, mm); v = gsl_vector_alloc(size); gsl_sf_legendre_Plm_array(ll, mm, NUM2DBL(x), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_sf_legendre_sphPlm(VALUE obj, VALUE l, VALUE m, VALUE x) { return rb_gsl_sf_eval_int_int_double(gsl_sf_legendre_sphPlm, l, m, x); } static VALUE rb_gsl_sf_legendre_sphPlm_e(VALUE obj, VALUE l, VALUE m, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; CHECK_FIXNUM(l); CHECK_FIXNUM(m); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = gsl_sf_legendre_sphPlm_e(FIX2INT(l), FIX2INT(m), NUM2DBL(x), rslt); return rb_ary_new3(2, v, INT2FIX(status)); } static VALUE rb_gsl_sf_legendre_sphPlm_array(VALUE obj, VALUE lmax, VALUE m, VALUE x) { gsl_vector *v = NULL; int size; int ll, mm; CHECK_FIXNUM(lmax); CHECK_FIXNUM(m); Need_Float(x); ll = FIX2INT(lmax); mm = FIX2INT(m); size = gsl_sf_legendre_array_size(ll, mm); v = gsl_vector_alloc(size); gsl_sf_legendre_sphPlm_array(ll, mm, NUM2DBL(x), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_sf_legendre_array_size(VALUE obj, VALUE lmax, VALUE m) { CHECK_FIXNUM(lmax); CHECK_FIXNUM(m); return INT2FIX(gsl_sf_legendre_array_size(FIX2INT(lmax), FIX2INT(m))); } static VALUE rb_gsl_sf_conicalP_half(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_conicalP_half, lambda, x); } static VALUE rb_gsl_sf_conicalP_half_e(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_conicalP_half_e, lambda, x); } static VALUE rb_gsl_sf_conicalP_mhalf(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_conicalP_mhalf, lambda, x); } static VALUE rb_gsl_sf_conicalP_mhalf_e(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_conicalP_mhalf_e, lambda, x); } static VALUE rb_gsl_sf_conicalP_0(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_conicalP_0, lambda, x); } static VALUE rb_gsl_sf_conicalP_0_e(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_conicalP_0_e, lambda, x); } static VALUE rb_gsl_sf_conicalP_1(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_conicalP_1, lambda, x); } static VALUE rb_gsl_sf_conicalP_1_e(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_conicalP_1_e, lambda, x); } static VALUE rb_gsl_sf_conicalP_sph_reg(VALUE obj, VALUE l, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_int_double_double(gsl_sf_conicalP_sph_reg, l, lambda, x); } static VALUE rb_gsl_sf_conicalP_sph_reg_e(VALUE obj, VALUE l, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_int_double2(gsl_sf_conicalP_sph_reg_e, l, lambda, x); } static VALUE rb_gsl_sf_conicalP_cyl_reg(VALUE obj, VALUE m, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_int_double_double(gsl_sf_conicalP_cyl_reg, m, lambda, x); } static VALUE rb_gsl_sf_conicalP_cyl_reg_e(VALUE obj, VALUE m, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_int_double2(gsl_sf_conicalP_cyl_reg_e, m, lambda, x); } static VALUE rb_gsl_sf_legendre_H3d_0(VALUE obj, VALUE lambda, VALUE eta) { Need_Float(lambda); Need_Float(eta); return rb_float_new(gsl_sf_legendre_H3d_0(NUM2DBL(lambda), NUM2DBL(eta))); } static VALUE rb_gsl_sf_legendre_H3d_0_e(VALUE obj, VALUE lambda, VALUE eta) { return rb_gsl_sf_eval_e_double2(gsl_sf_legendre_H3d_0_e, lambda, eta); } static VALUE rb_gsl_sf_legendre_H3d_1(VALUE obj, VALUE lambda, VALUE eta) { Need_Float(lambda); Need_Float(eta); return rb_float_new(gsl_sf_legendre_H3d_1(NUM2DBL(lambda), NUM2DBL(eta))); } static VALUE rb_gsl_sf_legendre_H3d_1_e(VALUE obj, VALUE lambda, VALUE eta) { return rb_gsl_sf_eval_e_double2(gsl_sf_legendre_H3d_1_e, lambda, eta); } static VALUE rb_gsl_sf_legendre_H3d(VALUE obj, VALUE l, VALUE lambda, VALUE eta) { return rb_float_new(gsl_sf_legendre_H3d(FIX2INT(l), NUM2DBL(lambda), NUM2DBL(eta))); } static VALUE rb_gsl_sf_legendre_H3d_e(VALUE obj,VALUE l, VALUE lambda, VALUE eta) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(l); Need_Float(lambda); Need_Float(eta); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_legendre_H3d_e(FIX2INT(l), NUM2DBL(lambda), NUM2DBL(eta), rslt); return v; } static VALUE rb_gsl_sf_legendre_H3d_array(VALUE obj, VALUE lmax, VALUE lambda, VALUE eta) { gsl_vector *v = NULL; CHECK_FIXNUM(lmax); Need_Float(lambda); Need_Float(eta); v = gsl_vector_alloc(FIX2INT(lmax) + 1); gsl_sf_legendre_H3d_array(FIX2INT(lmax), NUM2DBL(lambda), NUM2DBL(eta), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } void Init_gsl_sf_legendre(VALUE module) { VALUE mgsl_sf_leg; rb_define_module_function(module, "legendre_P1", rb_gsl_sf_legendre_P1, 1); rb_define_module_function(module, "legendre_P1_e", rb_gsl_sf_legendre_P1_e, 1); rb_define_module_function(module, "legendre_P2", rb_gsl_sf_legendre_P2, 1); rb_define_module_function(module, "legendre_P2_e", rb_gsl_sf_legendre_P2_e, 1); rb_define_module_function(module, "legendre_P3", rb_gsl_sf_legendre_P3, 1); rb_define_module_function(module, "legendre_P3_e", rb_gsl_sf_legendre_P3_e, 1); rb_define_module_function(module, "legendre_Pl", rb_gsl_sf_legendre_Pl, 2); rb_define_module_function(module, "legendre_Pl_e", rb_gsl_sf_legendre_Pl_e, 2); rb_define_module_function(module, "legendre_Pl_array", rb_gsl_sf_legendre_Pl_array, 2); rb_define_module_function(module, "legendre_Q0", rb_gsl_sf_legendre_Q0, 1); rb_define_module_function(module, "legendre_Q0_e", rb_gsl_sf_legendre_Q0_e, 1); rb_define_module_function(module, "legendre_Q1", rb_gsl_sf_legendre_Q1, 1); rb_define_module_function(module, "legendre_Q1_e", rb_gsl_sf_legendre_Q1_e, 1); rb_define_module_function(module, "legendre_Ql", rb_gsl_sf_legendre_Ql, 2); rb_define_module_function(module, "legendre_Ql_e", rb_gsl_sf_legendre_Ql_e, 2); rb_define_module_function(module, "legendre_Plm", rb_gsl_sf_legendre_Plm, 3); rb_define_module_function(module, "legendre_Plm_e", rb_gsl_sf_legendre_Plm_e, 3); rb_define_module_function(module, "legendre_Plm_array", rb_gsl_sf_legendre_Plm_array, 3); rb_define_module_function(module, "legendre_sphPlm", rb_gsl_sf_legendre_sphPlm, 3); rb_define_module_function(module, "legendre_sphPlm_e", rb_gsl_sf_legendre_sphPlm_e, 3); rb_define_module_function(module, "legendre_sphPlm_array", rb_gsl_sf_legendre_sphPlm_array, 3); rb_define_module_function(module, "legendre_array_size", rb_gsl_sf_legendre_array_size, 2); rb_define_module_function(module, "conicalP_half", rb_gsl_sf_conicalP_half, 2); rb_define_module_function(module, "conicalP_half_e", rb_gsl_sf_conicalP_half_e, 2); rb_define_module_function(module, "conicalP_mhalf", rb_gsl_sf_conicalP_mhalf, 2); rb_define_module_function(module, "conicalP_mhalf_e", rb_gsl_sf_conicalP_mhalf_e, 2); rb_define_module_function(module, "conicalP_0", rb_gsl_sf_conicalP_0, 2); rb_define_module_function(module, "conicalP_0_e", rb_gsl_sf_conicalP_0_e, 2); rb_define_module_function(module, "conicalP_1", rb_gsl_sf_conicalP_1, 2); rb_define_module_function(module, "conicalP_1_e", rb_gsl_sf_conicalP_1_e, 2); rb_define_module_function(module, "conicalP_sph_reg", rb_gsl_sf_conicalP_sph_reg, 3); rb_define_module_function(module, "conicalP_sph_reg_e", rb_gsl_sf_conicalP_sph_reg_e, 3); rb_define_module_function(module, "conicalP_cyl_reg", rb_gsl_sf_conicalP_cyl_reg, 3); rb_define_module_function(module, "conicalP_cyl_reg_e", rb_gsl_sf_conicalP_cyl_reg_e, 3); rb_define_module_function(module, "legendre_H3d_0", rb_gsl_sf_legendre_H3d_0, 2); rb_define_module_function(module, "legendre_H3d_0_e", rb_gsl_sf_legendre_H3d_0_e, 2); rb_define_module_function(module, "legendre_H3d_1", rb_gsl_sf_legendre_H3d_1, 2); rb_define_module_function(module, "legendre_H3d_1_e", rb_gsl_sf_legendre_H3d_1_e, 2); rb_define_module_function(module, "legendre_H3d", rb_gsl_sf_legendre_H3d, 3); rb_define_module_function(module, "legendre_H3d_e", rb_gsl_sf_legendre_H3d_e, 3); rb_define_module_function(module, "legendre_H3d_array", rb_gsl_sf_legendre_H3d_array, 3); /*****/ mgsl_sf_leg = rb_define_module_under(module, "Legendre"); rb_define_module_function(mgsl_sf_leg, "P1", rb_gsl_sf_legendre_P1, 1); rb_define_module_function(mgsl_sf_leg, "P1_e", rb_gsl_sf_legendre_P1_e, 1); rb_define_module_function(mgsl_sf_leg, "P2", rb_gsl_sf_legendre_P2, 1); rb_define_module_function(mgsl_sf_leg, "P2_e", rb_gsl_sf_legendre_P2_e, 1); rb_define_module_function(mgsl_sf_leg, "P3", rb_gsl_sf_legendre_P3, 1); rb_define_module_function(mgsl_sf_leg, "P3_e", rb_gsl_sf_legendre_P3_e, 1); rb_define_module_function(mgsl_sf_leg, "Pl", rb_gsl_sf_legendre_Pl, 2); rb_define_module_function(mgsl_sf_leg, "Pl_e", rb_gsl_sf_legendre_Pl_e, 2); rb_define_module_function(mgsl_sf_leg, "Pl_array", rb_gsl_sf_legendre_Pl_array, 2); rb_define_module_function(mgsl_sf_leg, "Q0", rb_gsl_sf_legendre_Q0, 1); rb_define_module_function(mgsl_sf_leg, "Q0_e", rb_gsl_sf_legendre_Q0_e, 1); rb_define_module_function(mgsl_sf_leg, "Q1", rb_gsl_sf_legendre_Q1, 1); rb_define_module_function(mgsl_sf_leg, "Q1_e", rb_gsl_sf_legendre_Q1_e, 1); rb_define_module_function(mgsl_sf_leg, "Plm", rb_gsl_sf_legendre_Plm, 3); rb_define_module_function(mgsl_sf_leg, "Plm_e", rb_gsl_sf_legendre_Plm_e, 3); rb_define_module_function(mgsl_sf_leg, "Plm_array", rb_gsl_sf_legendre_Plm_array, 3); rb_define_module_function(mgsl_sf_leg, "sphPlm", rb_gsl_sf_legendre_sphPlm, 3); rb_define_module_function(mgsl_sf_leg, "sphPlm_e", rb_gsl_sf_legendre_sphPlm_e, 3); rb_define_module_function(mgsl_sf_leg, "sphPlm_array", rb_gsl_sf_legendre_sphPlm_array, 3); rb_define_module_function(mgsl_sf_leg, "array_size", rb_gsl_sf_legendre_array_size, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_half", rb_gsl_sf_conicalP_half, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_half_e", rb_gsl_sf_conicalP_half_e, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_mhalf", rb_gsl_sf_conicalP_mhalf, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_mhalf_e", rb_gsl_sf_conicalP_mhalf_e, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_0", rb_gsl_sf_conicalP_0, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_0_e", rb_gsl_sf_conicalP_0_e, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_1", rb_gsl_sf_conicalP_1, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_1_e", rb_gsl_sf_conicalP_1_e, 2); rb_define_module_function(mgsl_sf_leg, "conicalP_sph_reg", rb_gsl_sf_conicalP_sph_reg, 3); rb_define_module_function(mgsl_sf_leg, "conicalP_sph_reg_e", rb_gsl_sf_conicalP_sph_reg_e, 3); rb_define_module_function(mgsl_sf_leg, "conicalP_cyl_reg", rb_gsl_sf_conicalP_cyl_reg, 3); rb_define_module_function(mgsl_sf_leg, "conicalP_cyl_reg_e", rb_gsl_sf_conicalP_cyl_reg_e, 3); rb_define_module_function(mgsl_sf_leg, "H3d_0", rb_gsl_sf_legendre_H3d_0, 2); rb_define_module_function(mgsl_sf_leg, "H3d_0_e", rb_gsl_sf_legendre_H3d_0_e, 2); rb_define_module_function(mgsl_sf_leg, "H3d_1", rb_gsl_sf_legendre_H3d_1, 2); rb_define_module_function(mgsl_sf_leg, "H3d_1_e", rb_gsl_sf_legendre_H3d_1_e, 2); rb_define_module_function(mgsl_sf_leg, "H3d", rb_gsl_sf_legendre_H3d, 3); rb_define_module_function(mgsl_sf_leg, "H3d_e", rb_gsl_sf_legendre_H3d_e, 3); rb_define_module_function(mgsl_sf_leg, "H3d_array", rb_gsl_sf_legendre_H3d_array, 3); } gsl-1.15.3/ext/bundle.c0000644000175000017500000000005312220252463014155 0ustar boutilboutil#ifdef HAVE_GSL_GSL_MULTIMIN_FSDF_H #endifgsl-1.15.3/ext/odeiv.c0000644000175000017500000007411112220252463014020 0ustar boutilboutil/* odeiv.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_odeiv.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #ifndef CHECK_SYSTEM #define CHECK_SYSTEM(x) if(CLASS_OF(x)!=cgsl_odeiv_system)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::Odeiv::System expected)",\ rb_class2name(CLASS_OF(x))); #endif #ifndef CHECK_STEP #define CHECK_STEP(x) if(CLASS_OF(x)!=cgsl_odeiv_step)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::Odeiv::Step expected)",\ rb_class2name(CLASS_OF(x))); #endif #ifndef CHECK_CONTROL #define CHECK_CONTROL(x) if(CLASS_OF(x)!=cgsl_odeiv_control)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::Odeiv::Control expected)",\ rb_class2name(CLASS_OF(x))); #endif #ifndef CHECK_EVOLVE #define CHECK_EVOLVE(x) if(CLASS_OF(x)!=cgsl_odeiv_evolve)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::Odeiv::Evolve expected)",\ rb_class2name(CLASS_OF(x))); #endif #ifndef CHECK_SOLVER #define CHECK_SOLVER(x) if(CLASS_OF(x)!=cgsl_odeiv_solver)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::Odeiv::Solver expected)",\ rb_class2name(CLASS_OF(x))); #endif static VALUE cgsl_odeiv_system; static VALUE cgsl_odeiv_step; static VALUE cgsl_odeiv_control; static VALUE cgsl_odeiv_evolve; static VALUE cgsl_odeiv_solver; enum { GSL_ODEIV_STEP_RK2, GSL_ODEIV_STEP_RK4, GSL_ODEIV_STEP_RKF45, GSL_ODEIV_STEP_RKCK, GSL_ODEIV_STEP_RK8PD, GSL_ODEIV_STEP_RK2IMP, GSL_ODEIV_STEP_RK4IMP, GSL_ODEIV_STEP_BSIMP, GSL_ODEIV_STEP_GEAR1, GSL_ODEIV_STEP_GEAR2, GSL_ODEIV_STEP_RK2SIMP, }; typedef struct __rb_gsl_odeiv_evolve { gsl_odeiv_evolve *e; gsl_odeiv_control *c; gsl_odeiv_step *s; gsl_odeiv_system *sys; } gsl_odeiv_solver; static int calc_func(double t, const double y[], double dydt[], void *data); static int calc_jac(double t, const double y[], double *dfdy, double dfdt[], void *data); static int calc_func(double t, const double y[], double dydt[], void *data) { VALUE ary, params, proc; // local variable "result" declared and set, but never used //VALUE result; VALUE vy, vdydt; gsl_vector_view ytmp, dydttmp; size_t dim; ary = (VALUE) data; proc = rb_ary_entry(ary, 0); dim = FIX2INT(rb_ary_entry(ary, 2)); params = rb_ary_entry(ary, 3); ytmp.vector.data = (double *) y; ytmp.vector.stride = 1; ytmp.vector.size = dim; dydttmp.vector.data = dydt; dydttmp.vector.stride = 1; dydttmp.vector.size = dim; vy = Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, &ytmp); vdydt = Data_Wrap_Struct(cgsl_vector_view, 0, NULL, &dydttmp); if (NIL_P(params)) /*result =*/ rb_funcall((VALUE) proc, RBGSL_ID_call, 3, rb_float_new(t), vy, vdydt); else /*result =*/ rb_funcall((VALUE) proc, RBGSL_ID_call, 4, rb_float_new(t), vy, vdydt, params); return GSL_SUCCESS; } static int calc_jac(double t, const double y[], double *dfdy, double dfdt[], void *data) { VALUE params, proc, ary; VALUE vdfdt; // local variable "result" declared and set, but never used //VALUE result; VALUE vy, vmjac; gsl_vector_view ytmp, dfdttmp; gsl_matrix_view mv; size_t dim; ary = (VALUE) data; proc = rb_ary_entry(ary, 1); if (NIL_P(proc)) rb_raise(rb_eRuntimeError, "df function not given"); dim = FIX2INT(rb_ary_entry(ary, 2)); params = rb_ary_entry(ary, 3); ytmp.vector.data = (double *) y; ytmp.vector.size = dim; ytmp.vector.stride = 1; dfdttmp.vector.data = dfdt; dfdttmp.vector.size = dim; dfdttmp.vector.stride = 1; mv = gsl_matrix_view_array(dfdy, dim, dim); vy = Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, &ytmp); vmjac = Data_Wrap_Struct(cgsl_matrix_view, 0, NULL, &mv); vdfdt = Data_Wrap_Struct(cgsl_vector_view, 0, NULL, &dfdttmp); if (NIL_P(params)) /*result =*/ rb_funcall((VALUE) proc, RBGSL_ID_call, 4, rb_float_new(t), vy, vmjac, vdfdt); else /*result =*/ rb_funcall((VALUE) proc, RBGSL_ID_call, 5, rb_float_new(t), vy, vmjac, vdfdt, params); return GSL_SUCCESS; } static void gsl_odeiv_system_mark(gsl_odeiv_system *sys); static void gsl_odeiv_system_mark(gsl_odeiv_system *sys) { rb_gc_mark((VALUE) sys->params); } static gsl_odeiv_system* make_sys(int argc, VALUE *argv); static void set_sys(int argc, VALUE *argv, gsl_odeiv_system *sys); static VALUE rb_gsl_odeiv_system_new(int argc, VALUE *argv, VALUE klass) { VALUE obj; gsl_odeiv_system *sys = NULL; sys = make_sys(argc, argv); obj = Data_Wrap_Struct(klass, gsl_odeiv_system_mark, free, sys); return obj; } static VALUE rb_gsl_odeiv_system_set(int argc, VALUE *argv, VALUE obj) { gsl_odeiv_system *sys = NULL; Data_Get_Struct(obj, gsl_odeiv_system, sys); set_sys(argc, argv, sys); return obj; } static gsl_odeiv_system* make_sys(int argc, VALUE *argv) { gsl_odeiv_system *sys = NULL; sys = ALLOC(gsl_odeiv_system); sys->function = &calc_func; sys->jacobian = &calc_jac; sys->params = NULL; set_sys(argc, argv, sys); return sys; } static void set_sys(int argc, VALUE *argv, gsl_odeiv_system *sys) { size_t dimension; VALUE ary, vjac, dim; VALUE vparams; int itmp; size_t i, j; if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_PROC(argv[0]); if (sys == NULL) { sys = ALLOC(gsl_odeiv_system); sys->function = &calc_func; sys->jacobian = &calc_jac; } if (sys->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) sys->params = ary;*/ sys->params = (void *) ary; } else { ary = (VALUE) sys->params; } rb_ary_store(ary, 1, Qnil); /* function to calc J */ rb_ary_store(ary, 3, Qnil); /* parameters */ itmp = 1; if (rb_obj_is_kind_of(argv[1], rb_cProc)) { vjac = argv[1]; itmp = 2; } else { vjac = Qnil; } if ((dim =argv[itmp++]) == Qnil) dim = argv[itmp++]; switch (argc - itmp) { case 0: vparams = Qnil; break; case 1: vparams = argv[itmp]; break; default: vparams = rb_ary_new2(argc-itmp); for (i = itmp, j = 0; i < argc; i++, j++) rb_ary_store(vparams, j, argv[i]); } dimension = FIX2INT(dim); sys->dimension = dimension; rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, vjac); rb_ary_store(ary, 2, dim); rb_ary_store(ary, 3, vparams); } static VALUE rb_gsl_odeiv_system_set_params(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_odeiv_system_set_params(int argc, VALUE *argv, VALUE obj) { VALUE vparams, ary; gsl_odeiv_system *sys = NULL; size_t i; Data_Get_Struct(obj, gsl_odeiv_system, sys); ary = (VALUE) sys->params; switch (argc) { case 0: vparams = Qnil; break; case 1: vparams = argv[0]; break; default: vparams = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(vparams, i, argv[i]); } // rb_ary_delete_at(ary, 3); rb_ary_store(ary, 3, vparams); return obj; } static VALUE rb_gsl_odeiv_system_params(VALUE obj) { VALUE ary; gsl_odeiv_system *sys = NULL; Data_Get_Struct(obj, gsl_odeiv_system, sys); ary = (VALUE) sys->params; return rb_ary_entry(ary, 3); } static VALUE rb_gsl_odeiv_system_function(VALUE obj) { VALUE ary; gsl_odeiv_system *sys = NULL; Data_Get_Struct(obj, gsl_odeiv_system, sys); ary = (VALUE) sys->params; return rb_ary_entry(ary, 0); } static VALUE rb_gsl_odeiv_system_jacobian(VALUE obj) { VALUE ary; gsl_odeiv_system *sys = NULL; Data_Get_Struct(obj, gsl_odeiv_system, sys); ary = (VALUE) sys->params; return rb_ary_entry(ary, 1); } static VALUE rb_gsl_odeiv_system_dimension(VALUE obj) { gsl_odeiv_system *sys = NULL; Data_Get_Struct(obj, gsl_odeiv_system, sys); return INT2FIX(sys->dimension); } static const gsl_odeiv_step_type* rb_gsl_odeiv_step_type_get(VALUE tt); static gsl_odeiv_step* make_step(VALUE tt, VALUE dim); static VALUE rb_gsl_odeiv_step_new(int argc, VALUE *argv, VALUE klass) { VALUE obj; gsl_odeiv_step *s = NULL; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); s = make_step(INT2FIX(GSL_ODEIV_STEP_RKF45), argv[0]); break; case 2: CHECK_FIXNUM(argv[1]); s = make_step(argv[0], argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } obj = Data_Wrap_Struct(klass, 0, gsl_odeiv_step_free, s); return obj; } static gsl_odeiv_step* make_step(VALUE tt, VALUE dim) { const gsl_odeiv_step_type *T; T = rb_gsl_odeiv_step_type_get(tt); return gsl_odeiv_step_alloc(T, FIX2INT(dim)); } static const gsl_odeiv_step_type* rb_gsl_odeiv_step_type_get(VALUE tt) { const gsl_odeiv_step_type *T; int type; char name[64]; switch (TYPE(tt)) { case T_FIXNUM: type = FIX2INT(tt); switch (type) { case GSL_ODEIV_STEP_RK2: T = gsl_odeiv_step_rk2; break; case GSL_ODEIV_STEP_RK4: T = gsl_odeiv_step_rk4; break; case GSL_ODEIV_STEP_RKF45: T = gsl_odeiv_step_rkf45; break; case GSL_ODEIV_STEP_RKCK: T = gsl_odeiv_step_rkck; break; case GSL_ODEIV_STEP_RK8PD: T = gsl_odeiv_step_rk8pd; break; case GSL_ODEIV_STEP_RK2IMP: T = gsl_odeiv_step_rk2imp; break; case GSL_ODEIV_STEP_RK4IMP: T = gsl_odeiv_step_rk4imp; break; case GSL_ODEIV_STEP_BSIMP: T = gsl_odeiv_step_bsimp; break; case GSL_ODEIV_STEP_GEAR1: T = gsl_odeiv_step_gear1; break; case GSL_ODEIV_STEP_GEAR2: T = gsl_odeiv_step_gear2; break; #ifdef GSL_1_6_LATER case GSL_ODEIV_STEP_RK2SIMP: T = gsl_odeiv_step_rk2simp; break; #endif default: rb_raise(rb_eArgError, "wrong argument type (Fixnum expected)"); break; } break; case T_STRING: strcpy(name, STR2CSTR(tt)); if (str_tail_grep(name, "rk2") == 0) T = gsl_odeiv_step_rk2; else if (str_tail_grep(name, "rk4") == 0) T = gsl_odeiv_step_rk4; else if (str_tail_grep(name, "rkf45") == 0) T = gsl_odeiv_step_rkf45; else if (str_tail_grep(name, "rkck") == 0) T = gsl_odeiv_step_rkck; else if (str_tail_grep(name, "rk8pd") == 0) T = gsl_odeiv_step_rk8pd; else if (str_tail_grep(name, "rk2imp") == 0) T = gsl_odeiv_step_rk2imp; else if (str_tail_grep(name, "rk4imp") == 0) T = gsl_odeiv_step_rk4imp; else if (str_tail_grep(name, "bsimp") == 0) T = gsl_odeiv_step_bsimp; else if (str_tail_grep(name, "gear1") == 0) T = gsl_odeiv_step_gear1; else if (str_tail_grep(name, "gear2") == 0) T = gsl_odeiv_step_gear2; #ifdef GSL_1_6_LATER else if (str_tail_grep(name, "rk2simp") == 0) T = gsl_odeiv_step_rk2simp; #endif else { rb_raise(rb_eArgError, "wrong argument type %s", name); } break; default: rb_raise(rb_eArgError, "wrong argument type %s (String or Fixnum expected)", rb_class2name(CLASS_OF(tt))); break; } return T; } static VALUE rb_gsl_odeiv_step_reset(VALUE obj) { gsl_odeiv_step *s = NULL; Data_Get_Struct(obj, gsl_odeiv_step, s); return INT2FIX(gsl_odeiv_step_reset(s)); } static VALUE rb_gsl_odeiv_step_name(VALUE obj) { gsl_odeiv_step *s = NULL; Data_Get_Struct(obj, gsl_odeiv_step, s); return rb_str_new2(gsl_odeiv_step_name(s)); } static VALUE rb_gsl_odeiv_step_order(VALUE obj) { gsl_odeiv_step *s = NULL; Data_Get_Struct(obj, gsl_odeiv_step, s); return INT2FIX(gsl_odeiv_step_order(s)); } static VALUE rb_gsl_odeiv_step_dimension(VALUE obj) { gsl_odeiv_step *s = NULL; Data_Get_Struct(obj, gsl_odeiv_step, s); return INT2FIX(s->dimension); } static VALUE rb_gsl_odeiv_step_apply(int argc, VALUE *argv, VALUE obj) { gsl_odeiv_step *s = NULL; gsl_odeiv_system *sys = NULL; gsl_vector *y = NULL, *yerr = NULL; gsl_vector *vtmp1 = NULL, *vtmp2 = NULL; double *dydt_in = NULL, *dydt_out = NULL; double t, h; switch (argc) { case 5: break; case 7: if (VECTOR_P(argv[5])) { Data_Get_Struct(argv[5], gsl_vector, vtmp2); if (vtmp2) dydt_out = vtmp2->data; } /* no break */ case 6: if (VECTOR_P(argv[4])) { Data_Get_Struct(argv[4], gsl_vector, vtmp1); if (vtmp1) dydt_in = vtmp1->data; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 5, 6 or 7)", argc); break; } Need_Float(argv[0]); Need_Float(argv[1]); CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[3]); CHECK_SYSTEM(argv[argc-1]); Data_Get_Struct(obj, gsl_odeiv_step, s); t = NUM2DBL(argv[0]); h = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_vector, y); Data_Get_Struct(argv[3], gsl_vector, yerr); Data_Get_Struct(argv[argc-1], gsl_odeiv_system, sys); return INT2FIX(gsl_odeiv_step_apply(s, t, h, y->data, yerr->data, dydt_in, dydt_out, sys)); } static VALUE rb_gsl_odeiv_step_info(VALUE obj) { gsl_odeiv_step *s; char buf[256]; Data_Get_Struct(obj, gsl_odeiv_step, s); sprintf(buf, "Class: %s\n", rb_class2name(CLASS_OF(obj))); #ifdef RUBY_1_9_LATER sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj)))); #else sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super)); #endif sprintf(buf, "%sType: %s\n", buf, gsl_odeiv_step_name(s)); sprintf(buf, "%sDimension: %d\n", buf, (int) s->dimension); return rb_str_new2(buf); } static gsl_odeiv_control* make_control_standard(VALUE epsabs, VALUE epsrel, VALUE ay, VALUE adydt); static gsl_odeiv_control* make_control_y(VALUE epsabs, VALUE epsrel); static VALUE rb_gsl_odeiv_control_standard_new(VALUE klass, VALUE epsabs, VALUE epsrel, VALUE ay, VALUE adydt) { gsl_odeiv_control *c = NULL; c = make_control_standard(epsabs, epsrel, ay, adydt); return Data_Wrap_Struct(klass, 0, gsl_odeiv_control_free, c); } static gsl_odeiv_control* make_control_standard(VALUE epsabs, VALUE epsrel, VALUE ay, VALUE adydt) { Need_Float(epsabs); Need_Float(epsrel); Need_Float(ay); Need_Float(adydt); return gsl_odeiv_control_standard_new(NUM2DBL(epsabs), NUM2DBL(epsrel), NUM2DBL(ay), NUM2DBL(adydt)); } static gsl_odeiv_control* make_control_y(VALUE epsabs, VALUE epsrel) { Need_Float(epsabs); Need_Float(epsrel); return gsl_odeiv_control_y_new(NUM2DBL(epsabs), NUM2DBL(epsrel)); } static VALUE rb_gsl_odeiv_control_y_new(VALUE klass, VALUE epsabs, VALUE epsrel) { gsl_odeiv_control *c = NULL; c = make_control_y(epsabs, epsrel); return Data_Wrap_Struct(klass, 0, gsl_odeiv_control_free, c); } static VALUE rb_gsl_odeiv_control_yp_new(VALUE klass, VALUE epsabs, VALUE epsrel) { gsl_odeiv_control *c = NULL; Need_Float(epsabs); Need_Float(epsrel); c = gsl_odeiv_control_yp_new(NUM2DBL(epsabs), NUM2DBL(epsrel)); return Data_Wrap_Struct(klass, 0, gsl_odeiv_control_free, c); } #ifdef GSL_1_2_LATER static VALUE rb_gsl_odeiv_control_scaled_new(VALUE klass, VALUE epsabs, VALUE epsrel, VALUE ay, VALUE adydt, VALUE sc, VALUE dd) { gsl_odeiv_control *c = NULL; gsl_vector *v = NULL; Need_Float(epsabs); Need_Float(epsrel); Need_Float(ay); Need_Float(adydt); CHECK_FIXNUM(dd); CHECK_VECTOR(sc); Data_Get_Struct(sc, gsl_vector, v); c = gsl_odeiv_control_scaled_new(NUM2DBL(epsabs), NUM2DBL(epsrel), NUM2DBL(ay), NUM2DBL(adydt), v->data, FIX2INT(dd)); return Data_Wrap_Struct(klass, 0, gsl_odeiv_control_free, c); } #endif static VALUE rb_gsl_odeiv_control_init(VALUE obj, VALUE epsabs, VALUE epsrel, VALUE ay, VALUE adydt) { gsl_odeiv_control *c = NULL; Need_Float(epsabs); Need_Float(epsrel); Need_Float(ay); Need_Float(adydt); Data_Get_Struct(obj, gsl_odeiv_control, c); gsl_odeiv_control_init(c, NUM2DBL(epsabs), NUM2DBL(epsrel), NUM2DBL(ay), NUM2DBL(adydt)); return obj; } static VALUE rb_gsl_odeiv_control_name(VALUE obj) { gsl_odeiv_control *c = NULL; Data_Get_Struct(obj, gsl_odeiv_control, c); return rb_str_new2(gsl_odeiv_control_name(c)); } static VALUE rb_gsl_odeiv_control_hadjust(VALUE obj, VALUE ss, VALUE yy0, VALUE yyerr, VALUE ddydt, VALUE hh) { gsl_odeiv_control *c = NULL; gsl_odeiv_step *s = NULL; gsl_vector *y0 = NULL, *yerr = NULL, *dydt = NULL; double h; int status; CHECK_VECTOR(yy0); CHECK_VECTOR(yyerr); CHECK_VECTOR(ddydt); Data_Get_Struct(obj, gsl_odeiv_control, c); Data_Get_Struct(ss, gsl_odeiv_step, s); Data_Get_Struct(yy0, gsl_vector, y0); Data_Get_Struct(yyerr, gsl_vector, yerr); Data_Get_Struct(ddydt, gsl_vector, dydt); h = NUM2DBL(hh); status = gsl_odeiv_control_hadjust(c, s, y0->data, yerr->data, dydt->data, &h); return rb_ary_new3(2, rb_float_new(h), INT2FIX(status)); } static gsl_odeiv_evolve* make_evolve(VALUE dim); static VALUE rb_gsl_odeiv_evolve_new(VALUE klass, VALUE dim) { gsl_odeiv_evolve *e = NULL; e = make_evolve(dim); return Data_Wrap_Struct(klass, 0, gsl_odeiv_evolve_free, e); } static gsl_odeiv_evolve* make_evolve(VALUE dim) { return gsl_odeiv_evolve_alloc(FIX2INT(dim)); } static VALUE rb_gsl_odeiv_evolve_reset(VALUE obj) { gsl_odeiv_evolve *e = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); return INT2FIX(gsl_odeiv_evolve_reset(e)); } static VALUE rb_gsl_odeiv_evolve_count(VALUE obj) { gsl_odeiv_evolve *e = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); return INT2FIX(e->count); } static VALUE rb_gsl_odeiv_evolve_dimension(VALUE obj) { gsl_odeiv_evolve *e = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); return INT2FIX(e->dimension); } static VALUE rb_gsl_odeiv_evolve_failed_steps(VALUE obj) { gsl_odeiv_evolve *e = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); return INT2FIX(e->failed_steps); } static VALUE rb_gsl_odeiv_evolve_last_step(VALUE obj) { gsl_odeiv_evolve *e = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); return rb_float_new(e->last_step); } static VALUE rb_gsl_odeiv_evolve_y0(VALUE obj) { gsl_odeiv_evolve *e = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); v = gsl_vector_view_alloc(); v->vector.data = e->y0; v->vector.size = e->dimension; v->vector.stride = 1; v->vector.owner = 0; return Data_Wrap_Struct(cgsl_vector_view_ro, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_odeiv_evolve_yerr(VALUE obj) { gsl_odeiv_evolve *e = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_odeiv_evolve, e); v = gsl_vector_view_alloc(); v->vector.data = e->yerr; v->vector.size = e->dimension; v->vector.stride = 1; v->vector.owner = 0; return Data_Wrap_Struct(cgsl_vector_view_ro, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_odeiv_evolve_apply(VALUE obj, VALUE cc, VALUE ss, VALUE sss, VALUE tt, VALUE tt1, VALUE hh, VALUE yy) { gsl_odeiv_evolve *e = NULL; gsl_odeiv_control *c = NULL; gsl_odeiv_step *s = NULL; gsl_odeiv_system *sys = NULL; gsl_vector *y = NULL; double t, h; int status; CHECK_STEP(ss); CHECK_SYSTEM(sss); CHECK_VECTOR(yy); Data_Get_Struct(obj, gsl_odeiv_evolve, e); if (NIL_P(cc)) { c = NULL; } else { CHECK_CONTROL(cc); Data_Get_Struct(cc, gsl_odeiv_control, c); } Data_Get_Struct(ss, gsl_odeiv_step, s); Data_Get_Struct(sss, gsl_odeiv_system, sys); Data_Get_Struct(yy, gsl_vector, y); /* if (TYPE(tt) != T_FLOAT) rb_raise(rb_eTypeError, "argument 4 Float expected"); if (TYPE(hh) != T_FLOAT) rb_raise(rb_eTypeError, "argument 6 Float expected");*/ t = NUM2DBL(tt); h = NUM2DBL(hh); status = gsl_odeiv_evolve_apply(e, c, s, sys, &t, NUM2DBL(tt1), &h, y->data); /* RFLOAT(tt)->value = t; RFLOAT(hh)->value = h;*/ return rb_ary_new3(3, rb_float_new(t), rb_float_new(h), INT2FIX(status)); } static void rb_gsl_odeiv_solver_free(gsl_odeiv_solver *gde); static void gsl_odeiv_solver_mark(gsl_odeiv_solver *gos); static VALUE rb_gsl_odeiv_solver_new(int argc, VALUE *argv, VALUE klass) { gsl_odeiv_solver *gos = NULL; VALUE epsabs, epsrel, ay, adydt; VALUE dim; if (argc < 4) rb_raise(rb_eArgError, "too few arguments"); Check_Type(argv[1], T_ARRAY); CHECK_PROC(argv[2]); if (rb_obj_is_kind_of(argv[3], rb_cProc) || NIL_P(argv[3])) { dim = argv[4]; } else { dim = argv[3]; } gos = ALLOC(gsl_odeiv_solver); gos->s = make_step(argv[0], dim); // switch (RARRAY(argv[1])->len) { switch (RARRAY_LEN(argv[1])) { case 2: epsabs = rb_ary_entry(argv[1], 0); epsrel = rb_ary_entry(argv[1], 1); gos->c = make_control_y(epsabs, epsrel); break; case 4: epsabs = rb_ary_entry(argv[1], 0); epsrel = rb_ary_entry(argv[1], 1); ay = rb_ary_entry(argv[1], 2); adydt = rb_ary_entry(argv[1], 3); gos->c = make_control_standard(epsabs, epsrel, ay, adydt); break; default: rb_raise(rb_eArgError, "size of the argument 1 must be 2 or 4"); break; } gos->sys = make_sys(argc - 2, argv + 2); gos->e = make_evolve(dim); return Data_Wrap_Struct(klass, gsl_odeiv_solver_mark, rb_gsl_odeiv_solver_free, gos); // return Data_Wrap_Struct(klass, 0, rb_gsl_odeiv_solver_free, gos); } static void gsl_odeiv_solver_mark(gsl_odeiv_solver *gos) { rb_gc_mark((VALUE) gos->sys->params); } static VALUE rb_gsl_odeiv_solver_evolve(VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); return Data_Wrap_Struct(cgsl_odeiv_evolve, 0, NULL, gos->e); } static VALUE rb_gsl_odeiv_solver_set_evolve(VALUE obj, VALUE ee) { gsl_odeiv_solver *gos = NULL; gsl_odeiv_evolve *e = NULL; CHECK_EVOLVE(ee); Data_Get_Struct(obj, gsl_odeiv_solver, gos); Data_Get_Struct(ee, gsl_odeiv_evolve, e); gos->e = e; return obj; } static VALUE rb_gsl_odeiv_solver_step(VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); return Data_Wrap_Struct(cgsl_odeiv_step, 0, NULL,gos->s); } static VALUE rb_gsl_odeiv_solver_set_step(VALUE obj, VALUE ss) { gsl_odeiv_solver *gos = NULL; gsl_odeiv_step *s = NULL; CHECK_STEP(ss); Data_Get_Struct(obj, gsl_odeiv_solver, gos); Data_Get_Struct(ss, gsl_odeiv_step, s); gos->s = s; return obj; } static VALUE rb_gsl_odeiv_solver_control(VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); return Data_Wrap_Struct(cgsl_odeiv_control, 0, NULL, gos->c); } static VALUE rb_gsl_odeiv_solver_set_control(VALUE obj, VALUE cc) { gsl_odeiv_solver *gos = NULL; gsl_odeiv_control *c = NULL; CHECK_CONTROL(cc); Data_Get_Struct(obj, gsl_odeiv_solver, gos); Data_Get_Struct(cc, gsl_odeiv_control, c); gos->c = c; return obj; } static VALUE rb_gsl_odeiv_solver_sys(VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); return Data_Wrap_Struct(cgsl_odeiv_system, 0, NULL, gos->sys); } static VALUE rb_gsl_odeiv_solver_set_sys(VALUE obj, VALUE ss) { gsl_odeiv_solver *gos = NULL; gsl_odeiv_system *sys = NULL; CHECK_SYSTEM(ss); Data_Get_Struct(obj, gsl_odeiv_solver, gos); Data_Get_Struct(ss, gsl_odeiv_system, sys); gos->sys = sys; return obj; } static VALUE rb_gsl_odeiv_solver_apply(VALUE obj, VALUE tt, VALUE tt1, VALUE hh, VALUE yy) { gsl_odeiv_solver *gos = NULL; gsl_vector *y = NULL; double t, h; int status; CHECK_VECTOR(yy); Need_Float(tt1); Data_Get_Struct(obj, gsl_odeiv_solver, gos); Data_Get_Struct(yy, gsl_vector, y); /* if (TYPE(tt) != T_FLOAT) rb_raise(rb_eTypeError, "argument 0 Float expected"); if (TYPE(hh) != T_FLOAT) rb_raise(rb_eTypeError, "argument 2 Float expected");*/ t = NUM2DBL(tt); h = NUM2DBL(hh); status = gsl_odeiv_evolve_apply(gos->e, gos->c, gos->s, gos->sys, &t, NUM2DBL(tt1), &h, y->data); /* RFLOAT(tt)->value = t; RFLOAT(hh)->value = h; return INT2FIX(status);*/ return rb_ary_new3(3, rb_float_new(t), rb_float_new(h), INT2FIX(status)); } static void rb_gsl_odeiv_solver_free(gsl_odeiv_solver *gos) { free((gsl_odeiv_solver *) gos); } static VALUE rb_gsl_odeiv_solver_reset(VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); gsl_odeiv_step_reset(gos->s); gsl_odeiv_evolve_reset(gos->e); return obj; } static VALUE rb_gsl_odeiv_solver_dim(VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); return INT2FIX(gos->sys->dimension); } static VALUE rb_gsl_odeiv_solver_set_params(int argc, VALUE *argv, VALUE obj) { gsl_odeiv_solver *gos = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, gos); rb_gsl_odeiv_system_set_params(argc, argv, Data_Wrap_Struct(cgsl_odeiv_system, 0, NULL, gos->sys)); return obj; } static VALUE rb_gsl_odeiv_solver_params(VALUE obj) { VALUE ary; gsl_odeiv_solver *solver = NULL; Data_Get_Struct(obj, gsl_odeiv_solver, solver); ary = (VALUE) solver->sys->params; return rb_ary_entry(ary, 3); } void Init_gsl_odeiv(VALUE module) { VALUE mgsl_odeiv; mgsl_odeiv = rb_define_module_under(module, "Odeiv"); rb_define_const(mgsl_odeiv, "HADJ_DEC", INT2FIX(GSL_ODEIV_HADJ_DEC)); rb_define_const(mgsl_odeiv, "HADJ_INC", INT2FIX(GSL_ODEIV_HADJ_INC)); rb_define_const(mgsl_odeiv, "HADJ_NIL", INT2FIX(GSL_ODEIV_HADJ_NIL)); cgsl_odeiv_step = rb_define_class_under(mgsl_odeiv, "Step", cGSL_Object); rb_define_singleton_method(cgsl_odeiv_step, "alloc", rb_gsl_odeiv_step_new, -1); /*****/ rb_define_const(cgsl_odeiv_step, "RK2", INT2FIX(GSL_ODEIV_STEP_RK2)); rb_define_const(cgsl_odeiv_step, "RK4", INT2FIX(GSL_ODEIV_STEP_RK4)); rb_define_const(cgsl_odeiv_step, "RKF45", INT2FIX(GSL_ODEIV_STEP_RKF45)); rb_define_const(cgsl_odeiv_step, "RKCK", INT2FIX(GSL_ODEIV_STEP_RKCK)); rb_define_const(cgsl_odeiv_step, "RK8PD", INT2FIX(GSL_ODEIV_STEP_RK8PD)); rb_define_const(cgsl_odeiv_step, "RK2IMP", INT2FIX(GSL_ODEIV_STEP_RK2IMP)); rb_define_const(cgsl_odeiv_step, "RK4IMP", INT2FIX(GSL_ODEIV_STEP_RK4IMP)); rb_define_const(cgsl_odeiv_step, "BSIMP", INT2FIX(GSL_ODEIV_STEP_BSIMP)); rb_define_const(cgsl_odeiv_step, "GEAR1", INT2FIX(GSL_ODEIV_STEP_GEAR1)); rb_define_const(cgsl_odeiv_step, "GEAR2", INT2FIX(GSL_ODEIV_STEP_GEAR2)); rb_define_const(cgsl_odeiv_step, "RK2SIMP", INT2FIX(GSL_ODEIV_STEP_RK2SIMP)); /*****/ rb_define_method(cgsl_odeiv_step, "reset", rb_gsl_odeiv_step_reset, 0); rb_define_method(cgsl_odeiv_step, "name", rb_gsl_odeiv_step_name, 0); rb_define_method(cgsl_odeiv_step, "order", rb_gsl_odeiv_step_order, 0); rb_define_method(cgsl_odeiv_step, "dimension", rb_gsl_odeiv_step_dimension, 0); rb_define_alias(cgsl_odeiv_step, "dim", "dimension"); rb_define_method(cgsl_odeiv_step, "apply", rb_gsl_odeiv_step_apply, -1); rb_define_method(cgsl_odeiv_step, "info", rb_gsl_odeiv_step_info, 0); /****/ cgsl_odeiv_control = rb_define_class_under(mgsl_odeiv, "Control", cGSL_Object); rb_define_singleton_method(cgsl_odeiv_control, "alloc", rb_gsl_odeiv_control_standard_new, 4); rb_define_singleton_method(cgsl_odeiv_control, "standard_alloc", rb_gsl_odeiv_control_standard_new, 4); rb_define_singleton_method(cgsl_odeiv_control, "y_new", rb_gsl_odeiv_control_y_new, 2); rb_define_singleton_method(cgsl_odeiv_control, "yp_new", rb_gsl_odeiv_control_yp_new, 2); #ifdef GSL_1_2_LATER rb_define_singleton_method(cgsl_odeiv_control, "scaled_alloc", rb_gsl_odeiv_control_scaled_new, 5); #endif rb_define_method(cgsl_odeiv_control, "init", rb_gsl_odeiv_control_init, 4); rb_define_method(cgsl_odeiv_control, "name", rb_gsl_odeiv_control_name, 0); rb_define_method(cgsl_odeiv_control, "hadjust", rb_gsl_odeiv_control_hadjust, 5); /****/ cgsl_odeiv_evolve = rb_define_class_under(mgsl_odeiv, "Evolve", cGSL_Object); rb_define_singleton_method(cgsl_odeiv_evolve, "alloc", rb_gsl_odeiv_evolve_new, 1); rb_define_method(cgsl_odeiv_evolve, "reset", rb_gsl_odeiv_evolve_reset, 0); rb_define_method(cgsl_odeiv_evolve, "apply", rb_gsl_odeiv_evolve_apply, 7); rb_define_method(cgsl_odeiv_evolve, "count", rb_gsl_odeiv_evolve_count, 0); rb_define_method(cgsl_odeiv_evolve, "dimension", rb_gsl_odeiv_evolve_dimension, 0); rb_define_method(cgsl_odeiv_evolve, "failed_steps", rb_gsl_odeiv_evolve_failed_steps, 0); rb_define_method(cgsl_odeiv_evolve, "last_step", rb_gsl_odeiv_evolve_last_step, 0); rb_define_method(cgsl_odeiv_evolve, "y0", rb_gsl_odeiv_evolve_y0, 0); rb_define_method(cgsl_odeiv_evolve, "yerr", rb_gsl_odeiv_evolve_yerr, 0); /*****/ cgsl_odeiv_system = rb_define_class_under(mgsl_odeiv, "System", cGSL_Object); rb_define_singleton_method(cgsl_odeiv_system, "alloc", rb_gsl_odeiv_system_new, -1); rb_define_method(cgsl_odeiv_system, "set", rb_gsl_odeiv_system_set, -1); rb_define_method(cgsl_odeiv_system, "set_params", rb_gsl_odeiv_system_set_params, -1); rb_define_method(cgsl_odeiv_system, "params", rb_gsl_odeiv_system_params, 0); rb_define_method(cgsl_odeiv_system, "function", rb_gsl_odeiv_system_function, 0); rb_define_alias(cgsl_odeiv_system, "func", "function"); rb_define_method(cgsl_odeiv_system, "jacobian", rb_gsl_odeiv_system_jacobian, 0); rb_define_alias(cgsl_odeiv_system, "jac", "jacobian"); rb_define_method(cgsl_odeiv_system, "dimension", rb_gsl_odeiv_system_dimension, 0); rb_define_alias(cgsl_odeiv_system, "dim", "dimension"); /*****/ cgsl_odeiv_solver = rb_define_class_under(mgsl_odeiv, "Solver", cGSL_Object); rb_define_singleton_method(cgsl_odeiv_solver, "alloc", rb_gsl_odeiv_solver_new, -1); rb_define_method(cgsl_odeiv_solver, "step", rb_gsl_odeiv_solver_step, 0); rb_define_method(cgsl_odeiv_solver, "control", rb_gsl_odeiv_solver_control, 0); rb_define_method(cgsl_odeiv_solver, "evolve", rb_gsl_odeiv_solver_evolve, 0); rb_define_method(cgsl_odeiv_solver, "sys", rb_gsl_odeiv_solver_sys, 0); rb_define_method(cgsl_odeiv_solver, "apply", rb_gsl_odeiv_solver_apply, 4); rb_define_method(cgsl_odeiv_solver, "set_evolve", rb_gsl_odeiv_solver_set_evolve, 1); rb_define_method(cgsl_odeiv_solver, "set_step", rb_gsl_odeiv_solver_set_step, 1); rb_define_method(cgsl_odeiv_solver, "set_control", rb_gsl_odeiv_solver_set_control, 1); rb_define_method(cgsl_odeiv_solver, "set_system", rb_gsl_odeiv_solver_set_sys, 1); rb_define_method(cgsl_odeiv_solver, "reset", rb_gsl_odeiv_solver_reset, 0); rb_define_method(cgsl_odeiv_solver, "dim", rb_gsl_odeiv_solver_dim, 0); rb_define_alias(cgsl_odeiv_solver, "dimension", "dim"); rb_define_method(cgsl_odeiv_solver, "set_params", rb_gsl_odeiv_solver_set_params, -1); rb_define_method(cgsl_odeiv_solver, "params", rb_gsl_odeiv_solver_params, 0); } #undef CHECK_SOLVER #undef CHECK_EVOLVE #undef CHECK_CONTROL #undef CHECK_STEP #undef CHECK_SYSTEM gsl-1.15.3/ext/sf_ellint.c0000644000175000017500000001770712220252463014701 0ustar boutilboutil/* sf_ellint.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_ellint_Kcomp(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_ellint_Kcomp, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_ellint_Kcomp, argv[0], argv[1]); } static VALUE rb_gsl_sf_ellint_Kcomp_e(VALUE obj, VALUE k, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_ellint_Kcomp_e, k, m); } static VALUE rb_gsl_sf_ellint_Ecomp(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_ellint_Ecomp, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_ellint_Ecomp, argv[0], argv[1]); } static VALUE rb_gsl_sf_ellint_Ecomp_e(VALUE obj, VALUE k, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_ellint_Ecomp_e, k, m); } static VALUE rb_gsl_sf_ellint_F(int argc, VALUE *argv, VALUE obj) { if (argc == 2) return rb_gsl_sf_eval_double2_m(gsl_sf_ellint_F, argv[0], argv[1], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double2_m(gsl_sf_ellint_F, argv[0], argv[1], argv[2]); } static VALUE rb_gsl_sf_ellint_F_e(VALUE obj, VALUE phi, VALUE k, VALUE m) { return rb_gsl_sf_eval_e_double2_m(gsl_sf_ellint_F_e, phi, k, m); } static VALUE rb_gsl_sf_ellint_E(int argc, VALUE *argv, VALUE obj) { if (argc == 2) return rb_gsl_sf_eval_double2_m(gsl_sf_ellint_E, argv[0], argv[1], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double2_m(gsl_sf_ellint_E, argv[0], argv[1], argv[2]); } static VALUE rb_gsl_sf_ellint_E_e(VALUE obj, VALUE phi, VALUE k, VALUE m) { return rb_gsl_sf_eval_e_double2_m(gsl_sf_ellint_E_e, phi, k, m); } static VALUE rb_gsl_sf_ellint_P(int argc, VALUE *argv, VALUE obj) { if (argc == 3) return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_P, argv[0], argv[1], argv[2], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_P, argv[0], argv[1], argv[2], argv[3]); } static VALUE rb_gsl_sf_ellint_P_e(VALUE obj, VALUE phi, VALUE k, VALUE n, VALUE m) { return rb_gsl_sf_eval_e_double3_m(gsl_sf_ellint_P_e, phi, k, n, m); } static VALUE rb_gsl_sf_ellint_D(int argc, VALUE *argv, VALUE obj) { if (argc == 3) return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_D, argv[0], argv[1], argv[2], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_D, argv[0], argv[1], argv[2], argv[3]); } static VALUE rb_gsl_sf_ellint_D_e(VALUE obj, VALUE phi, VALUE k, VALUE n, VALUE m) { return rb_gsl_sf_eval_e_double3_m(gsl_sf_ellint_D_e, phi, k, n, m); } static VALUE rb_gsl_sf_ellint_RC(int argc, VALUE *argv, VALUE obj) { if (argc == 2) return rb_gsl_sf_eval_double2_m(gsl_sf_ellint_RC, argv[0], argv[1], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double2_m(gsl_sf_ellint_RC, argv[0], argv[1], argv[2]); } static VALUE rb_gsl_sf_ellint_RC_e(VALUE obj, VALUE x, VALUE y, VALUE m) { return rb_gsl_sf_eval_e_double2_m(gsl_sf_ellint_RC_e, x, y, m); } static VALUE rb_gsl_sf_ellint_RD(int argc, VALUE *argv, VALUE obj) { if (argc == 3) return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_RD, argv[0], argv[1], argv[2], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_RD, argv[0], argv[1], argv[2], argv[3]); } static VALUE rb_gsl_sf_ellint_RD_e(VALUE obj, VALUE x, VALUE y, VALUE z, VALUE m) { return rb_gsl_sf_eval_e_double3_m(gsl_sf_ellint_RD_e, x, y, z, m); } static VALUE rb_gsl_sf_ellint_RF(int argc, VALUE *argv, VALUE obj) { if (argc == 3) return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_RF, argv[0], argv[1], argv[2], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double3_m(gsl_sf_ellint_RF, argv[0], argv[1], argv[2], argv[3]); } static VALUE rb_gsl_sf_ellint_RF_e(VALUE obj, VALUE x, VALUE y, VALUE z, VALUE m) { return rb_gsl_sf_eval_e_double3_m(gsl_sf_ellint_RF_e, x, y, z, m); } static VALUE rb_gsl_sf_ellint_RJ(int argc, VALUE *argv, VALUE obj) { if (argc == 4) return rb_gsl_sf_eval_double4_m(gsl_sf_ellint_RJ, argv[0], argv[1], argv[2], argv[3], INT2FIX(GSL_PREC_DOUBLE)); else return rb_gsl_sf_eval_double4_m(gsl_sf_ellint_RJ, argv[0], argv[1], argv[2], argv[3], argv[4]); } static VALUE rb_gsl_sf_ellint_RJ_e(VALUE obj, VALUE x, VALUE y, VALUE z, VALUE p, VALUE m) { return rb_gsl_sf_eval_e_double4_m(gsl_sf_ellint_RJ_e, x, y, z, p, m); } void Init_gsl_sf_ellint(VALUE module) { VALUE mgsl_sf_ellint; rb_define_module_function(module, "ellint_Kcomp", rb_gsl_sf_ellint_Kcomp, -1); rb_define_module_function(module, "ellint_Kcomp_e", rb_gsl_sf_ellint_Kcomp_e, 2); rb_define_module_function(module, "ellint_Ecomp", rb_gsl_sf_ellint_Ecomp, -1); rb_define_module_function(module, "ellint_Ecomp_e", rb_gsl_sf_ellint_Ecomp_e, 2); rb_define_module_function(module, "ellint_F", rb_gsl_sf_ellint_F, -1); rb_define_module_function(module, "ellint_F_e", rb_gsl_sf_ellint_F_e, 3); rb_define_module_function(module, "ellint_E", rb_gsl_sf_ellint_E, -1); rb_define_module_function(module, "ellint_E_e", rb_gsl_sf_ellint_E_e, 3); rb_define_module_function(module, "ellint_P", rb_gsl_sf_ellint_P, -1); rb_define_module_function(module, "ellint_P_e", rb_gsl_sf_ellint_P_e, 4); rb_define_module_function(module, "ellint_D", rb_gsl_sf_ellint_D, -1); rb_define_module_function(module, "ellint_D_e", rb_gsl_sf_ellint_D_e, 4); rb_define_module_function(module, "ellint_RC", rb_gsl_sf_ellint_RC, -1); rb_define_module_function(module, "ellint_RC_e", rb_gsl_sf_ellint_RC_e, 3); rb_define_module_function(module, "ellint_RD", rb_gsl_sf_ellint_RD, -1); rb_define_module_function(module, "ellint_RD_e", rb_gsl_sf_ellint_RD_e, 4); rb_define_module_function(module, "ellint_RF", rb_gsl_sf_ellint_RF, -1); rb_define_module_function(module, "ellint_RF_e", rb_gsl_sf_ellint_RF_e, 4); rb_define_module_function(module, "ellint_RJ", rb_gsl_sf_ellint_RJ, -1); rb_define_module_function(module, "ellint_RJ_e", rb_gsl_sf_ellint_RJ_e, 5); mgsl_sf_ellint = rb_define_module_under(module, "Ellint"); rb_define_module_function(mgsl_sf_ellint, "Kcomp", rb_gsl_sf_ellint_Kcomp, -1); rb_define_module_function(mgsl_sf_ellint, "Kcomp_e", rb_gsl_sf_ellint_Kcomp_e, 2); rb_define_module_function(mgsl_sf_ellint, "Ecomp", rb_gsl_sf_ellint_Ecomp, -1); rb_define_module_function(mgsl_sf_ellint, "Ecomp_e", rb_gsl_sf_ellint_Ecomp_e, 2); rb_define_module_function(mgsl_sf_ellint, "F", rb_gsl_sf_ellint_F, -1); rb_define_module_function(mgsl_sf_ellint, "F_e", rb_gsl_sf_ellint_F_e, 3); rb_define_module_function(mgsl_sf_ellint, "E", rb_gsl_sf_ellint_E, -1); rb_define_module_function(mgsl_sf_ellint, "E_e", rb_gsl_sf_ellint_E_e, 3); rb_define_module_function(mgsl_sf_ellint, "P", rb_gsl_sf_ellint_P, -1); rb_define_module_function(mgsl_sf_ellint, "P_e", rb_gsl_sf_ellint_P_e, 4); rb_define_module_function(mgsl_sf_ellint, "D", rb_gsl_sf_ellint_D, -1); rb_define_module_function(mgsl_sf_ellint, "D_e", rb_gsl_sf_ellint_D_e, 4); rb_define_module_function(mgsl_sf_ellint, "RC", rb_gsl_sf_ellint_RC, -1); rb_define_module_function(mgsl_sf_ellint, "RC_e", rb_gsl_sf_ellint_RC_e, 3); rb_define_module_function(mgsl_sf_ellint, "RD", rb_gsl_sf_ellint_RD, -1); rb_define_module_function(mgsl_sf_ellint, "RD_e", rb_gsl_sf_ellint_RD_e, 4); rb_define_module_function(mgsl_sf_ellint, "RF", rb_gsl_sf_ellint_RF, -1); rb_define_module_function(mgsl_sf_ellint, "RF_e", rb_gsl_sf_ellint_RF_e, 4); rb_define_module_function(mgsl_sf_ellint, "RJ", rb_gsl_sf_ellint_RJ, -1); rb_define_module_function(mgsl_sf_ellint, "RJ_e", rb_gsl_sf_ellint_RJ_e, 5); } gsl-1.15.3/ext/bspline.c0000644000175000017500000000727612220252463014356 0ustar boutilboutil #include "rb_gsl.h" #ifdef GSL_1_9_LATER #include "gsl/gsl_bspline.h" static VALUE cBSWS; static VALUE rb_gsl_bspline_alloc(VALUE klass, VALUE k, VALUE n) { gsl_bspline_workspace *w; w = gsl_bspline_alloc(FIX2INT(k), FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_bspline_free, w); } static VALUE rb_gsl_bspline_ncoeffs(VALUE obj) { gsl_bspline_workspace *w; Data_Get_Struct(obj, gsl_bspline_workspace, w); return INT2FIX((int)gsl_bspline_ncoeffs(w)); } static VALUE rb_gsl_bspline_order(VALUE obj) { gsl_bspline_workspace *w; Data_Get_Struct(obj, gsl_bspline_workspace, w); return INT2FIX((int)gsl_bspline_order(w)); } static VALUE rb_gsl_bspline_nbreak(VALUE obj) { gsl_bspline_workspace *w; Data_Get_Struct(obj, gsl_bspline_workspace, w); return INT2FIX((int)gsl_bspline_nbreak(w)); } static VALUE rb_gsl_bspline_breakpoint(VALUE obj, VALUE i) { gsl_bspline_workspace *w; Data_Get_Struct(obj, gsl_bspline_workspace, w); return rb_float_new(gsl_bspline_breakpoint(FIX2INT(i), w)); } static VALUE rb_gsl_bspline_knots(VALUE obj, VALUE b) { gsl_bspline_workspace *w; gsl_vector *bpts; CHECK_VECTOR(b); Data_Get_Struct(obj, gsl_bspline_workspace, w); Data_Get_Struct(b, gsl_vector, bpts); gsl_bspline_knots(bpts, w); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, w->knots); } static VALUE rb_gsl_bspline_knots_uniform(int argc, VALUE *argv, VALUE obj) { gsl_bspline_workspace *w; int argc2; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (!rb_obj_is_kind_of(argv[argc-1], cBSWS)) { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::BSpline expected)", rb_class2name(CLASS_OF(argv[argc-1]))); } Data_Get_Struct(argv[argc-1], gsl_bspline_workspace, w); argc2 = argc-1; break; default: Data_Get_Struct(obj, gsl_bspline_workspace, w); argc2 = argc; } if (argc2 != 2) rb_raise(rb_eArgError, "Wrong number of arguments."); gsl_bspline_knots_uniform(NUM2DBL(argv[0]), NUM2DBL(argv[1]), w); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, w->knots); } static VALUE rb_gsl_bspline_eval(int argc, VALUE *argv, VALUE obj) { gsl_bspline_workspace *w; double x; gsl_vector *B; VALUE vB; Data_Get_Struct(obj, gsl_bspline_workspace, w); switch (argc) { case 2: CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, B); vB = argv[1]; x = NUM2DBL(argv[0]); break; case 1: x = NUM2DBL(argv[0]); B = gsl_vector_alloc(w->nbreak+w->k-2); vB = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, B); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)", argc); } gsl_bspline_eval(x, B, w); return vB; } #ifdef GSL_1_13_LATER static VALUE rb_gsl_bspline_greville_abscissa(VALUE obj, VALUE i) { gsl_bspline_workspace *w; Data_Get_Struct(obj, gsl_bspline_workspace, w); return rb_float_new(gsl_bspline_greville_abscissa(i, w)); } #endif void Init_bspline(VALUE module) { cBSWS = rb_define_class_under(module, "BSpline", cGSL_Object); rb_define_singleton_method(cBSWS, "alloc", rb_gsl_bspline_alloc, 2); rb_define_method(cBSWS, "ncoeffs", rb_gsl_bspline_ncoeffs, 0); rb_define_method(cBSWS, "order", rb_gsl_bspline_order, 0); rb_define_method(cBSWS, "nbreak", rb_gsl_bspline_nbreak, 0); rb_define_method(cBSWS, "breakpoint", rb_gsl_bspline_breakpoint, 1); rb_define_method(cBSWS, "knots", rb_gsl_bspline_knots, 1); rb_define_method(cBSWS, "knots_uniform", rb_gsl_bspline_knots_uniform, -1); rb_define_singleton_method(cBSWS, "knots_uniform", rb_gsl_bspline_knots_uniform, -1); rb_define_method(cBSWS, "eval", rb_gsl_bspline_eval, -1); #ifdef GSL_1_13_LATER rb_define_method(cBSWS, "greville_abscissa", rb_gsl_bspline_greville_abscissa, 1); #endif } #endif gsl-1.15.3/ext/vector_complex.c0000644000175000017500000021656512220252463015756 0ustar boutilboutil/* vector_complex.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_complex.h" EXTERN VALUE cgsl_complex; static VALUE rb_gsl_vector_complex_inner_product(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_vector_complex_product_to_m(int argc, VALUE *argv, VALUE obj); // From vector_source.c void get_range_beg_en_n(VALUE range, double *beg, double *en, size_t *n, int *step); // // From vector_source.c void parse_subvector_args(int argc, VALUE *argv, size_t size, size_t *offset, size_t *stride, size_t *n); // From complex.c gsl_complex rb_gsl_obj_to_gsl_complex(VALUE obj, gsl_complex *z); static VALUE rb_gsl_vector_complex_new(int argc, VALUE *argv, VALUE klass) { VALUE tmp; gsl_vector_complex *v = NULL; gsl_vector *x, *y; gsl_complex z, *z2 = NULL; size_t n, i; switch (argc) { case 1: switch (TYPE(argv[0])) { case T_FIXNUM: n = FIX2INT(argv[0]); v = gsl_vector_complex_calloc(n); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); break; case T_ARRAY: n = RARRAY_LEN(argv[0]); v = gsl_vector_complex_alloc(n); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); for (i = 0; i < n; i++) { z2 = &z; tmp = rb_ary_entry(argv[0], i); if (TYPE(tmp) == T_ARRAY) { GSL_SET_REAL(z2, NUM2DBL(rb_ary_entry(tmp, 0))); GSL_SET_IMAG(z2, NUM2DBL(rb_ary_entry(tmp, 1))); } else if (COMPLEX_P(tmp)) { Data_Get_Struct(tmp, gsl_complex, z2); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Complex expected)", rb_class2name(CLASS_OF(tmp))); } gsl_vector_complex_set(v, i, *z2); } break; default: rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); break; } break; default: if (argc == 2 && (VECTOR_P(argv[0]) && VECTOR_P(argv[1]))) { Data_Get_Struct(argv[0], gsl_vector, x); Data_Get_Struct(argv[1], gsl_vector, y); n = GSL_MIN_INT(x->size, y->size); v = gsl_vector_complex_alloc(n); for (i = 0; i < n; i++) { z.dat[0] = gsl_vector_get(x, i); z.dat[1] = gsl_vector_get(y, i); gsl_vector_complex_set(v, i, z); } break; } n = argc; v = gsl_vector_complex_alloc(n); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); for (i = 0; i < n; i++) { if (TYPE(argv[i]) == T_ARRAY) { GSL_SET_REAL(&z, NUM2DBL(rb_ary_entry(argv[i], 0))); GSL_SET_IMAG(&z, NUM2DBL(rb_ary_entry(argv[i], 1))); z2 = &z; } else if (COMPLEX_P(argv[i])) { Data_Get_Struct(argv[i], gsl_complex, z2); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Complex expected)", rb_class2name(CLASS_OF(argv[i]))); } gsl_vector_complex_set(v, i, *z2); } break; } return Data_Wrap_Struct(klass, 0, gsl_vector_complex_free, v); } static VALUE rb_gsl_vector_complex_row_new(int argc, VALUE *argv, VALUE klass) { return rb_gsl_vector_complex_new(argc, argv, klass); } static VALUE rb_gsl_vector_complex_calloc(VALUE klass, VALUE nn) { gsl_vector_complex *vc = NULL; CHECK_FIXNUM(nn); vc = gsl_vector_complex_calloc(FIX2INT(nn)); if (vc == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); return Data_Wrap_Struct(klass, 0, gsl_vector_complex_free, vc); } static VALUE rb_gsl_vector_complex_size(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); return INT2FIX(v->size); } static VALUE rb_gsl_vector_complex_stride(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); return INT2FIX(v->stride); } static VALUE rb_gsl_vector_complex_owner(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); return INT2FIX(v->owner); } static VALUE rb_gsl_vector_complex_ptr(VALUE obj, VALUE i) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); return Data_Wrap_Struct(cgsl_complex, 0, NULL, gsl_vector_complex_ptr(v, FIX2INT(i))); } // TODO return Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj),..." where appropriate static VALUE rb_gsl_vector_complex_subvector(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_vector_complex_get(int argc, VALUE *argv, VALUE obj) { VALUE retval = Qnil; gsl_vector_complex *v = NULL, *vnew; gsl_complex *c = NULL; gsl_index *p; int i, k; size_t index, j; // If argc is not 1 or argv[0] is a Range if( argc != 1 || rb_obj_is_kind_of(argv[0], rb_cRange)) { // Treat as call to subvector retval = rb_gsl_vector_complex_subvector(argc, argv, obj); } else { Data_Get_Struct(obj, gsl_vector_complex, v); switch (TYPE(argv[0])) { case T_FIXNUM: CHECK_FIXNUM(argv[0]); i = FIX2INT(argv[0]); if (i < 0) index = (size_t) (v->size + i); else index = (size_t) i; c = ALLOC(gsl_complex); *c = gsl_vector_complex_get(v, index); retval = Data_Wrap_Struct(cgsl_complex, 0, free, c); break; case T_ARRAY: vnew = gsl_vector_complex_alloc(RARRAY_LEN(argv[0])); for (j = 0; j < vnew->size; j++) { i = FIX2INT(rb_ary_entry(argv[0], j)); if (i < 0) i = v->size + i; gsl_vector_complex_set(vnew, j, gsl_vector_complex_get(v, i)); } retval = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); break; default: if (PERMUTATION_P(argv[0])) { Data_Get_Struct(argv[0], gsl_index, p); vnew = gsl_vector_complex_alloc(p->size); for (j = 0; j < p->size; j++) { k = p->data[j]; if (k < 0) k = p->size + j; gsl_vector_complex_set(vnew, j, gsl_vector_complex_get(v, k)); } retval = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } else { // TODO Support Vector::Int (and even Vector?) rb_raise(rb_eTypeError, "wrong argument type %s (Array, Range, GSL::Permutation, or Fixnum expected)", rb_class2name(CLASS_OF(argv[0]))); } break; } } return retval; } static VALUE rb_gsl_vector_complex_set_all(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL; gsl_complex tmp; if (argc < 1) rb_raise(rb_eArgError, "wrong number of arguments"); Data_Get_Struct(obj, gsl_vector_complex, v); switch (argc) { case 1: tmp = rb_gsl_obj_to_gsl_complex(argv[0], NULL); break; case 2: GSL_SET_COMPLEX(&tmp, NUM2DBL(argv[0]), NUM2DBL(argv[1])); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } gsl_vector_complex_set_all(v, tmp); return obj; } void rb_gsl_vector_complex_set_subvector(int argc, VALUE *argv, gsl_vector_complex *v, VALUE other) { gsl_vector_complex *vother; gsl_vector_complex_view vv; gsl_complex tmp; int step; size_t i, offset, stride, n, nother; double beg, end; // assignment to v.subvector(...) parse_subvector_args(argc, argv, v->size, &offset, &stride, &n); vv = gsl_vector_complex_subvector_with_stride(v, offset, stride, n); if(rb_obj_is_kind_of(other, cgsl_vector_complex)) { Data_Get_Struct(other, gsl_vector_complex, vother); if(n != vother->size) { rb_raise(rb_eRangeError, "lengths do not match (%d != %d)", (int) n, (int) vother->size); } // TODO Change to gsl_vector_complex_memmove if/when GSL has such a // function because gsl_vector_memcpy does not handle overlapping regions // (e.g. Views) well. gsl_vector_complex_memcpy(&vv.vector, vother); } else if(rb_obj_is_kind_of(other, rb_cArray)) { // TODO Support other forms of Array contents as well if(n != RARRAY_LEN(other)) { rb_raise(rb_eRangeError, "lengths do not match (%d != %d)", (int) n, (int) RARRAY_LEN(other)); } for(i = 0; i < n; i++) { tmp = rb_gsl_obj_to_gsl_complex(rb_ary_entry(other, i), NULL); gsl_vector_complex_set(&vv.vector, i, tmp); } } else if(rb_obj_is_kind_of(other, rb_cRange)) { get_range_beg_en_n(other, &beg, &end, ¬her, &step); if(n != nother) { rb_raise(rb_eRangeError, "lengths do not match (%d != %d)", (int) n, (int) nother); } GSL_SET_IMAG(&tmp, 0.0); for(i = 0; i < n; i++) { GSL_SET_REAL(&tmp, beg); gsl_vector_complex_set(&vv.vector, i, tmp); beg += step; } } else { tmp = rb_gsl_obj_to_gsl_complex(argv[1], NULL); gsl_vector_complex_set_all(&vv.vector, tmp); } } static VALUE rb_gsl_vector_complex_set(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL; gsl_complex tmp; VALUE other; int ii; if(argc < 1 || argc > 4) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-4)", argc); } Data_Get_Struct(obj, gsl_vector_complex, v); other = argv[argc-1]; if(argc == 1) { // // If assigning from another vector if(VECTOR_P(other) || VECTOR_COMPLEX_P(other)) { // treat as assignment to v.subvector(...) rb_gsl_vector_complex_set_subvector(argc-1, argv, v, other); } else { // treat as set_all rb_gsl_vector_complex_set_all(argc, argv, obj); } } else if(argc == 2 && TYPE(argv[0]) == T_FIXNUM) { // v[i] = x ii = FIX2INT(argv[0]); if(ii < 0) ii += v->size; // Get/make GSL::Complex from second arg tmp = gsl_vector_complex_get(v, ii); rb_gsl_obj_to_gsl_complex(argv[1], &tmp); gsl_vector_complex_set(v, (size_t)ii, tmp); } else { // assignment to v.subvector(...) rb_gsl_vector_complex_set_subvector(argc-1, argv, v, other); } return obj; } static VALUE rb_gsl_vector_complex_each(VALUE obj) { gsl_vector_complex *v = NULL; VALUE vz; gsl_complex * zp; size_t i; Data_Get_Struct(obj, gsl_vector_complex, v); for (i = 0; i < v->size; i++) { vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, zp); *zp = gsl_vector_complex_get(v, i); rb_yield(vz); } return obj; } static VALUE rb_gsl_vector_complex_reverse_each(VALUE obj) { gsl_vector_complex *v = NULL; VALUE vz; gsl_complex * zp; size_t i; Data_Get_Struct(obj, gsl_vector_complex, v); for (i = v->size-1; i >= 0; i--) { vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, zp); *zp = gsl_vector_complex_get(v, i); rb_yield(vz); } return obj; } static VALUE rb_gsl_vector_complex_each_index(VALUE obj) { gsl_vector_complex *v = NULL; size_t i; Data_Get_Struct(obj, gsl_vector_complex, v); for (i = 0; i < v->size; i++) rb_yield(INT2FIX(i)); return obj; } static VALUE rb_gsl_vector_complex_reverse_each_index(VALUE obj) { gsl_vector_complex *v = NULL; size_t i; Data_Get_Struct(obj, gsl_vector_complex, v); for (i = v->size-1; i >= 0; i--) { rb_yield(INT2FIX(i)); if (i == 0) break; } return obj; } static void rb_gsl_vector_complex_collect_native(gsl_vector_complex *src, gsl_vector_complex *dst) { VALUE vz; gsl_complex * zp; size_t i; for (i = 0; i < src->size; i++) { vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, zp); *zp = gsl_vector_complex_get(src, i); vz = rb_yield(vz); CHECK_COMPLEX(vz); Data_Get_Struct(vz, gsl_complex, zp); gsl_vector_complex_set(dst, i, *zp); } } static VALUE rb_gsl_vector_complex_collect(VALUE obj) { gsl_vector_complex *v = NULL, *vnew; Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); rb_gsl_vector_complex_collect_native(v, vnew); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_collect_bang(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); rb_gsl_vector_complex_collect_native(v, v); return obj; } static VALUE rb_gsl_vector_complex_set_zero(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); gsl_vector_complex_set_zero(v); return obj; } static VALUE rb_gsl_vector_complex_set_basis(VALUE obj, VALUE ii) { gsl_vector_complex *v = NULL; CHECK_FIXNUM(ii); Data_Get_Struct(obj, gsl_vector_complex, v); gsl_vector_complex_set_basis(v, FIX2INT(ii)); return obj; } static VALUE rb_gsl_vector_complex_to_s(VALUE obj) { gsl_vector_complex *v = NULL; char buf[64]; size_t i; VALUE str; gsl_complex * z; Data_Get_Struct(obj, gsl_vector_complex, v); if (v->size == 0) return rb_str_new2("[ ]"); str = rb_str_new2("[ "); if (VECTOR_COMPLEX_COL_P(obj)) { for (i = 0; i < v->size; i++) { if (i != 0) { rb_str_cat(str, " ", 2); } z = GSL_COMPLEX_AT(v, i); sprintf(buf, "[%4.3e %4.3e]", GSL_REAL(*z), GSL_IMAG(*z)); if (i != v->size-1) strcat(buf, "\n"); rb_str_cat(str, buf, strlen(buf)); if (i >= 10 && i != v->size-1) { rb_str_cat(str, " ...", 5); break; } } } else { z = GSL_COMPLEX_AT(v, 0); sprintf(buf, "[%4.3e %4.3e]", GSL_REAL(*z), GSL_IMAG(*z)); rb_str_cat(str, buf, strlen(buf)); for (i = 1; i < v->size; i++) { z = GSL_COMPLEX_AT(v, i); sprintf(buf, " [%4.3e %4.3e]", GSL_REAL(*z), GSL_IMAG(*z)); rb_str_cat(str, buf, strlen(buf)); if (i >= 10 && i != v->size-1) { rb_str_cat(str, " ...", 4); break; } } } rb_str_cat(str, " ]", 2); return str; } static VALUE rb_gsl_vector_complex_inspect(VALUE obj) { VALUE str; char buf[128]; gsl_vector_complex *v; Data_Get_Struct(obj, gsl_vector_complex, v); sprintf(buf, "#<%s[%lu]:%#lx>\n", rb_class2name(CLASS_OF(obj)), v->size, NUM2ULONG(rb_obj_id(obj))); str = rb_str_new2(buf); return rb_str_concat(str, rb_gsl_vector_complex_to_s(obj)); } /*static VALUE rb_gsl_vector_complex_fprintf(VALUE obj, VALUE io, VALUE format)*/ static VALUE rb_gsl_vector_complex_fprintf(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *h = NULL; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } Data_Get_Struct(obj, gsl_vector_complex, h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 2) { Check_Type(argv[1], T_STRING); status = gsl_vector_complex_fprintf(fp, h, STR2CSTR(argv[1])); } else { status = gsl_vector_complex_fprintf(fp, h, "%4.3e"); } if (flag == 1) fclose(fp); return INT2FIX(status); } /*static VALUE rb_gsl_vector_complex_printf(VALUE obj, VALUE format)*/ static VALUE rb_gsl_vector_complex_printf(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *h = NULL; int status; Data_Get_Struct(obj, gsl_vector_complex, h); if (argc == 1) { Check_Type(argv[0], T_STRING); status = gsl_vector_complex_fprintf(stdout, h, STR2CSTR(argv[0])); } else { status = gsl_vector_complex_fprintf(stdout, h, "%4.3e"); } return INT2FIX(status); } /* static VALUE rb_gsl_vector_complex_print(VALUE obj); static VALUE rb_gsl_vector_complex_inspect(VALUE obj) { gsl_vector_complex *h = NULL; Data_Get_Struct(obj, gsl_vector_complex, h); printf("%s\n", rb_class2name(CLASS_OF(obj))); rb_gsl_vector_complex_print(obj); return Qtrue; } */ static VALUE rb_gsl_vector_complex_print(VALUE obj) { gsl_vector_complex *h = NULL; gsl_complex *z = NULL; size_t i; Data_Get_Struct(obj, gsl_vector_complex, h); printf("[ "); if (VECTOR_COMPLEX_COL_P(obj)) { printf("\n"); for (i = 0; i < h->size; i++) { z = GSL_COMPLEX_AT(h, i); printf(" [%4.3e %4.3e]\n", GSL_REAL(*z), GSL_IMAG(*z)); } } else { for (i = 0; i < h->size; i++) { z = GSL_COMPLEX_AT(h, i); printf("[%4.3e %4.3e] ", GSL_REAL(*z), GSL_IMAG(*z)); } } printf("]\n"); return obj; } static VALUE rb_gsl_vector_complex_fwrite(VALUE obj, VALUE io) { gsl_vector_complex *h = NULL; FILE *fp = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_vector_complex, h); fp = rb_gsl_open_writefile(io, &flag); status = gsl_vector_complex_fwrite(fp, h); if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_vector_complex_fread(VALUE obj, VALUE io) { gsl_vector_complex *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_vector_complex, h); f = rb_gsl_open_writefile(io, &flag); status = gsl_vector_complex_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_vector_complex_fscanf(VALUE obj, VALUE io) { gsl_vector_complex *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_vector_complex, h); f = rb_gsl_open_writefile(io, &flag); status = gsl_vector_complex_fscanf(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_vector_complex_real(VALUE obj) { gsl_vector_complex *c = NULL; gsl_vector_view *vv = NULL; Data_Get_Struct(obj, gsl_vector_complex, c); vv = gsl_vector_view_alloc(); *vv = gsl_vector_complex_real(c); if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, vv); else return Data_Wrap_Struct(cgsl_vector_col_view, 0, gsl_vector_view_free, vv); } static VALUE rb_gsl_vector_complex_imag(VALUE obj) { gsl_vector_complex *c = NULL; gsl_vector_view *vv = NULL; Data_Get_Struct(obj, gsl_vector_complex, c); vv = gsl_vector_view_alloc(); *vv = gsl_vector_complex_imag(c); if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, vv); else return Data_Wrap_Struct(cgsl_vector_col_view, 0, gsl_vector_view_free, vv); } static VALUE rb_gsl_vector_complex_set_real(VALUE obj, VALUE val) { gsl_vector_complex *v = NULL; gsl_vector_view vv; double d = NUM2DBL(val); Data_Get_Struct(obj, gsl_vector_complex, v); vv = gsl_vector_complex_real(v); gsl_vector_set_all(&vv.vector, d); return obj; } static VALUE rb_gsl_vector_complex_set_imag(VALUE obj, VALUE val) { gsl_vector_complex *v = NULL; gsl_vector_view vv; double d = NUM2DBL(val); Data_Get_Struct(obj, gsl_vector_complex, v); vv = gsl_vector_complex_imag(v); gsl_vector_set_all(&vv.vector, d); return obj; } static VALUE rb_gsl_vector_complex_conj(VALUE obj) { size_t i; gsl_vector_complex *vin = NULL; gsl_vector_complex *vout = NULL; Data_Get_Struct(obj, gsl_vector_complex, vin); vout = gsl_vector_complex_alloc(vin->size); for(i=0; isize; i++) { gsl_vector_complex_set(vout, i, gsl_complex_conjugate( gsl_vector_complex_get(vin, i))); } return Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj), 0, gsl_vector_complex_free, vout); } static VALUE rb_gsl_vector_complex_conj_bang(VALUE obj) { size_t i; gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); for(i=0; isize; i++) { gsl_vector_complex_set(v, i, gsl_complex_conjugate( gsl_vector_complex_get(v, i))); } return obj; } static VALUE rb_gsl_vector_complex_to_a(VALUE obj) { gsl_vector_complex *c = NULL; gsl_complex *z = NULL; size_t i, j; VALUE ary; Data_Get_Struct(obj, gsl_vector_complex, c); ary = rb_ary_new2(c->size*2); for (i = 0, j = 0; i < c->size; i++, j+=2) { z = GSL_COMPLEX_AT(c, i); rb_ary_store(ary, j, rb_float_new(GSL_REAL(*z))); rb_ary_store(ary, j+1, rb_float_new(GSL_IMAG(*z))); } return ary; } static VALUE rb_gsl_vector_complex_to_a2(VALUE obj) { gsl_vector_complex *c = NULL; gsl_complex *znew = NULL, *z = NULL; size_t i; VALUE ary, vz; Data_Get_Struct(obj, gsl_vector_complex, c); ary = rb_ary_new2(c->size); for (i = 0; i < c->size; i++) { z = GSL_COMPLEX_AT(c, i); znew = make_complex(z->dat[0], z->dat[1]); vz = Data_Wrap_Struct(cgsl_complex, 0, free, znew); rb_ary_store(ary, i, vz); } return ary; } gsl_vector_complex_view* gsl_vector_complex_view_alloc() { gsl_vector_complex_view *vv = NULL; vv = ALLOC(gsl_vector_complex_view); if (vv == NULL) rb_raise(rb_eRuntimeError, "malloc failed"); return vv; } void gsl_vector_complex_view_free(gsl_vector_view * vv) { free((gsl_vector_complex_view *) vv); } static VALUE rb_gsl_vector_complex_subvector(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL; gsl_vector_complex_view *vv = NULL; size_t offset, stride, n; Data_Get_Struct(obj, gsl_vector_complex, v); parse_subvector_args(argc, argv, v->size, &offset, &stride, &n); vv = gsl_vector_complex_view_alloc(); *vv = gsl_vector_complex_subvector_with_stride(v, offset, stride, n); if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, vv); else return Data_Wrap_Struct(cgsl_vector_complex_col_view, 0, gsl_vector_complex_view_free, vv); } static VALUE rb_gsl_vector_complex_subvector_with_stride(VALUE obj, VALUE o, VALUE s, VALUE nn) { gsl_vector_complex *v = NULL; gsl_vector_complex_view *vv = NULL; int offset; CHECK_FIXNUM(o); CHECK_FIXNUM(nn); CHECK_FIXNUM(s); offset = NUM2INT(o); Data_Get_Struct(obj, gsl_vector_complex, v); if(offset < 0) { offset += v->size; } vv = gsl_vector_complex_view_alloc(); *vv = gsl_vector_complex_subvector_with_stride(v, (size_t)offset, FIX2INT(s), FIX2INT(nn)); if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, vv); else return Data_Wrap_Struct(cgsl_vector_complex_col_view, 0, gsl_vector_complex_view_free, vv); } /* singleton */ static VALUE rb_gsl_vector_complex_memcpy(VALUE obj, VALUE dst, VALUE src) { gsl_vector_complex *v = NULL, *dest = NULL; CHECK_VECTOR_COMPLEX(dst); CHECK_VECTOR_COMPLEX(src); Data_Get_Struct(dst, gsl_vector_complex, dest); Data_Get_Struct(src, gsl_vector_complex, v); gsl_vector_complex_memcpy(dest, v); return dst; } static VALUE rb_gsl_vector_complex_clone(VALUE obj) { gsl_vector_complex *v = NULL, *vnew = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_vector_complex_memcpy(vnew, v); if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); else return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_reverse(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); gsl_vector_complex_reverse(v); return obj; } static VALUE rb_gsl_vector_complex_reverse2(VALUE obj) { gsl_vector_complex *v = NULL, *vnew = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); gsl_vector_complex_memcpy(vnew, v); gsl_vector_complex_reverse(vnew); if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); else return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_swap_elements(VALUE obj, VALUE i, VALUE j) { gsl_vector_complex *v = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, gsl_vector_complex, v); gsl_vector_complex_swap_elements(v, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE rb_gsl_vector_complex_fftshift_bang(VALUE obj) { gsl_vector_complex *v = NULL; gsl_complex tmp; size_t i, n; Data_Get_Struct(obj, gsl_vector_complex, v); n = v->size; if(n & 1) { // length is odd tmp = gsl_vector_complex_get(v,0); for(i = 0; i < n/2; i++) { gsl_vector_complex_set(v, i, gsl_vector_complex_get(v, i+n/2+1)); gsl_vector_complex_set(v, i+n/2+1, gsl_vector_complex_get(v, i+1)); } gsl_vector_complex_set(v, n/2, tmp); } else { // length is even for(i = 0; i < n/2; i++) { gsl_vector_complex_swap_elements(v, i, i+n/2); } } return obj; } static VALUE rb_gsl_vector_complex_fftshift(VALUE obj) { gsl_vector_complex *v, *vnew; gsl_vector_complex_view vv, vvnew; size_t n; Data_Get_Struct(obj, gsl_vector_complex, v); n = v->size; vnew = gsl_vector_complex_alloc(n); // Copy low to high vv = gsl_vector_complex_subvector(v, 0, (n+1)/2); vvnew = gsl_vector_complex_subvector(vnew, n/2, (n+1)/2); gsl_vector_complex_memcpy(&vvnew.vector, &vv.vector); // Copy high to low vv = gsl_vector_complex_subvector(v, (n+1)/2, n/2); vvnew = gsl_vector_complex_subvector(vnew, 0, n/2); gsl_vector_complex_memcpy(&vvnew.vector, &vv.vector); return Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj), 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_ifftshift_bang(VALUE obj) { gsl_vector_complex *v = NULL; gsl_complex tmp; size_t i, n; Data_Get_Struct(obj, gsl_vector_complex, v); n = v->size; if(n & 1) { // length is odd tmp = gsl_vector_complex_get(v,n/2); for(i = n/2; i > 0; i--) { gsl_vector_complex_set(v, i, gsl_vector_complex_get(v, i+n/2)); gsl_vector_complex_set(v, i+n/2, gsl_vector_complex_get(v, i-1)); } gsl_vector_complex_set(v, 0, tmp); } else { // length is even for(i = 0; i < n/2; i++) { gsl_vector_complex_swap_elements(v, i, i+n/2); } } return obj; } static VALUE rb_gsl_vector_complex_ifftshift(VALUE obj) { return rb_gsl_vector_complex_ifftshift_bang(rb_gsl_vector_complex_clone(obj)); gsl_vector_complex *v, *vnew; gsl_vector_complex_view vv, vvnew; size_t n; Data_Get_Struct(obj, gsl_vector_complex, v); n = v->size; vnew = gsl_vector_complex_alloc(n); // Copy high to low vv = gsl_vector_complex_subvector(vnew, n/2, (n+1)/2); vvnew = gsl_vector_complex_subvector(v, 0, (n+1)/2); gsl_vector_complex_memcpy(&vvnew.vector, &vv.vector); // Copy low to high vv = gsl_vector_complex_subvector(vnew, 0, n/2); vvnew = gsl_vector_complex_subvector(v, (n+1)/2, n/2); gsl_vector_complex_memcpy(&vvnew.vector, &vv.vector); return Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj), 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_isnull(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); if (gsl_vector_complex_isnull(v)) return Qtrue; else return Qfalse; } static VALUE rb_gsl_vector_complex_matrix_view(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL; gsl_matrix_complex_view *mv = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); switch (argc) { case 2: mv = gsl_matrix_complex_view_alloc(); *mv = gsl_matrix_complex_view_vector(v, FIX2INT(argv[0]), FIX2INT(argv[1])); break; case 3: mv = gsl_matrix_complex_view_alloc(); *mv = gsl_matrix_complex_view_vector_with_tda(v, FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2])); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } return Data_Wrap_Struct(cgsl_matrix_complex_view, 0, gsl_matrix_complex_view_free, mv); } static VALUE rb_gsl_vector_complex_matrix_view_with_tda(VALUE obj, VALUE nn1, VALUE nn2, VALUE tda) { gsl_vector_complex *v = NULL; gsl_matrix_complex_view *mv = NULL; CHECK_FIXNUM(nn1); CHECK_FIXNUM(nn2); CHECK_FIXNUM(tda); Data_Get_Struct(obj, gsl_vector_complex, v); mv = gsl_matrix_complex_view_alloc(); if (mv == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); *mv = gsl_matrix_complex_view_vector_with_tda(v, FIX2INT(nn1), FIX2INT(nn2), FIX2INT(tda)); return Data_Wrap_Struct(cgsl_matrix_complex_view, 0, gsl_matrix_complex_view_free, mv); } static VALUE rb_gsl_vector_complex_trans(VALUE obj) { gsl_vector_complex *v = NULL, *vnew = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); vnew = make_vector_complex_clone(v); if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, vnew); else if (VECTOR_COMPLEX_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); else { rb_raise(rb_eTypeError, "wrong type"); } } static VALUE rb_gsl_vector_complex_trans2(VALUE obj) { if (CLASS_OF(obj) == cgsl_vector_complex) RBASIC(obj)->klass = cgsl_vector_complex_col; else if (CLASS_OF(obj) == cgsl_vector_complex_col) RBASIC(obj)->klass = cgsl_vector_complex; else { rb_raise(rb_eRuntimeError, "method trans! for %s is forbidden", rb_class2name(CLASS_OF(obj))); } return obj; } static VALUE rb_gsl_vector_complex_to_real(VALUE obj) { gsl_vector_complex *cv = NULL; gsl_vector *v = NULL; gsl_complex z; size_t i; Data_Get_Struct(obj, gsl_vector_complex, cv); v = gsl_vector_alloc(cv->size); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); for (i = 0; i < cv->size; i++) { z = gsl_vector_complex_get(cv, i); gsl_vector_set(v, i, GSL_REAL(z)); } if (VECTOR_COMPLEX_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); else return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, v); } enum { GSL_VECTOR_COMPLEX_ADD, GSL_VECTOR_COMPLEX_SUB, GSL_VECTOR_COMPLEX_MUL, GSL_VECTOR_COMPLEX_DIV, GSL_VECTOR_COMPLEX_ADD_BANG, GSL_VECTOR_COMPLEX_SUB_BANG, GSL_VECTOR_COMPLEX_MUL_BANG, GSL_VECTOR_COMPLEX_DIV_BANG, }; static VALUE rb_gsl_vector_complex_arithmetics(int flag, VALUE obj, VALUE bb); static VALUE rb_gsl_vector_complex_arithmetics(int flag, VALUE obj, VALUE bb) { gsl_vector *b = NULL; gsl_vector_complex *cv = NULL, *cvnew = NULL, *cb = NULL; gsl_complex *c = NULL, z; Data_Get_Struct(obj, gsl_vector_complex, cv); switch (flag) { case GSL_VECTOR_COMPLEX_ADD: case GSL_VECTOR_COMPLEX_SUB: case GSL_VECTOR_COMPLEX_MUL: case GSL_VECTOR_COMPLEX_DIV: cvnew = make_vector_complex_clone(cv); obj = Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj), 0, gsl_vector_complex_free, cvnew); break; case GSL_VECTOR_COMPLEX_ADD_BANG: case GSL_VECTOR_COMPLEX_SUB_BANG: case GSL_VECTOR_COMPLEX_MUL_BANG: case GSL_VECTOR_COMPLEX_DIV_BANG: cvnew = cv; break; default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } switch (TYPE(bb)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: z = gsl_complex_rect(NUM2DBL(bb), 0.0); switch (flag) { case GSL_VECTOR_COMPLEX_ADD: case GSL_VECTOR_COMPLEX_ADD_BANG: gsl_vector_complex_add_constant(cvnew, z); break; case GSL_VECTOR_COMPLEX_SUB: case GSL_VECTOR_COMPLEX_SUB_BANG: gsl_vector_complex_add_constant(cvnew, gsl_complex_negative(z)); break; case GSL_VECTOR_COMPLEX_MUL: case GSL_VECTOR_COMPLEX_MUL_BANG: gsl_vector_complex_scale(cvnew, z); break; case GSL_VECTOR_COMPLEX_DIV: case GSL_VECTOR_COMPLEX_DIV_BANG: gsl_vector_complex_scale(cvnew, gsl_complex_inverse(z)); break; } break; default: if (VECTOR_P(bb)) { Data_Get_Struct(bb, gsl_vector, b); cb = vector_to_complex(b); switch (flag) { case GSL_VECTOR_COMPLEX_ADD: case GSL_VECTOR_COMPLEX_ADD_BANG: gsl_vector_complex_add(cvnew, cb); break; case GSL_VECTOR_COMPLEX_SUB: case GSL_VECTOR_COMPLEX_SUB_BANG: gsl_vector_complex_sub(cvnew, cb); break; case GSL_VECTOR_COMPLEX_MUL: case GSL_VECTOR_COMPLEX_MUL_BANG: gsl_vector_complex_mul(cvnew, cb); break; case GSL_VECTOR_COMPLEX_DIV: case GSL_VECTOR_COMPLEX_DIV_BANG: gsl_vector_complex_div(cvnew, cb); break; } gsl_vector_complex_free(cb); } else if (VECTOR_COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_vector_complex, cb); switch (flag) { case GSL_VECTOR_COMPLEX_ADD: case GSL_VECTOR_COMPLEX_ADD_BANG: gsl_vector_complex_add(cvnew, cb); break; case GSL_VECTOR_COMPLEX_SUB: case GSL_VECTOR_COMPLEX_SUB_BANG: gsl_vector_complex_sub(cvnew, cb); break; case GSL_VECTOR_COMPLEX_MUL: case GSL_VECTOR_COMPLEX_MUL_BANG: gsl_vector_complex_mul(cvnew, cb); break; case GSL_VECTOR_COMPLEX_DIV: case GSL_VECTOR_COMPLEX_DIV_BANG: gsl_vector_complex_div(cvnew, cb); break; } } else if (COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_complex, c); switch (flag) { case GSL_VECTOR_COMPLEX_ADD: case GSL_VECTOR_COMPLEX_ADD_BANG: gsl_vector_complex_add_constant(cvnew, *c); break; case GSL_VECTOR_COMPLEX_SUB: case GSL_VECTOR_COMPLEX_SUB_BANG: gsl_vector_complex_add_constant(cvnew, gsl_complex_negative(*c)); break; case GSL_VECTOR_COMPLEX_MUL: case GSL_VECTOR_COMPLEX_MUL_BANG: gsl_vector_complex_scale(cvnew, *c); break; case GSL_VECTOR_COMPLEX_DIV: case GSL_VECTOR_COMPLEX_DIV_BANG: gsl_vector_complex_scale(cvnew, gsl_complex_inverse(*c)); break; } } else { rb_raise(rb_eTypeError, "wrong type argument %s", rb_class2name(CLASS_OF(bb))); } break; } return obj; } static VALUE rb_gsl_vector_complex_add(VALUE obj, VALUE bb) { return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_ADD, obj, bb); } static VALUE rb_gsl_vector_complex_sub(VALUE obj, VALUE bb) { return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_SUB, obj, bb); } static VALUE rb_gsl_vector_complex_mul(VALUE obj, VALUE bb) { VALUE argv[2]; if (VECTOR_COMPLEX_ROW_P(obj) && VECTOR_COMPLEX_COL_P(bb)) { argv[0] = obj; argv[1] = bb; return rb_gsl_vector_complex_inner_product(2, argv, CLASS_OF(obj)); } if (VECTOR_COMPLEX_COL_P(obj) && VECTOR_COMPLEX_ROW_P(bb)) { argv[0] = obj; argv[1] = bb; return rb_gsl_vector_complex_product_to_m(2, argv, CLASS_OF(obj)); } return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_MUL, obj, bb); } static VALUE rb_gsl_vector_complex_div(VALUE obj, VALUE bb) { return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_DIV, obj, bb); } static VALUE rb_gsl_vector_complex_add_bang(VALUE obj, VALUE bb) { return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_ADD_BANG, obj, bb); } static VALUE rb_gsl_vector_complex_sub_bang(VALUE obj, VALUE bb) { return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_SUB_BANG, obj, bb); } static VALUE rb_gsl_vector_complex_mul_bang(VALUE obj, VALUE bb) { return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_MUL_BANG, obj, bb); } static VALUE rb_gsl_vector_complex_div_bang(VALUE obj, VALUE bb) { return rb_gsl_vector_complex_arithmetics(GSL_VECTOR_COMPLEX_DIV_BANG, obj, bb); } static VALUE rb_gsl_vector_complex_coerce(VALUE obj, VALUE other) { gsl_vector_complex *cv = NULL, *cb = NULL; gsl_complex z; VALUE vv; Data_Get_Struct(obj, gsl_vector_complex, cv); switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: z = gsl_complex_rect(NUM2DBL(other), 0.0); cb = gsl_vector_complex_alloc(cv->size); if (cb == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_vector_complex_set_all(cb, z); vv = Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj), 0, gsl_vector_complex_free, cb); return rb_ary_new3(2, vv, obj); break; default: rb_raise(rb_eTypeError, "GSL::Vector::Complex, operation not defined"); break; } } /* 2.Aug.2004 */ static VALUE rb_gsl_vector_complex_inner_product(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL, *v2 = NULL; gsl_complex prod, a, b, *z = NULL; size_t i; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); if (!VECTOR_COMPLEX_ROW_P(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Complex expected)", rb_class2name(CLASS_OF(argv[0]))); if (!VECTOR_COMPLEX_COL_P(argv[1])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Complex::Col expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[0], gsl_vector_complex, v); Data_Get_Struct(argv[1], gsl_vector_complex, v2); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); if (!VECTOR_COMPLEX_COL_P(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Complex::Col expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(obj, gsl_vector_complex, v); Data_Get_Struct(argv[0], gsl_vector_complex, v2); break; } if (v->size != v2->size) rb_raise(rb_eRangeError, "vector lengths are different."); prod = gsl_complex_rect(0.0, 0.0); for (i = 0; i < v->size; i++) { a = gsl_vector_complex_get(v, i); b = gsl_vector_complex_get(v2, i); prod = gsl_complex_add(prod, gsl_complex_mul(a, b)); } z = ALLOC(gsl_complex); *z = prod; return Data_Wrap_Struct(cgsl_complex, 0, free, z); } static VALUE rb_gsl_vector_complex_product_to_m(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL, *v2 = NULL; gsl_matrix_complex *m = NULL; gsl_complex a, b; size_t i, j; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); if (!VECTOR_COMPLEX_COL_P(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Complex::Col expected)", rb_class2name(CLASS_OF(argv[0]))); if (!VECTOR_COMPLEX_ROW_P(argv[1])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Complex expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[0], gsl_vector_complex, v); Data_Get_Struct(argv[1], gsl_vector_complex, v2); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); if (!VECTOR_COMPLEX_ROW_P(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Complex expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(obj, gsl_vector_complex, v); Data_Get_Struct(argv[0], gsl_vector_complex, v2); break; } m = gsl_matrix_complex_alloc(v->size, v2->size); for (i = 0; i < v->size; i++) { for (j = 0; j < v2->size; j++) { a = gsl_vector_complex_get(v, i); b = gsl_vector_complex_get(v2, j); gsl_matrix_complex_set(m, i, j, gsl_complex_mul(a, b)); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, m); } static VALUE rb_gsl_vector_complex_uplus(VALUE obj) { return obj; } static VALUE rb_gsl_vector_complex_uminus(VALUE obj) { gsl_vector_complex *v = NULL, *vnew; size_t i; Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_complex_set(vnew, i, gsl_complex_negative(gsl_vector_complex_get(v, i))); } return Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj), 0, gsl_vector_complex_free, vnew); } /*****/ static VALUE rb_gsl_vector_complex_XXX(VALUE obj, double (*f)(gsl_complex)) { gsl_vector_complex *m; gsl_vector *v; gsl_complex c; size_t i; Data_Get_Struct(obj, gsl_vector_complex, m); v = gsl_vector_alloc(m->size); for (i = 0; i < m->size; i++) { c = gsl_vector_complex_get(m, i); gsl_vector_set(v, i, (*f)(c)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_vector_complex_XXXz(VALUE obj, gsl_complex (*f)(gsl_complex)) { gsl_vector_complex *m, *v; gsl_complex c; size_t i; Data_Get_Struct(obj, gsl_vector_complex, m); v = gsl_vector_complex_alloc(m->size); for (i = 0; i < m->size; i++) { c = gsl_vector_complex_get(m, i); gsl_vector_complex_set(v, i, (*f)(c)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v); } /* In-place version of rb_gsl_vector_complex_XXXz */ static VALUE rb_gsl_vector_complex_XXXz_bang(VALUE obj, gsl_complex (*f)(gsl_complex)) { gsl_vector_complex *v; gsl_complex c; size_t i; Data_Get_Struct(obj, gsl_vector_complex, v); for (i = 0; i < v->size; i++) { c = gsl_vector_complex_get(v, i); gsl_vector_complex_set(v, i, (*f)(c)); } return obj; } static VALUE rb_gsl_vector_complex_XXXz2(VALUE obj, VALUE a, gsl_complex (*f)(gsl_complex, gsl_complex)) { gsl_vector_complex *m, *v; gsl_complex c, *z; size_t i; CHECK_COMPLEX(a); Data_Get_Struct(obj, gsl_vector_complex, m); Data_Get_Struct(a, gsl_complex, z); v = gsl_vector_complex_alloc(m->size); for (i = 0; i < m->size; i++) { c = gsl_vector_complex_get(m, i); gsl_vector_complex_set(v, i, (*f)(c, *z)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v); } static VALUE rb_gsl_vector_complex_XXXz2_bang(VALUE obj, VALUE a, gsl_complex (*f)(gsl_complex, gsl_complex)) { gsl_vector_complex *v; gsl_complex c, *z; size_t i; CHECK_COMPLEX(a); Data_Get_Struct(obj, gsl_vector_complex, v); Data_Get_Struct(a, gsl_complex, z); for (i = 0; i < v->size; i++) { c = gsl_vector_complex_get(v, i); gsl_vector_complex_set(v, i, (*f)(c, *z)); } return obj; } static VALUE rb_gsl_vector_complex_abs2(VALUE obj) { return rb_gsl_vector_complex_XXX(obj, gsl_complex_abs2); } static VALUE rb_gsl_vector_complex_abs(VALUE obj) { return rb_gsl_vector_complex_XXX(obj, gsl_complex_abs); } static VALUE rb_gsl_vector_complex_logabs(VALUE obj) { return rb_gsl_vector_complex_XXX(obj, gsl_complex_logabs); } static VALUE rb_gsl_vector_complex_arg(VALUE obj) { return rb_gsl_vector_complex_XXX(obj, gsl_complex_arg); } static VALUE rb_gsl_vector_complex_sqrt(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_sqrt); } static VALUE rb_gsl_vector_complex_sqrt_bang(VALUE obj) { return rb_gsl_vector_complex_XXXz_bang(obj, gsl_complex_sqrt); } static VALUE rb_gsl_vector_complex_exp(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_exp); } static VALUE rb_gsl_vector_complex_exp_bang(VALUE obj) { return rb_gsl_vector_complex_XXXz_bang(obj, gsl_complex_exp); } static VALUE rb_gsl_vector_complex_pow(VALUE obj, VALUE a) { return rb_gsl_vector_complex_XXXz2(obj, a, gsl_complex_pow); } static VALUE rb_gsl_vector_complex_pow_bang(VALUE obj, VALUE a) { return rb_gsl_vector_complex_XXXz2_bang(obj, a, gsl_complex_pow); } static VALUE rb_gsl_vector_complex_log(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_log); } static VALUE rb_gsl_vector_complex_log_bang(VALUE obj) { return rb_gsl_vector_complex_XXXz_bang(obj, gsl_complex_log); } static VALUE rb_gsl_vector_complex_log10(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_log10); } static VALUE rb_gsl_vector_complex_log10_bang(VALUE obj) { return rb_gsl_vector_complex_XXXz_bang(obj, gsl_complex_log10); } static VALUE rb_gsl_vector_complex_log_b(VALUE obj, VALUE a) { return rb_gsl_vector_complex_XXXz2(obj, a, gsl_complex_log_b); } static VALUE rb_gsl_vector_complex_log_b_bang(VALUE obj, VALUE a) { return rb_gsl_vector_complex_XXXz2_bang(obj, a, gsl_complex_log_b); } /* gsl_vector_complex_sum */ static gsl_complex rb_gsl_vector_complex_sum_gsl(gsl_vector_complex * v) { size_t i; gsl_complex z = gsl_complex_rect(0.0,0.0); for(i=0; isize; i++) { z = gsl_complex_add(z, gsl_vector_complex_get(v,i)); } return z; } /* gsl_vector_complex_mean */ static gsl_complex rb_gsl_vector_complex_mean_gsl(gsl_vector_complex * v) { gsl_complex z = rb_gsl_vector_complex_sum_gsl(v); return gsl_complex_div_real(z, (double)v->size); } /* gsl_vector_complex_tss_m */ static double rb_gsl_vector_complex_tss_m_gsl(gsl_vector_complex * v, gsl_complex mean) { size_t i; double tss = 0.0; for(i=0; isize; i++) { tss += gsl_complex_abs2(gsl_complex_sub(gsl_vector_complex_get(v,i), mean)); } return tss; } /* gsl_vector_complex_variance_m */ static double rb_gsl_vector_complex_variance_m_gsl(gsl_vector_complex * v, gsl_complex mean) { double tss = rb_gsl_vector_complex_tss_m_gsl(v, mean); return tss / (double)(v->size - 1); } /* gsl_vector_complex_variance_with_fixed_mean */ static double rb_gsl_vector_complex_variance_fm_gsl(gsl_vector_complex * v, gsl_complex mean) { double tss = rb_gsl_vector_complex_tss_m_gsl(v, mean); return tss / (double)(v->size); } /* gsl_vector_complex_sd_m */ static double rb_gsl_vector_complex_sd_m_gsl(gsl_vector_complex * v, gsl_complex mean) { double var = rb_gsl_vector_complex_variance_m_gsl(v, mean); return sqrt(var); } /* gsl_vector_complex_sd_with_fixed_mean */ static double rb_gsl_vector_complex_sd_fm_gsl(gsl_vector_complex * v, gsl_complex mean) { double var = rb_gsl_vector_complex_variance_fm_gsl(v, mean); return sqrt(var); } /* gsl_vector_complex_tss */ static double rb_gsl_vector_complex_tss_gsl(gsl_vector_complex * v) { gsl_complex mean = rb_gsl_vector_complex_mean_gsl(v); return rb_gsl_vector_complex_tss_m_gsl(v, mean); } /* gsl_vector_complex_variance */ static double rb_gsl_vector_complex_variance_gsl(gsl_vector_complex * v) { double tss = rb_gsl_vector_complex_tss_gsl(v); return tss / (double)(v->size - 1); } /* gsl_vector_complex_sd */ static double rb_gsl_vector_complex_sd_gsl(gsl_vector_complex * v) { double var = rb_gsl_vector_complex_variance_gsl(v); return sqrt(var); } /* Wrapper around stats funcs with prototype like * "gsl_complex func(gsl_vector_complex *v)" * (e.g. sum and mean) */ static VALUE rb_gsl_vector_complex_z_stats_v(VALUE obj, gsl_complex (*func)(gsl_vector_complex*)) { gsl_vector_complex * v; gsl_complex * zp; VALUE zv; CHECK_VECTOR_COMPLEX(obj); Data_Get_Struct(obj, gsl_vector_complex, v); zv = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, zp); *zp = func(v); return zv; } /* Wrapper around stats funcs with prototype like * "double func(gsl_vector_complex *v)" * (e.g. tss, variance, sd) */ static VALUE rb_gsl_vector_complex_d_stats_v(VALUE obj, double (*func)(gsl_vector_complex*)) { gsl_vector_complex * v; double d; CHECK_VECTOR_COMPLEX(obj); Data_Get_Struct(obj, gsl_vector_complex, v); d = func(v); return rb_float_new(d); } /* Wrapper around stats funcs with prototype like * "double func(gsl_vector_complex *v, gsl_complex z)" * (e.g. tss_m, variance_m, sd_m, variance_fm, sd_fm) */ static VALUE rb_gsl_vector_complex_d_stats_v_z(VALUE obj, VALUE arg, double (*func)(gsl_vector_complex*, gsl_complex)) { gsl_vector_complex * v; gsl_complex z; gsl_complex * zp; double d; CHECK_VECTOR_COMPLEX(obj); Data_Get_Struct(obj, gsl_vector_complex, v); switch (TYPE(arg)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: z = gsl_complex_rect(NUM2DBL(arg), 0.0); zp = &z; break; default: CHECK_COMPLEX(arg); Data_Get_Struct(arg, gsl_complex, zp); break; } d = func(v,*zp); return rb_float_new(d); } static VALUE rb_gsl_vector_complex_sum(VALUE obj) { return rb_gsl_vector_complex_z_stats_v(obj, rb_gsl_vector_complex_sum_gsl); } static VALUE rb_gsl_vector_complex_mean(VALUE obj) { return rb_gsl_vector_complex_z_stats_v(obj, rb_gsl_vector_complex_mean_gsl); } static VALUE rb_gsl_vector_complex_tss_m(VALUE obj, VALUE arg) { return rb_gsl_vector_complex_d_stats_v_z(obj, arg, rb_gsl_vector_complex_tss_m_gsl); } static VALUE rb_gsl_vector_complex_variance_m(VALUE obj, VALUE arg) { return rb_gsl_vector_complex_d_stats_v_z(obj, arg, rb_gsl_vector_complex_variance_m_gsl); } static VALUE rb_gsl_vector_complex_variance_fm(VALUE obj, VALUE arg) { return rb_gsl_vector_complex_d_stats_v_z(obj, arg, rb_gsl_vector_complex_variance_fm_gsl); } static VALUE rb_gsl_vector_complex_sd_m(VALUE obj, VALUE arg) { return rb_gsl_vector_complex_d_stats_v_z(obj, arg, rb_gsl_vector_complex_sd_m_gsl); } static VALUE rb_gsl_vector_complex_sd_fm(VALUE obj, VALUE arg) { return rb_gsl_vector_complex_d_stats_v_z(obj, arg, rb_gsl_vector_complex_sd_fm_gsl); } static VALUE rb_gsl_vector_complex_tss(VALUE obj) { return rb_gsl_vector_complex_d_stats_v(obj, rb_gsl_vector_complex_tss_gsl); } static VALUE rb_gsl_vector_complex_variance(VALUE obj) { return rb_gsl_vector_complex_d_stats_v(obj, rb_gsl_vector_complex_variance_gsl); } static VALUE rb_gsl_vector_complex_sd(VALUE obj) { return rb_gsl_vector_complex_d_stats_v(obj, rb_gsl_vector_complex_sd_gsl); } /*****/ static VALUE rb_gsl_vector_complex_sin(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_sin); } static VALUE rb_gsl_vector_complex_cos(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_cos); } static VALUE rb_gsl_vector_complex_tan(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_tan); } static VALUE rb_gsl_vector_complex_sec(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_sec); } static VALUE rb_gsl_vector_complex_csc(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_csc); } static VALUE rb_gsl_vector_complex_cot(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_cot); } static VALUE rb_gsl_vector_complex_arcsin(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arcsin); } static VALUE rb_gsl_vector_complex_arccos(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arccos); } static VALUE rb_gsl_vector_complex_arctan(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arctan); } static VALUE rb_gsl_vector_complex_arcsec(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arcsec); } static VALUE rb_gsl_vector_complex_arccsc(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arccsc); } static VALUE rb_gsl_vector_complex_arccot(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arccot); } static VALUE rb_gsl_vector_complex_sinh(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_sinh); } static VALUE rb_gsl_vector_complex_cosh(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_cosh); } static VALUE rb_gsl_vector_complex_tanh(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_tanh); } static VALUE rb_gsl_vector_complex_sech(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_sech); } static VALUE rb_gsl_vector_complex_csch(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_csch); } static VALUE rb_gsl_vector_complex_coth(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_coth); } static VALUE rb_gsl_vector_complex_arcsinh(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arcsinh); } static VALUE rb_gsl_vector_complex_arccosh(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arccosh); } static VALUE rb_gsl_vector_complex_arctanh(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arctanh); } static VALUE rb_gsl_vector_complex_arcsech(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arcsech); } static VALUE rb_gsl_vector_complex_arccsch(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arccsch); } static VALUE rb_gsl_vector_complex_arccoth(VALUE obj) { return rb_gsl_vector_complex_XXXz(obj, gsl_complex_arccoth); } static VALUE rb_gsl_vector_complex_concat(VALUE obj, VALUE other) { gsl_vector_complex *v = NULL, *v2 = NULL, *vnew = NULL; gsl_vector_complex_view vv; gsl_complex tmp; VALUE x; double beg, end; int step; size_t i, size2; Data_Get_Struct(obj, gsl_vector_complex, v); switch(TYPE(other)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: vnew = gsl_vector_complex_alloc(v->size + 1); vv = gsl_vector_complex_subvector(vnew, 0, v->size); gsl_vector_complex_memcpy(&vv.vector, v); gsl_vector_complex_set(vnew, v->size, rb_gsl_obj_to_gsl_complex(other, NULL)); break; case T_ARRAY: size2 = RARRAY_LEN(other); vnew = gsl_vector_complex_alloc(v->size + size2); vv = gsl_vector_complex_subvector(vnew, 0, v->size); gsl_vector_complex_memcpy(&vv.vector, v); for (i = 0; i < size2; i++) { x = rb_ary_entry(other, i); gsl_vector_complex_set(vnew, v->size + i, rb_gsl_obj_to_gsl_complex(x, NULL)); } break; default: if(rb_obj_is_kind_of(other, cgsl_complex)) { vnew = gsl_vector_complex_alloc(v->size + 1); vv = gsl_vector_complex_subvector(vnew, 0, v->size); gsl_vector_complex_memcpy(&vv.vector, v); gsl_vector_complex_set(vnew, v->size, rb_gsl_obj_to_gsl_complex(other, NULL)); } else if(rb_obj_is_kind_of(other, rb_cRange)) { get_range_beg_en_n(other, &beg, &end, &size2, &step); vnew = gsl_vector_complex_alloc(v->size + size2); vv = gsl_vector_complex_subvector(vnew, 0, v->size); gsl_vector_complex_memcpy(&vv.vector, v); GSL_SET_COMPLEX(&tmp, beg, 0.0); for (i = 0; i < size2; i++) { gsl_vector_complex_set(vnew, v->size + i, tmp); GSL_SET_REAL(&tmp, GSL_REAL(tmp) + step); } } else if (rb_obj_is_kind_of(other, cgsl_vector_complex)) { Data_Get_Struct(other, gsl_vector_complex, v2); size2 = v2->size; vnew = gsl_vector_complex_alloc(v->size + size2); vv = gsl_vector_complex_subvector(vnew, 0, v->size); gsl_vector_complex_memcpy(&vv.vector, v); vv = gsl_vector_complex_subvector(vnew, v->size, size2); gsl_vector_complex_memcpy(&vv.vector, v2); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array, Numeric, Range, GSL::Complex, or %s expected)", rb_class2name(CLASS_OF(other)), rb_class2name(cgsl_vector_complex)); } break; } return Data_Wrap_Struct(VECTOR_COMPLEX_ROW_COL(obj), 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_block(VALUE obj) { gsl_vector_complex *v = NULL; Data_Get_Struct(obj, gsl_vector_complex, v); return Data_Wrap_Struct(cgsl_block_complex, 0, NULL, v->block); } static VALUE rb_gsl_vector_complex_indgen_bang(int argc, VALUE *argv[], VALUE obj) { gsl_vector_complex *v = NULL; double start = 0.0, step = 1.0, x; size_t i; switch (argc) { case 0: break; case 1: start = NUM2DBL(argv[0]); break; case 2: start = NUM2DBL(argv[0]); step = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2)", argc); } Data_Get_Struct(obj, gsl_vector_complex, v); for (i = 0, x = start; i < v->size; i++, x += step) { gsl_vector_complex_set(v, i, gsl_complex_rect(x,0)); } return obj; } static VALUE rb_gsl_vector_complex_indgen(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL, *vnew; double start = 0, step = 1, x; size_t i; switch (argc) { case 0: break; case 1: start = NUM2DBL(argv[0]); break; case 2: start = NUM2DBL(argv[0]); step = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2)", argc); } Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_calloc(v->size); for (i = 0, x = start; i < vnew->size; i++, x += step) { gsl_vector_complex_set(vnew, i, gsl_complex_rect(x,0)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_indgen_singleton(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *vnew; double start = 0, step = 1, x; size_t n, i; switch (argc) { case 1: n = (size_t) FIX2INT(argv[0]); break; case 2: n = (size_t) FIX2INT(argv[0]); start = NUM2DBL(argv[1]); break; case 3: n = (size_t) FIX2INT(argv[0]); start = NUM2DBL(argv[1]); step = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-3)",argc); } vnew = gsl_vector_complex_calloc(n); for (i = 0, x = start; i < vnew->size; i++, x += step) { gsl_vector_complex_set(vnew, i, gsl_complex_rect(x,0)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_phasor_singleton(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *vnew; double start, step, theta; size_t n, i; switch (argc) { case 1: n = (size_t) FIX2INT(argv[0]); start = 0; step = 2 * M_PI / n; break; case 2: n = (size_t) FIX2INT(argv[0]); start = NUM2DBL(argv[1]); step = 2 * M_PI / n; break; case 3: n = (size_t) FIX2INT(argv[0]); start = NUM2DBL(argv[1]); step = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-3)",argc); } vnew = gsl_vector_complex_alloc(n); for (i = 0, theta = start; i < vnew->size; i++, theta += step) { gsl_vector_complex_set(vnew, i, gsl_complex_polar(1.0,theta)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_vector_complex_zip(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v0, **vp, *vnew; VALUE ary; size_t i, j; int argc2; VALUE *argv2; gsl_complex zzero = gsl_complex_rect(0, 0); if (VECTOR_COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_vector_complex, v0); argc2 = argc; argv2 = argv; } else { if (argc < 1) rb_raise(rb_eArgError, "Too few arguments."); Data_Get_Struct(argv[0], gsl_vector_complex, v0); argc2 = argc - 1; argv2 = argv + 1; } for (i = 0; i < argc2; i++) { CHECK_VECTOR_COMPLEX(argv2[i]); } vp = (gsl_vector_complex**) malloc(sizeof(gsl_vector_complex**)); for (i = 0; i < argc2; i++) { Data_Get_Struct(argv2[i], gsl_vector_complex, vp[i]); } ary = rb_ary_new2(v0->size); for (i = 0; i < v0->size; i++) { vnew = gsl_vector_complex_alloc(argc2 + 1); gsl_vector_complex_set(vnew, 0, gsl_vector_complex_get(v0, i)); for (j = 0; j < argc2; j++) { if (i < vp[j]->size) { gsl_vector_complex_set(vnew, j+1, gsl_vector_complex_get(vp[j], i)); } else { gsl_vector_complex_set(vnew, j+1, zzero); } } rb_ary_store(ary, i, Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew)); } free((gsl_vector_complex**) vp); return ary; } // Starting with version 1.15, GSL provides a gsl_vector_complex_equal // function, but it only determines absolute equality (i.e. is has no epsilon // argument). static int gsl_vector_complex_equal_eps(const gsl_vector_complex *v1, const gsl_vector_complex *v2, double eps) { gsl_complex z1, z2; size_t i; if (v1->size != v2->size) return 0; for (i = 0; i < v1->size; i++) { z1 = gsl_vector_complex_get(v1, i); z2 = gsl_vector_complex_get(v2, i); if (!rbgsl_complex_equal(&z1, &z2, eps)) return 0; } return 1; } static VALUE rb_gsl_vector_complex_equal(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v1, *v2; double eps = 1e-8; int ret; switch (argc) { case 1: eps = 1e-8; break; case 2: eps = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)\n", argc); } Data_Get_Struct(obj, gsl_vector_complex, v1); CHECK_VECTOR_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_vector_complex, v2); ret = gsl_vector_complex_equal_eps(v1, v2, eps); if (ret == 1) return Qtrue; else return Qfalse; } static VALUE rb_gsl_vector_complex_not_equal(int argc, VALUE *argv, VALUE obj) { VALUE ret; ret = rb_gsl_vector_complex_equal(argc, argv, obj); if (ret == Qtrue) return Qfalse; else return Qtrue; } void Init_gsl_vector_complex(VALUE module) { rb_define_singleton_method(cgsl_vector_complex, "new", rb_gsl_vector_complex_new, -1); rb_define_singleton_method(cgsl_vector_complex, "[]", rb_gsl_vector_complex_new, -1); rb_define_singleton_method(cgsl_vector_complex, "alloc", rb_gsl_vector_complex_new, -1); rb_define_singleton_method(cgsl_vector_complex, "calloc", rb_gsl_vector_complex_calloc, 1); rb_define_singleton_method(cgsl_vector_complex_col, "new", rb_gsl_vector_complex_row_new, -1); rb_define_method(cgsl_vector_complex, "size", rb_gsl_vector_complex_size, 0); rb_define_alias(cgsl_vector_complex, "len", "size"); rb_define_alias(cgsl_vector_complex, "length", "size"); rb_define_method(cgsl_vector_complex, "stride", rb_gsl_vector_complex_stride, 0); rb_define_method(cgsl_vector_complex, "owner", rb_gsl_vector_complex_owner, 0); rb_define_method(cgsl_vector_complex, "get", rb_gsl_vector_complex_get, -1); rb_define_alias(cgsl_vector_complex, "[]", "get"); rb_define_method(cgsl_vector_complex, "ptr", rb_gsl_vector_complex_ptr, 1); rb_define_method(cgsl_vector_complex, "set", rb_gsl_vector_complex_set, -1); rb_define_alias(cgsl_vector_complex, "[]=", "set"); rb_define_method(cgsl_vector_complex, "set_all", rb_gsl_vector_complex_set_all, -1); rb_define_method(cgsl_vector_complex, "each", rb_gsl_vector_complex_each, 0); rb_define_method(cgsl_vector_complex, "reverse_each", rb_gsl_vector_complex_reverse_each, 0); rb_define_method(cgsl_vector_complex, "each_index", rb_gsl_vector_complex_each_index, 0); rb_define_method(cgsl_vector_complex, "reverse_each_index", rb_gsl_vector_complex_reverse_each_index, 0); rb_define_method(cgsl_vector_complex, "collect", rb_gsl_vector_complex_collect, 0); rb_define_method(cgsl_vector_complex, "collect!", rb_gsl_vector_complex_collect_bang, 0); rb_define_alias(cgsl_vector_complex, "map", "collect"); rb_define_alias(cgsl_vector_complex, "map!", "collect!"); rb_define_method(cgsl_vector_complex, "set_zero", rb_gsl_vector_complex_set_zero, 0); rb_define_method(cgsl_vector_complex, "set_basis", rb_gsl_vector_complex_set_basis, 1); rb_define_method(cgsl_vector_complex, "to_s", rb_gsl_vector_complex_to_s, 0); rb_define_method(cgsl_vector_complex, "fprintf", rb_gsl_vector_complex_fprintf, -1); rb_define_method(cgsl_vector_complex, "printf", rb_gsl_vector_complex_printf, -1); rb_define_method(cgsl_vector_complex, "print", rb_gsl_vector_complex_print, 0); rb_define_method(cgsl_vector_complex, "inspect", rb_gsl_vector_complex_inspect, 0); rb_define_method(cgsl_vector_complex, "fwrite", rb_gsl_vector_complex_fwrite, 1); rb_define_method(cgsl_vector_complex, "fread", rb_gsl_vector_complex_fread, 1); rb_define_method(cgsl_vector_complex, "fscanf", rb_gsl_vector_complex_fscanf, 1); rb_define_method(cgsl_vector_complex, "real", rb_gsl_vector_complex_real, 0); rb_define_alias(cgsl_vector_complex, "re", "real"); rb_define_method(cgsl_vector_complex, "imag", rb_gsl_vector_complex_imag, 0); rb_define_alias(cgsl_vector_complex, "im", "imag"); rb_define_method(cgsl_vector_complex, "set_real", rb_gsl_vector_complex_set_real, 1); rb_define_alias(cgsl_vector_complex, "real=", "set_real"); rb_define_alias(cgsl_vector_complex, "re=", "set_real"); rb_define_method(cgsl_vector_complex, "set_imag", rb_gsl_vector_complex_set_imag, 1); rb_define_alias(cgsl_vector_complex, "imag=", "set_imag"); rb_define_alias(cgsl_vector_complex, "im=", "set_imag"); rb_define_method(cgsl_vector_complex, "conj", rb_gsl_vector_complex_conj, 0); rb_define_alias(cgsl_vector_complex, "conjugate", "conj"); rb_define_method(cgsl_vector_complex, "conj!", rb_gsl_vector_complex_conj_bang, 0); rb_define_alias(cgsl_vector_complex, "conjugate!", "conj!"); rb_define_method(cgsl_vector_complex, "to_a", rb_gsl_vector_complex_to_a, 0); rb_define_method(cgsl_vector_complex, "to_a2", rb_gsl_vector_complex_to_a2, 0); rb_define_method(cgsl_vector_complex, "subvector", rb_gsl_vector_complex_subvector, -1); rb_define_alias(cgsl_vector_complex, "view", "subvector"); rb_define_method(cgsl_vector_complex, "subvector_with_stride", rb_gsl_vector_complex_subvector_with_stride, 3); rb_define_singleton_method(cgsl_vector_complex, "memcpy", rb_gsl_vector_complex_memcpy, 2); rb_define_method(cgsl_vector_complex, "clone", rb_gsl_vector_complex_clone, 0); rb_define_alias(cgsl_vector_complex, "duplicate", "clone"); rb_define_alias(cgsl_vector_complex, "dup", "clone"); rb_define_method(cgsl_vector_complex, "reverse!", rb_gsl_vector_complex_reverse, 0); rb_define_method(cgsl_vector_complex, "reverse", rb_gsl_vector_complex_reverse2, 0); rb_define_method(cgsl_vector_complex, "swap_elements", rb_gsl_vector_complex_swap_elements, 2); rb_define_method(cgsl_vector_complex, "fftshift!", rb_gsl_vector_complex_fftshift_bang, 0); rb_define_method(cgsl_vector_complex, "fftshift", rb_gsl_vector_complex_fftshift, 0); rb_define_method(cgsl_vector_complex, "ifftshift!", rb_gsl_vector_complex_ifftshift_bang, 0); rb_define_method(cgsl_vector_complex, "ifftshift", rb_gsl_vector_complex_ifftshift, 0); rb_define_method(cgsl_vector_complex, "isnull", rb_gsl_vector_complex_isnull, 0); rb_define_method(cgsl_vector_complex, "matrix_view", rb_gsl_vector_complex_matrix_view, -1); rb_define_method(cgsl_vector_complex, "matrix_view_with_tda", rb_gsl_vector_complex_matrix_view_with_tda, -1); rb_define_method(cgsl_vector_complex, "trans", rb_gsl_vector_complex_trans, 0); rb_define_alias(cgsl_vector_complex, "transpose", "trans"); rb_define_method(cgsl_vector_complex, "trans!", rb_gsl_vector_complex_trans2, 0); rb_define_alias(cgsl_vector_complex, "transpose!", "trans!"); /*****/ rb_define_alias(cgsl_vector_complex, "col", "trans"); rb_define_alias(cgsl_vector_complex, "col!", "trans!"); rb_define_alias(cgsl_vector_complex_col, "row", "trans"); rb_define_alias(cgsl_vector_complex_col, "row!", "trans!"); /*****/ rb_define_method(cgsl_vector_complex, "to_real", rb_gsl_vector_complex_to_real, 0); rb_define_method(cgsl_vector_complex, "add", rb_gsl_vector_complex_add, 1); rb_define_method(cgsl_vector_complex, "sub", rb_gsl_vector_complex_sub, 1); rb_define_method(cgsl_vector_complex, "mul", rb_gsl_vector_complex_mul, 1); rb_define_method(cgsl_vector_complex, "div", rb_gsl_vector_complex_div, 1); rb_define_method(cgsl_vector_complex, "add!", rb_gsl_vector_complex_add_bang, 1); rb_define_method(cgsl_vector_complex, "sub!", rb_gsl_vector_complex_sub_bang, 1); rb_define_method(cgsl_vector_complex, "mul!", rb_gsl_vector_complex_mul_bang, 1); rb_define_method(cgsl_vector_complex, "div!", rb_gsl_vector_complex_div_bang, 1); rb_define_alias(cgsl_vector_complex, "+", "add"); rb_define_alias(cgsl_vector_complex, "add_constant", "add"); rb_define_alias(cgsl_vector_complex, "add_constant!", "add!"); rb_define_alias(cgsl_vector_complex, "-", "sub"); rb_define_alias(cgsl_vector_complex, "*", "mul"); rb_define_alias(cgsl_vector_complex, "scale", "mul"); rb_define_alias(cgsl_vector_complex, "scale!", "mul!"); rb_define_alias(cgsl_vector_complex, "/", "div"); rb_define_method(cgsl_vector_complex, "coerce", rb_gsl_vector_complex_coerce, 1); /* 2.Aug.2004 */ rb_define_singleton_method(cgsl_vector_complex, "inner_product", rb_gsl_vector_complex_inner_product, -1); rb_define_singleton_method(cgsl_vector_complex, "dot", rb_gsl_vector_complex_inner_product, -1); rb_define_method(cgsl_vector_complex, "inner_product", rb_gsl_vector_complex_inner_product, -1); /* rb_define_alias(cgsl_vector_complex, "dot", "inner_product");*/ /*****/ rb_define_method(cgsl_vector_complex, "-@", rb_gsl_vector_complex_uminus, 0); rb_define_method(cgsl_vector_complex, "+@", rb_gsl_vector_complex_uplus, 0); rb_define_method(cgsl_vector_complex, "abs2", rb_gsl_vector_complex_abs2, 0); rb_define_alias(cgsl_vector_complex, "square", "abs2"); rb_define_method(cgsl_vector_complex, "abs", rb_gsl_vector_complex_abs, 0); rb_define_alias(cgsl_vector_complex, "amp", "abs"); rb_define_alias(cgsl_vector_complex, "mag", "abs"); rb_define_method(cgsl_vector_complex, "arg", rb_gsl_vector_complex_arg, 0); rb_define_alias(cgsl_vector_complex, "angle", "arg"); rb_define_alias(cgsl_vector_complex, "phase", "arg"); rb_define_method(cgsl_vector_complex, "logabs", rb_gsl_vector_complex_logabs, 0); rb_define_method(cgsl_vector_complex, "sqrt", rb_gsl_vector_complex_sqrt, 0); rb_define_method(cgsl_vector_complex, "sqrt!", rb_gsl_vector_complex_sqrt_bang, 0); rb_define_method(cgsl_vector_complex, "exp", rb_gsl_vector_complex_exp, 0); rb_define_method(cgsl_vector_complex, "exp!", rb_gsl_vector_complex_exp_bang, 0); rb_define_method(cgsl_vector_complex, "pow", rb_gsl_vector_complex_pow, 1); rb_define_method(cgsl_vector_complex, "pow!", rb_gsl_vector_complex_pow_bang, 1); rb_define_method(cgsl_vector_complex, "log", rb_gsl_vector_complex_log, 0); rb_define_method(cgsl_vector_complex, "log!", rb_gsl_vector_complex_log_bang, 0); rb_define_method(cgsl_vector_complex, "log10", rb_gsl_vector_complex_log10, 0); rb_define_method(cgsl_vector_complex, "log10!", rb_gsl_vector_complex_log10_bang, 0); rb_define_method(cgsl_vector_complex, "log_b", rb_gsl_vector_complex_log_b, 1); rb_define_method(cgsl_vector_complex, "log_b!", rb_gsl_vector_complex_log_b_bang, 1); rb_define_method(cgsl_vector_complex, "sum", rb_gsl_vector_complex_sum, 0); rb_define_method(cgsl_vector_complex, "mean", rb_gsl_vector_complex_mean, 0); rb_define_method(cgsl_vector_complex, "tss", rb_gsl_vector_complex_tss, 0); rb_define_method(cgsl_vector_complex, "tss_m", rb_gsl_vector_complex_tss_m, 1); rb_define_method(cgsl_vector_complex, "variance", rb_gsl_vector_complex_variance, 0); rb_define_method(cgsl_vector_complex, "variance_m", rb_gsl_vector_complex_variance_m, 1); rb_define_method(cgsl_vector_complex, "variance_fm", rb_gsl_vector_complex_variance_fm, 1); rb_define_method(cgsl_vector_complex, "sd", rb_gsl_vector_complex_sd, 0); rb_define_method(cgsl_vector_complex, "sd_m", rb_gsl_vector_complex_sd_m, 1); rb_define_method(cgsl_vector_complex, "sd_fm", rb_gsl_vector_complex_sd_fm, 1); rb_define_method(cgsl_vector_complex, "sin", rb_gsl_vector_complex_sin, 0); rb_define_method(cgsl_vector_complex, "cos", rb_gsl_vector_complex_cos, 0); rb_define_method(cgsl_vector_complex, "tan", rb_gsl_vector_complex_tan, 0); rb_define_method(cgsl_vector_complex, "sec", rb_gsl_vector_complex_sec, 0); rb_define_method(cgsl_vector_complex, "csc", rb_gsl_vector_complex_csc, 0); rb_define_method(cgsl_vector_complex, "cot", rb_gsl_vector_complex_cot, 0); rb_define_method(cgsl_vector_complex, "arcsin", rb_gsl_vector_complex_arcsin, 0); rb_define_method(cgsl_vector_complex, "arccos", rb_gsl_vector_complex_arccos, 0); rb_define_method(cgsl_vector_complex, "arctan", rb_gsl_vector_complex_arctan, 0); rb_define_method(cgsl_vector_complex, "arcsec", rb_gsl_vector_complex_arcsec, 0); rb_define_method(cgsl_vector_complex, "arccsc", rb_gsl_vector_complex_arccsc, 0); rb_define_method(cgsl_vector_complex, "arccot", rb_gsl_vector_complex_arccot, 0); rb_define_method(cgsl_vector_complex, "sinh", rb_gsl_vector_complex_sinh, 0); rb_define_method(cgsl_vector_complex, "cosh", rb_gsl_vector_complex_cosh, 0); rb_define_method(cgsl_vector_complex, "tanh", rb_gsl_vector_complex_tanh, 0); rb_define_method(cgsl_vector_complex, "sech", rb_gsl_vector_complex_sech, 0); rb_define_method(cgsl_vector_complex, "csch", rb_gsl_vector_complex_csch, 0); rb_define_method(cgsl_vector_complex, "coth", rb_gsl_vector_complex_coth, 0); rb_define_method(cgsl_vector_complex, "arcsinh", rb_gsl_vector_complex_arcsinh, 0); rb_define_method(cgsl_vector_complex, "arccosh", rb_gsl_vector_complex_arccosh, 0); rb_define_method(cgsl_vector_complex, "arctanh", rb_gsl_vector_complex_arctanh, 0); rb_define_method(cgsl_vector_complex, "arcsech", rb_gsl_vector_complex_arcsech, 0); rb_define_method(cgsl_vector_complex, "arccsch", rb_gsl_vector_complex_arccsch, 0); rb_define_method(cgsl_vector_complex, "arccoth", rb_gsl_vector_complex_arccoth, 0); /*****/ rb_define_method(cgsl_vector_complex, "concat", rb_gsl_vector_complex_concat, 1); rb_define_method(cgsl_vector_complex, "block", rb_gsl_vector_complex_block, 0); rb_define_method(cgsl_vector_complex, "indgen", rb_gsl_vector_complex_indgen, -1); rb_define_method(cgsl_vector_complex, "indgen!", rb_gsl_vector_complex_indgen_bang, -1); rb_define_singleton_method(cgsl_vector_complex, "indgen", rb_gsl_vector_complex_indgen_singleton, -1); rb_define_singleton_method(cgsl_vector_complex, "phasor", rb_gsl_vector_complex_phasor_singleton, -1); rb_define_method(cgsl_vector_complex, "zip", rb_gsl_vector_complex_zip, -1); rb_define_singleton_method(cgsl_vector_complex, "zip", rb_gsl_vector_complex_zip, -1); rb_define_method(cgsl_vector_complex, "equal?", rb_gsl_vector_complex_equal, -1); rb_define_alias(cgsl_vector_complex, "==", "equal?"); rb_define_method(cgsl_vector_complex, "not_equal?", rb_gsl_vector_complex_not_equal, -1); rb_define_alias(cgsl_vector_complex, "!=", "not_equal?"); } gsl-1.15.3/ext/integration.c0000644000175000017500000011274612220252463015244 0ustar boutilboutil/* integration.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #include "rb_gsl_integration.h" #include "rb_gsl_common.h" #ifndef CHECK_WORKSPACE #define CHECK_WORKSPACE(x) if(CLASS_OF(x)!=cgsl_integration_workspace)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (Integration::Workspace expected)",\ rb_class2name(CLASS_OF(x))); #endif #define EPSABS_DEFAULT 0.0 #define EPSREL_DEFAULT 1e-10 #define LIMIT_DEFAULT 1000 #define KEY_DEFAULT GSL_INTEG_GAUSS61 static VALUE cgsl_integration_qaws_table, cgsl_integration_qawo_table; static VALUE cgsl_integration_workspace; #ifdef GSL_1_14_LATER static VALUE cgsl_integration_glfixed_table; #endif static int get_a_b(int argc, VALUE *argv, int argstart, double *a, double *b); static int get_epsabs_epsrel(int argc, VALUE *argv, int argstart, double *epsabs, double *epsrel); static int get_a_b_epsabs_epsrel(int argc, VALUE *argv, int argstart, double *a, double *b, double *epsabs, double *epsrel); static int get_limit_key_workspace(int argc, VALUE *argv, int argstart, size_t *limit, int *key, gsl_integration_workspace **w); static int get_limit_workspace(int argc, VALUE *argv, int argstart, size_t *limit, gsl_integration_workspace **w); static int get_epsabs_epsrel_limit_workspace(int argc, VALUE *argv, int argstart, double *epsabs, double *epsrel, size_t *limit, gsl_integration_workspace **w); static int get_a_b(int argc, VALUE *argv, int argstart, double *a, double *b) { int itmp; VALUE aa, bb; if (argstart >= argc) return argstart; if (TYPE(argv[argstart]) == T_ARRAY) { aa = rb_ary_entry(argv[argstart], 0); bb = rb_ary_entry(argv[argstart], 1); Need_Float(aa); Need_Float(bb); // *a = RFLOAT(aa)->value; // *b = RFLOAT(bb)->value; *a = NUM2DBL(aa); *b = NUM2DBL(bb); itmp = argstart + 1; } else { Need_Float(argv[argstart]); Need_Float(argv[argstart+1]); *a = NUM2DBL(argv[argstart]); *b = NUM2DBL(argv[argstart+1]); itmp = argstart + 2; } return itmp; } static int get_epsabs_epsrel(int argc, VALUE *argv, int argstart, double *epsabs, double *epsrel) { int itmp; VALUE aa, bb; *epsabs = EPSABS_DEFAULT; *epsrel = EPSREL_DEFAULT; if (argstart >= argc) return argstart; if (TYPE(argv[argstart]) == T_ARRAY) { aa = rb_ary_entry(argv[argstart], 0); bb = rb_ary_entry(argv[argstart], 1); Need_Float(aa); Need_Float(bb); *epsabs = NUM2DBL(aa); *epsrel = NUM2DBL(bb); itmp = 1; } else { Need_Float(argv[argstart]); Need_Float(argv[argstart+1]); *epsabs = NUM2DBL(argv[argstart]); *epsrel = NUM2DBL(argv[argstart+1]); itmp = 2; } return argstart + itmp; } static int get_a_b_epsabs_epsrel(int argc, VALUE *argv, int argstart, double *a, double *b, double *epsabs, double *epsrel) { int itmp; *epsabs = EPSABS_DEFAULT; *epsrel = EPSREL_DEFAULT; itmp = get_a_b(argc, argv, argstart, a, b); itmp = get_epsabs_epsrel(argc, argv, itmp, epsabs, epsrel); return itmp; } static int get_limit_key_workspace(int argc, VALUE *argv, int argstart, size_t *limit, int *key, gsl_integration_workspace **w) { int flag = 0; switch (argc-argstart) { case 3: CHECK_FIXNUM(argv[argstart]); CHECK_FIXNUM(argv[argstart+1]); CHECK_WORKSPACE(argv[argstart+2]); *limit = FIX2INT(argv[argstart]); *key = FIX2INT(argv[argstart+1]); Data_Get_Struct(argv[argstart+2], gsl_integration_workspace, *w); flag = 0; break; case 1: CHECK_FIXNUM(argv[argstart]); *key = FIX2INT(argv[argstart]); *limit = LIMIT_DEFAULT; *w = gsl_integration_workspace_alloc(*limit); flag = 1; break; case 2: if (TYPE(argv[argc-1]) == T_FIXNUM) { CHECK_FIXNUM(argv[argc-2]); *limit = FIX2INT(argv[argc-2]); *key = FIX2INT(argv[argc-1]); *w = gsl_integration_workspace_alloc(*limit); flag = 1; } else { CHECK_FIXNUM(argv[argc-2]); CHECK_WORKSPACE(argv[argc-1]); *key = FIX2INT(argv[argc-2]); Data_Get_Struct(argv[argc-1], gsl_integration_workspace, *w); *limit = (*w)->limit; flag = 0; } break; case 0: *key = KEY_DEFAULT; *limit = LIMIT_DEFAULT; *w = gsl_integration_workspace_alloc(*limit); flag = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } if (*w == NULL) rb_raise(rb_eRuntimeError, "something wrong with workspace"); return flag; } static int get_limit_workspace(int argc, VALUE *argv, int argstart, size_t *limit, gsl_integration_workspace **w) { int flag = 0; switch (argc-argstart) { case 2: CHECK_FIXNUM(argv[argstart]); *limit = FIX2INT(argv[argstart]); CHECK_WORKSPACE(argv[argstart+1]); Data_Get_Struct(argv[argstart+1], gsl_integration_workspace, *w); flag = 0; break; case 0: *limit = LIMIT_DEFAULT; *w = gsl_integration_workspace_alloc(*limit); flag = 1; break; case 1: switch (TYPE(argv[argstart])) { case T_FIXNUM: case T_BIGNUM: CHECK_FIXNUM(argv[argstart]); *limit = FIX2INT(argv[argstart]); *w = gsl_integration_workspace_alloc(*limit); flag = 1; break; default: CHECK_WORKSPACE(argv[argc-1]); Data_Get_Struct(argv[argc-1], gsl_integration_workspace, *w); *limit = (*w)->limit; flag = 0; break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } if (*w == NULL) rb_raise(rb_eRuntimeError, "something wrong with workspace"); return flag; } static int get_epsabs_epsrel_limit_workspace(int argc, VALUE *argv, int argstart, double *epsabs, double *epsrel, size_t *limit, gsl_integration_workspace **w) { int flag = 0, itmp; itmp = argstart; *epsabs = EPSABS_DEFAULT; *epsrel = EPSREL_DEFAULT; *limit = LIMIT_DEFAULT; switch (argc-itmp) { case 0: *w = gsl_integration_workspace_alloc(*limit); flag = 1; break; case 1: if (TYPE(argv[itmp]) == T_ARRAY) { get_epsabs_epsrel(argc, argv, itmp, epsabs, epsrel); *w = gsl_integration_workspace_alloc(*limit); flag = 1; } else { flag = get_limit_workspace(argc, argv, itmp, limit, w); } break; case 2: case 3: switch (TYPE(argv[itmp])) { case T_ARRAY: itmp = get_epsabs_epsrel(argc, argv, itmp, epsabs, epsrel); flag = get_limit_workspace(argc, argv, itmp, limit, w); break; case T_FLOAT: get_epsabs_epsrel(argc, argv, itmp, epsabs, epsrel); *w = gsl_integration_workspace_alloc(*limit); flag = 1; break; default: flag = get_limit_workspace(argc, argv, itmp, limit, w); break; } break; case 4: itmp = get_epsabs_epsrel(argc, argv, itmp, epsabs, epsrel); flag = get_limit_workspace(argc, argv, itmp, limit, w); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } if (*w == NULL) rb_raise(rb_eRuntimeError, "something wrong with workspace"); return flag; } static VALUE rb_gsl_integration_qng(int argc, VALUE *argv, VALUE obj) { double a, b, epsabs = EPSABS_DEFAULT, epsrel = EPSREL_DEFAULT; double result, abserr; size_t neval; gsl_function *F = NULL; int status; // local variable 'itmp' declared and set, but never used //int itmp; if (argc < 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 1)", argc); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); /*itmp =*/ get_a_b_epsabs_epsrel(argc, argv, 1, &a, &b, &epsabs, &epsrel); break; default: /*itmp =*/ get_a_b_epsabs_epsrel(argc, argv, 0, &a, &b, &epsabs, &epsrel); Data_Get_Struct(obj, gsl_function, F); break; } status = gsl_integration_qng(F, a, b, epsabs, epsrel, &result, &abserr, &neval); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(neval), INT2FIX(status)); } static VALUE rb_gsl_integration_qag(int argc, VALUE *argv, VALUE obj) { double a, b, epsabs = EPSABS_DEFAULT, epsrel = EPSREL_DEFAULT; double result, abserr; size_t limit = LIMIT_DEFAULT; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; int key = KEY_DEFAULT, status, intervals, itmp, flag = 0; if (argc < 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 1)", argc); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); if (argc == 3) { CHECK_FIXNUM(argv[2]); get_a_b(argc, argv, 1, &a, &b); key = FIX2INT(argv[2]); w = gsl_integration_workspace_alloc(limit); flag = 1; } else if (argc == 4) { CHECK_FIXNUM(argv[3]); get_a_b(argc, argv, 1, &a, &b); key = FIX2INT(argv[3]); w = gsl_integration_workspace_alloc(limit); flag = 1; } else { itmp = get_a_b_epsabs_epsrel(argc, argv, 1, &a, &b, &epsabs, &epsrel); flag = get_limit_key_workspace(argc, argv, itmp, &limit, &key, &w); } break; default: if (argc == 2) { if (FIXNUM_P(argv[1])) { key = FIX2INT(argv[1]); w = gsl_integration_workspace_alloc(limit); flag = 1; } else if (rb_obj_is_kind_of(argv[1], cgsl_integration_workspace)) { Data_Get_Struct(argv[1], gsl_integration_workspace, w); flag = 0; } else { rb_raise(rb_eTypeError, "Key or Workspace expected"); } itmp = get_a_b(argc, argv, 0, &a, &b); } else if (argc == 3) { if (FIXNUM_P(argv[2])) { key = FIX2INT(argv[2]); w = gsl_integration_workspace_alloc(limit); flag = 1; } else if (rb_obj_is_kind_of(argv[2], cgsl_integration_workspace)) { Data_Get_Struct(argv[2], gsl_integration_workspace, w); flag = 0; } else { rb_raise(rb_eTypeError, "Key or Workspace expected"); } itmp = get_a_b(argc, argv, 0, &a, &b); } else { itmp = get_a_b_epsabs_epsrel(argc, argv, 0, &a, &b, &epsabs, &epsrel); flag = get_limit_key_workspace(argc, argv, itmp, &limit, &key, &w); } Data_Get_Struct(obj, gsl_function, F); break; } status = gsl_integration_qag(F, a, b, epsabs, epsrel, limit, key, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } static VALUE rb_gsl_integration_qags(int argc, VALUE *argv, VALUE obj) { double a, b, epsabs = EPSABS_DEFAULT, epsrel = EPSREL_DEFAULT; double result, abserr; size_t limit = LIMIT_DEFAULT; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; int status, intervals, flag = 0, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = get_a_b(argc, argv, 1, &a, &b); break; default: Data_Get_Struct(obj, gsl_function, F); itmp = get_a_b(argc, argv, 0, &a, &b); break; } flag = get_epsabs_epsrel_limit_workspace(argc, argv, itmp, &epsabs, &epsrel, &limit, &w); status = gsl_integration_qags(F, a, b, epsabs, epsrel, limit, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } static VALUE rb_gsl_integration_qagp(int argc, VALUE *argv, VALUE obj) { double epsabs, epsrel; double result, abserr; size_t limit; gsl_function *F = NULL; gsl_vector *v = NULL; gsl_integration_workspace *w = NULL; int status, intervals, flag = 0, flag2 = 0, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } if (TYPE(argv[itmp]) == T_ARRAY) { v = make_cvector_from_rarray(argv[itmp]); flag2 = 1; } else { Data_Get_Vector(argv[itmp], v); flag2 = 0; } itmp += 1; flag = get_epsabs_epsrel_limit_workspace(argc, argv, itmp, &epsabs, &epsrel, &limit, &w); status = gsl_integration_qagp(F, v->data, v->size, epsabs, epsrel, limit, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); if (flag2 == 1) gsl_vector_free(v); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } /* (-infty --- +infty) */ static VALUE rb_gsl_integration_qagi(int argc, VALUE *argv, VALUE obj) { double epsabs, epsrel; double result, abserr; size_t limit; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; int status, intervals, flag = 0, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } flag = get_epsabs_epsrel_limit_workspace(argc, argv, itmp, &epsabs, &epsrel, &limit, &w); status = gsl_integration_qagi(F, epsabs, epsrel, limit, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } /* (a --- +infty) */ static VALUE rb_gsl_integration_qagiu(int argc, VALUE *argv, VALUE obj) { double a, epsabs, epsrel; double result, abserr; size_t limit; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; int status, intervals, flag = 0, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } Need_Float(argv[itmp]); a = NUM2DBL(argv[itmp]); itmp += 1; flag = get_epsabs_epsrel_limit_workspace(argc, argv, itmp, &epsabs, &epsrel, &limit, &w); status = gsl_integration_qagiu(F, a, epsabs, epsrel, limit, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } /* (-infty --- b) */ static VALUE rb_gsl_integration_qagil(int argc, VALUE *argv, VALUE obj) { double b, epsabs, epsrel; double result, abserr; size_t limit; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; int status, intervals, flag = 0, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } Need_Float(argv[itmp]); b = NUM2DBL(argv[itmp]); flag = get_epsabs_epsrel_limit_workspace(argc, argv, itmp+1, &epsabs, &epsrel, &limit, &w); Data_Get_Struct(obj, gsl_function, F); status = gsl_integration_qagil(F, b, epsabs, epsrel, limit, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } static VALUE rb_gsl_integration_qawc(int argc, VALUE *argv, VALUE obj) { double a, b, c, epsabs, epsrel; double result, abserr; size_t limit; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; int status, intervals, itmp, flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } itmp = get_a_b(argc, argv, itmp, &a, &b); if (argc-itmp <= 0) rb_raise(rb_eArgError, "The pole is not given"); Need_Float(argv[itmp]); c = NUM2DBL(argv[itmp]); flag = get_epsabs_epsrel_limit_workspace(argc, argv, itmp+1, &epsabs, &epsrel, &limit, &w); status = gsl_integration_qawc(F, a, b, c, epsabs, epsrel, limit, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } VALUE rb_gsl_integration_qaws_table_alloc(int argc, VALUE *argv, VALUE klass) { gsl_integration_qaws_table *t = NULL; VALUE alpha, beta, mu, nu; if (TYPE(argv[0]) == T_ARRAY) { alpha = rb_ary_entry(argv[0], 0); beta = rb_ary_entry(argv[0], 1); mu = rb_ary_entry(argv[0], 2); nu = rb_ary_entry(argv[0], 3); } else { Need_Float(argv[0]); Need_Float(argv[1]); CHECK_FIXNUM(argv[2]); CHECK_FIXNUM(argv[3]); alpha = argv[0]; beta = argv[1]; mu = argv[2]; nu = argv[3]; } t = gsl_integration_qaws_table_alloc(NUM2DBL(alpha), NUM2DBL(beta), FIX2INT(mu), FIX2INT(nu)); return Data_Wrap_Struct(klass, 0, gsl_integration_qaws_table_free, t); } static VALUE rb_gsl_integration_qaws_table_set(int argc, VALUE *argv, VALUE obj) { gsl_integration_qaws_table *t = NULL; double alpha, beta; int mu, nu, type; if (argc != 1 && argc != 4) rb_raise(rb_eArgError, "wrong number of argument (%d for 1 or 3)", argc); type = TYPE(argv[0]); Data_Get_Struct(obj, gsl_integration_qaws_table, t); if (type == T_FIXNUM || type == T_BIGNUM || type == T_FLOAT) { alpha = NUM2DBL(argv[0]); beta = NUM2DBL(argv[1]); mu = FIX2INT(argv[2]); nu = FIX2INT(argv[3]); } else if (type == T_ARRAY) { alpha = NUM2DBL(rb_ary_entry(argv[0], 0)); beta = NUM2DBL(rb_ary_entry(argv[0], 1)); mu = FIX2INT(rb_ary_entry(argv[0], 2)); nu = FIX2INT(rb_ary_entry(argv[0], 3)); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); } gsl_integration_qaws_table_set(t, alpha, beta, mu, nu); return obj; } static VALUE rb_gsl_integration_qaws_table_to_a(VALUE obj) { gsl_integration_qaws_table *t = NULL; VALUE ary; Data_Get_Struct(obj, gsl_integration_qaws_table, t); ary = rb_ary_new2(4); rb_ary_store(ary, 0, rb_float_new(t->alpha)); rb_ary_store(ary, 1, rb_float_new(t->beta)); rb_ary_store(ary, 2, INT2FIX(t->mu)); rb_ary_store(ary, 3, INT2FIX(t->nu)); return ary; } static gsl_integration_qaws_table* make_qaws_table(VALUE ary); static VALUE rb_gsl_ary_to_integration_qaws_table(VALUE ary) { gsl_integration_qaws_table *t = NULL; t = make_qaws_table(ary); return Data_Wrap_Struct(cgsl_integration_qaws_table, 0, gsl_integration_qaws_table_free, t); } static gsl_integration_qaws_table* make_qaws_table(VALUE ary) { double alpha, beta; int mu, nu; alpha = NUM2DBL(rb_ary_entry(ary, 0)); beta = NUM2DBL(rb_ary_entry(ary, 1)); mu = FIX2INT(rb_ary_entry(ary, 2)); nu = FIX2INT(rb_ary_entry(ary, 3)); return gsl_integration_qaws_table_alloc(alpha, beta, mu, nu); } static VALUE rb_gsl_integration_qaws(int argc, VALUE *argv, VALUE obj) { double a, b, epsabs, epsrel; double result, abserr; size_t limit; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; gsl_integration_qaws_table *t = NULL; int status, intervals, itmp, flag = 0, flagt = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } itmp = get_a_b(argc, argv, itmp, &a, &b); if (TYPE(argv[itmp]) == T_ARRAY) { flagt = 1; t = make_qaws_table(argv[itmp]); } else { flagt = 0; if (!rb_obj_is_kind_of(argv[itmp], cgsl_integration_qaws_table)) rb_raise(rb_eTypeError, "Integration::QAWS_Table expected"); Data_Get_Struct(argv[itmp], gsl_integration_qaws_table, t); } flag = get_epsabs_epsrel_limit_workspace(argc, argv, itmp+1, &epsabs, &epsrel, &limit, &w); status = gsl_integration_qaws(F, a, b, t, epsabs, epsrel, limit, w, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); if (flagt == 1) gsl_integration_qaws_table_free(t); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } static gsl_integration_qawo_table* make_qawo_table(VALUE ary); static VALUE rb_gsl_integration_qawo_table_alloc(int argc, VALUE *argv, VALUE klass) { gsl_integration_qawo_table *t = NULL; double omega, L; enum gsl_integration_qawo_enum sine; size_t n; if (argc != 1 && argc != 4) rb_raise(rb_eArgError, "wrong nubmer of arguments (%d for 1 or 4)", argc); if (TYPE(argv[0]) == T_ARRAY) { omega = NUM2DBL(rb_ary_entry(argv[0], 0)); L = NUM2DBL(rb_ary_entry(argv[0], 1)); sine = FIX2INT(rb_ary_entry(argv[0], 2)); n = FIX2INT(rb_ary_entry(argv[0], 3)); } else { omega = NUM2DBL(argv[0]); L = NUM2DBL(argv[1]); sine = FIX2INT(argv[2]); n = FIX2INT(argv[3]); } t = gsl_integration_qawo_table_alloc(omega, L, sine, n); return Data_Wrap_Struct(klass, 0, gsl_integration_qawo_table_free, t); } static VALUE rb_gsl_integration_qawo_table_to_a(VALUE obj) { gsl_integration_qawo_table *t = NULL; VALUE ary; Data_Get_Struct(obj, gsl_integration_qawo_table, t); ary = rb_ary_new2(4); rb_ary_store(ary, 0, rb_float_new(t->omega)); rb_ary_store(ary, 1, rb_float_new(t->L)); rb_ary_store(ary, 2, INT2FIX(t->sine)); rb_ary_store(ary, 3, INT2FIX(t->n)); return ary; } static VALUE rb_gsl_ary_to_integration_qawo_table(VALUE ary) { gsl_integration_qawo_table *t = NULL; t = make_qawo_table(ary); return Data_Wrap_Struct(cgsl_integration_qawo_table, 0, gsl_integration_qawo_table_free, t); } static gsl_integration_qawo_table* make_qawo_table(VALUE ary) { double omega, L; enum gsl_integration_qawo_enum sine; size_t n; omega = NUM2DBL(rb_ary_entry(ary, 0)); L = NUM2DBL(rb_ary_entry(ary, 1)); sine = FIX2INT(rb_ary_entry(ary, 2)); n = FIX2INT(rb_ary_entry(ary, 3)); return gsl_integration_qawo_table_alloc(omega, L, sine, n); } static VALUE rb_gsl_integration_qawo_table_set(int argc, VALUE *argv, VALUE obj) { gsl_integration_qawo_table *t = NULL; double omega, L; enum gsl_integration_qawo_enum sine; int type; if (argc != 1 && argc != 3) rb_raise(rb_eArgError, "wrong number of argument (%d for 1 or 3)", argc); type = TYPE(argv[0]); Data_Get_Struct(obj, gsl_integration_qawo_table, t); if (type == T_FIXNUM || type == T_BIGNUM || type == T_FLOAT) { omega = NUM2DBL(argv[0]); L = NUM2DBL(argv[1]); sine = FIX2INT(argv[2]); } else if (type == T_ARRAY) { omega = NUM2DBL(rb_ary_entry(argv[0], 0)); L = NUM2DBL(rb_ary_entry(argv[0], 1)); sine = FIX2INT(rb_ary_entry(argv[0], 2)); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); } gsl_integration_qawo_table_set(t, omega, L, sine); return obj; } static VALUE rb_gsl_integration_qawo_table_set_length(VALUE obj, VALUE L) { gsl_integration_qawo_table *t = NULL; Need_Float(L); Data_Get_Struct(obj, gsl_integration_qawo_table, t); gsl_integration_qawo_table_set_length(t, NUM2DBL(L)); return obj; } static int get_qawo_table(VALUE tt, gsl_integration_qawo_table **t); static VALUE rb_gsl_integration_qawo(int argc, VALUE *argv, VALUE obj) { double a, epsabs, epsrel; double result, abserr; size_t limit; gsl_function *F = NULL; gsl_integration_workspace *w = NULL; gsl_integration_qawo_table *t = NULL; int status, intervals, itmp, flag = 0, flagt = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } Need_Float(argv[itmp]); a = NUM2DBL(argv[itmp]); flagt = get_qawo_table(argv[argc-1], &t); flag = get_epsabs_epsrel_limit_workspace(argc-1, argv, itmp+1, &epsabs, &epsrel, &limit, &w); status = gsl_integration_qawo(F, a, epsabs, epsrel, limit, w, t, &result, &abserr); intervals = w->size; if (flag == 1) gsl_integration_workspace_free(w); if (flagt == 1) gsl_integration_qawo_table_free(t); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } static int get_qawo_table(VALUE tt, gsl_integration_qawo_table **t) { int flagt; if (TYPE(tt) == T_ARRAY) { flagt = 1; *t = make_qawo_table(tt); } else { flagt = 0; if (!rb_obj_is_kind_of(tt, cgsl_integration_qawo_table)) rb_raise(rb_eTypeError, "Integration::QAWO_Table expected"); Data_Get_Struct(tt, gsl_integration_qawo_table, *t); } return flagt; } static VALUE rb_gsl_integration_qawf(int argc, VALUE *argv, VALUE obj) { double a, epsabs = EPSREL_DEFAULT; double result, abserr; size_t limit = LIMIT_DEFAULT; gsl_function *F = NULL; gsl_integration_workspace *w = NULL, *cw = NULL; gsl_integration_qawo_table *t = NULL; int status, intervals, flag = 0, flagt = 0, itmp; VALUE *vtmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); itmp = 1; break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); Data_Get_Struct(obj, gsl_function, F); itmp = 0; break; } Need_Float(argv[itmp]); a = NUM2DBL(argv[itmp]); itmp += 1; if (TYPE(argv[itmp]) == T_FLOAT) { epsabs = NUM2DBL(argv[itmp]); itmp += 1; } vtmp = argv + itmp; flagt = get_qawo_table(argv[argc-1], &t); switch (argc - 1 - itmp) { case 0: w = gsl_integration_workspace_alloc(limit); cw = gsl_integration_workspace_alloc(limit); flag = 1; break; case 1: CHECK_FIXNUM(vtmp[0]); limit = FIX2INT(vtmp[0]); w = gsl_integration_workspace_alloc(limit); cw = gsl_integration_workspace_alloc(limit); flag = 1; break; case 2: CHECK_WORKSPACE(vtmp[0]); CHECK_WORKSPACE(vtmp[1]); Data_Get_Struct(vtmp[0], gsl_integration_workspace, w); Data_Get_Struct(vtmp[1], gsl_integration_workspace, cw); flag = 0; break; case 3: CHECK_FIXNUM(vtmp[0]); CHECK_WORKSPACE(vtmp[1]); CHECK_WORKSPACE(vtmp[2]); limit = FIX2INT(vtmp[0]); Data_Get_Struct(vtmp[1], gsl_integration_workspace, w); Data_Get_Struct(vtmp[2], gsl_integration_workspace, cw); flag = 0; break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } status = gsl_integration_qawf(F, a, epsabs, limit, w, cw, t, &result, &abserr); intervals = w->size; if (flag == 1) { gsl_integration_workspace_free(w); gsl_integration_workspace_free(cw); } if (flagt == 1) gsl_integration_qawo_table_free(t); return rb_ary_new3(4, rb_float_new(result), rb_float_new(abserr), INT2FIX(intervals), INT2FIX(status)); } static void rb_gsl_integration_define_symbols(VALUE module) { rb_define_const(module, "GAUSS15", INT2FIX(GSL_INTEG_GAUSS15)); rb_define_const(module, "GAUSS21", INT2FIX(GSL_INTEG_GAUSS21)); rb_define_const(module, "GAUSS31", INT2FIX(GSL_INTEG_GAUSS31)); rb_define_const(module, "GAUSS41", INT2FIX(GSL_INTEG_GAUSS41)); rb_define_const(module, "GAUSS51", INT2FIX(GSL_INTEG_GAUSS51)); rb_define_const(module, "GAUSS61", INT2FIX(GSL_INTEG_GAUSS61)); rb_define_const(module, "COSINE", INT2FIX(GSL_INTEG_COSINE)); rb_define_const(module, "SINE", INT2FIX(GSL_INTEG_SINE)); } static VALUE rb_gsl_integration_workspace_alloc(int argc, VALUE *argv, VALUE klass) { size_t limit; if (argc == 1) limit = FIX2INT(argv[0]); else limit = LIMIT_DEFAULT; return Data_Wrap_Struct(klass, 0, gsl_integration_workspace_free, gsl_integration_workspace_alloc(limit)); } static VALUE rb_gsl_integration_workspace_limit(VALUE obj) { gsl_integration_workspace *w = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); return INT2FIX(w->limit); } static VALUE rb_gsl_integration_workspace_size(VALUE obj) { gsl_integration_workspace *w = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); return INT2FIX(w->size); } static VALUE rb_gsl_integration_workspace_nrmax(VALUE obj) { gsl_integration_workspace *w = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); return INT2FIX(w->nrmax); } static VALUE rb_gsl_integration_workspace_i(VALUE obj) { gsl_integration_workspace *w = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); return INT2FIX(w->i); } static VALUE rb_gsl_integration_workspace_maximum_level(VALUE obj) { gsl_integration_workspace *w = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); return INT2FIX(w->maximum_level); } static VALUE rb_gsl_integration_workspace_to_a(VALUE obj) { gsl_integration_workspace *w = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); return rb_ary_new3(5, INT2FIX(w->limit), INT2FIX(w->size), INT2FIX(w->nrmax), INT2FIX(w->i), INT2FIX(w->maximum_level)); } static VALUE rb_gsl_integration_workspace_alist(VALUE obj) { gsl_integration_workspace *w = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); v = rb_gsl_make_vector_view(w->alist, w->limit, 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_integration_workspace_blist(VALUE obj) { gsl_integration_workspace *w = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); v = rb_gsl_make_vector_view(w->blist, w->limit, 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_integration_workspace_rlist(VALUE obj) { gsl_integration_workspace *w = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); v = rb_gsl_make_vector_view(w->rlist, w->limit, 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_integration_workspace_elist(VALUE obj) { gsl_integration_workspace *w = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_integration_workspace, w); v = rb_gsl_make_vector_view(w->elist, w->limit, 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } #ifdef GSL_1_14_LATER static VALUE rb_gsl_integration_glfixed_table_alloc(VALUE klass, VALUE n) { gsl_integration_glfixed_table *t; t = gsl_integration_glfixed_table_alloc(FIX2INT(n)); return Data_Wrap_Struct(cgsl_integration_glfixed_table, 0, gsl_integration_glfixed_table_free, t); } static VALUE rb_gsl_integration_glfixed(VALUE obj, VALUE aa, VALUE bb, VALUE tt) { gsl_function *f; double a, b; gsl_integration_glfixed_table *t; double res; if (!rb_obj_is_kind_of(tt, cgsl_integration_glfixed_table)) { rb_raise(rb_eTypeError, "Wrong arugment type (%s for GSL::Integration::Glfixed_table)", rb_class2name(CLASS_OF(tt))); } Data_Get_Struct(tt, gsl_integration_glfixed_table, t); a = NUM2DBL(aa); b = NUM2DBL(bb); Data_Get_Struct(obj, gsl_function, f); res = gsl_integration_glfixed(f, a, b, t); return rb_float_new(res); } #endif void Init_gsl_integration(VALUE module) { VALUE mgsl_integ; mgsl_integ = rb_define_module_under(module, "Integration"); rb_gsl_integration_define_symbols(mgsl_integ); rb_define_method(cgsl_function, "integration_qng", rb_gsl_integration_qng, -1); rb_define_method(cgsl_function, "integration_qag", rb_gsl_integration_qag, -1); rb_define_method(cgsl_function, "integration_qags", rb_gsl_integration_qags, -1); rb_define_method(cgsl_function, "integration_qagp", rb_gsl_integration_qagp, -1); rb_define_method(cgsl_function, "integration_qagi", rb_gsl_integration_qagi, -1); rb_define_method(cgsl_function, "integration_qagiu", rb_gsl_integration_qagiu, -1); rb_define_method(cgsl_function, "integration_qagil", rb_gsl_integration_qagil, -1); rb_define_method(cgsl_function, "integration_qawc", rb_gsl_integration_qawc, -1); rb_define_alias(cgsl_function, "qng", "integration_qng"); rb_define_alias(cgsl_function, "qag", "integration_qag"); rb_define_alias(cgsl_function, "qags", "integration_qags"); rb_define_alias(cgsl_function, "qagp", "integration_qagp"); rb_define_alias(cgsl_function, "qagi", "integration_qagi"); rb_define_alias(cgsl_function, "qagiu", "integration_qagiu"); rb_define_alias(cgsl_function, "qagil", "integration_qagil"); rb_define_alias(cgsl_function, "qawc", "integration_qawc"); cgsl_integration_qaws_table = rb_define_class_under(mgsl_integ, "QAWS_Table", cGSL_Object); rb_define_singleton_method(cgsl_integration_qaws_table, "alloc", rb_gsl_integration_qaws_table_alloc, -1); /* rb_define_singleton_method(cgsl_integration_qaws_table, "new", rb_gsl_integration_qaws_table_alloc, -1);*/ rb_define_method(cgsl_integration_qaws_table, "to_a", rb_gsl_integration_qaws_table_to_a, 0); rb_define_method(cgsl_integration_qaws_table, "set", rb_gsl_integration_qaws_table_set, -1); rb_define_method(rb_cArray, "to_gsl_integration_qaws_table", rb_gsl_ary_to_integration_qaws_table, 0); rb_define_alias(rb_cArray, "to_qaws_table", "to_gsl_integration_qaws_table"); rb_define_method(cgsl_function, "integration_qaws", rb_gsl_integration_qaws, -1); rb_define_alias(cgsl_function, "qaws", "integration_qaws"); cgsl_integration_qawo_table = rb_define_class_under(mgsl_integ, "QAWO_Table", cGSL_Object); rb_define_singleton_method(cgsl_integration_qawo_table, "alloc", rb_gsl_integration_qawo_table_alloc, -1); /* rb_define_singleton_method(cgsl_integration_qawo_table, "new", rb_gsl_integration_qawo_table_alloc, -1);*/ rb_define_method(cgsl_integration_qawo_table, "to_a", rb_gsl_integration_qawo_table_to_a, 0); rb_define_method(rb_cArray, "to_gsl_integration_qawo_table", rb_gsl_ary_to_integration_qawo_table, 0); rb_define_method(cgsl_integration_qawo_table, "set", rb_gsl_integration_qawo_table_set, -1); rb_define_method(cgsl_integration_qawo_table, "set_length", rb_gsl_integration_qawo_table_set_length, 1); rb_define_method(cgsl_function, "integration_qawo", rb_gsl_integration_qawo, -1); rb_define_method(cgsl_function, "integration_qawf", rb_gsl_integration_qawf, -1); rb_define_alias(cgsl_function, "qawo", "integration_qawo"); rb_define_alias(cgsl_function, "qawf", "integration_qawf"); cgsl_integration_workspace = rb_define_class_under(mgsl_integ, "Workspace", cGSL_Object); /* rb_define_singleton_method(cgsl_integration_workspace, "new", rb_gsl_integration_workspace_alloc, -1);*/ rb_define_singleton_method(cgsl_integration_workspace, "alloc", rb_gsl_integration_workspace_alloc, -1); rb_define_method(cgsl_integration_workspace, "limit", rb_gsl_integration_workspace_limit, 0); rb_define_method(cgsl_integration_workspace, "size", rb_gsl_integration_workspace_size, 0); rb_define_method(cgsl_integration_workspace, "nrmax", rb_gsl_integration_workspace_nrmax, 0); rb_define_method(cgsl_integration_workspace, "i", rb_gsl_integration_workspace_i, 0); rb_define_method(cgsl_integration_workspace, "maximum_level", rb_gsl_integration_workspace_maximum_level, 0); rb_define_method(cgsl_integration_workspace, "to_a", rb_gsl_integration_workspace_to_a, 0); rb_define_method(cgsl_integration_workspace, "alist", rb_gsl_integration_workspace_alist, 0); rb_define_method(cgsl_integration_workspace, "blist", rb_gsl_integration_workspace_blist, 0); rb_define_method(cgsl_integration_workspace, "rlist", rb_gsl_integration_workspace_rlist, 0); rb_define_method(cgsl_integration_workspace, "elist", rb_gsl_integration_workspace_elist, 0); /*****/ rb_define_module_function(mgsl_integ, "qng", rb_gsl_integration_qng, -1); rb_define_module_function(mgsl_integ, "qag", rb_gsl_integration_qag, -1); rb_define_module_function(mgsl_integ, "qags", rb_gsl_integration_qags, -1); rb_define_module_function(mgsl_integ, "qagp", rb_gsl_integration_qagp, -1); rb_define_module_function(mgsl_integ, "qagi", rb_gsl_integration_qagi, -1); rb_define_module_function(mgsl_integ, "qagiu", rb_gsl_integration_qagiu, -1); rb_define_module_function(mgsl_integ, "qagil", rb_gsl_integration_qagil, -1); rb_define_module_function(mgsl_integ, "qawc", rb_gsl_integration_qawc, -1); rb_define_module_function(mgsl_integ, "qaws", rb_gsl_integration_qaws, -1); rb_define_module_function(mgsl_integ, "qawo", rb_gsl_integration_qawo, -1); rb_define_module_function(mgsl_integ, "qawf", rb_gsl_integration_qawf, -1); #ifdef GSL_1_14_LATER cgsl_integration_glfixed_table = rb_define_class_under(mgsl_integ, "Glfixed_table", cGSL_Object); rb_define_singleton_method(cgsl_integration_glfixed_table, "alloc", rb_gsl_integration_glfixed_table_alloc, 1); rb_define_method(cgsl_function, "glfixed", rb_gsl_integration_glfixed, 3); #endif } #undef EPSABS_DEFAULT #undef EPSREL_DEFAULT #undef LIMIT_DEFAULT #undef KEY_DEFAULT #ifdef CHECK_WORKSPACE #undef CHECK_WORKSPACE #endif gsl-1.15.3/ext/sf_zeta.c0000644000175000017500000000640212220252463014343 0ustar boutilboutil/* sf_zeta.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_zeta_int(VALUE obj, VALUE n) { VALUE nn; if (TYPE(n) != T_FIXNUM) nn = INT2FIX(NUM2INT(n)); else nn = n; return rb_gsl_sf_eval1_int(gsl_sf_zeta_int, nn); } static VALUE rb_gsl_sf_zeta_int_e(VALUE obj, VALUE n) { VALUE nn; if (TYPE(n) != T_FIXNUM) nn = INT2FIX(NUM2INT(n)); else nn = n; return rb_gsl_sf_eval_e_int(gsl_sf_zeta_int_e, nn); } static VALUE rb_gsl_sf_zeta(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_zeta, x); } static VALUE rb_gsl_sf_zeta_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_zeta_e, x); } static VALUE rb_gsl_sf_hzeta(VALUE obj, VALUE s, VALUE q) { Need_Float(s); Need_Float(q); return rb_float_new(gsl_sf_hzeta(NUM2DBL(s), NUM2DBL(q))); } static VALUE rb_gsl_sf_hzeta_e(VALUE obj, VALUE s, VALUE q) { return rb_gsl_sf_eval_e_double2(gsl_sf_hzeta_e, s, q); } static VALUE rb_gsl_sf_eta_int(VALUE obj, VALUE n) { return rb_gsl_sf_eval1_int(gsl_sf_eta_int, n); } static VALUE rb_gsl_sf_eta_int_e(VALUE obj, VALUE n) { return rb_gsl_sf_eval_e_int(gsl_sf_eta_int_e, n); } static VALUE rb_gsl_sf_eta(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_eta, x); } static VALUE rb_gsl_sf_eta_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_eta_e, x); } #ifdef GSL_1_4_9_LATER static VALUE rb_gsl_sf_zetam1_int(VALUE obj, VALUE n) { VALUE nn; if (TYPE(n) != T_FIXNUM) nn = INT2FIX(NUM2INT(n)); else nn = n; return rb_gsl_sf_eval1_int(gsl_sf_zetam1_int, nn); } static VALUE rb_gsl_sf_zetam1_int_e(VALUE obj, VALUE n) { VALUE nn; if (TYPE(n) != T_FIXNUM) nn = INT2FIX(NUM2INT(n)); else nn = n; return rb_gsl_sf_eval_e_int(gsl_sf_zetam1_int_e, nn); } static VALUE rb_gsl_sf_zetam1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_zetam1, x); } static VALUE rb_gsl_sf_zetam1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_zetam1_e, x); } #endif void Init_gsl_sf_zeta(VALUE module) { rb_define_module_function(module, "zeta_int", rb_gsl_sf_zeta_int, 1); rb_define_module_function(module, "zeta_int_e", rb_gsl_sf_zeta_int_e, 1); rb_define_module_function(module, "zeta", rb_gsl_sf_zeta, 1); rb_define_module_function(module, "zeta_e", rb_gsl_sf_zeta_e, 1); rb_define_module_function(module, "hzeta", rb_gsl_sf_hzeta, 2); rb_define_module_function(module, "hzeta_e", rb_gsl_sf_hzeta_e, 2); rb_define_module_function(module, "eta_int", rb_gsl_sf_eta_int, 1); rb_define_module_function(module, "eta_int_e", rb_gsl_sf_eta_int_e, 1); rb_define_module_function(module, "eta", rb_gsl_sf_eta, 1); rb_define_module_function(module, "eta_e", rb_gsl_sf_eta_e, 1); #ifdef GSL_1_4_9_LATER rb_define_module_function(module, "zetam1_int", rb_gsl_sf_zetam1_int, 1); rb_define_module_function(module, "zetam1_int_e", rb_gsl_sf_zetam1_int_e, 1); rb_define_module_function(module, "zetam1", rb_gsl_sf_zetam1, 1); rb_define_module_function(module, "zetam1_e", rb_gsl_sf_zetam1_e, 1); #endif } gsl-1.15.3/ext/histogram_find.c0000644000175000017500000000504012220252463015702 0ustar boutilboutil/* histogram/find.c * * Copyright (C) 1996, 1997, 1998, 1999, 2000 Brian Gough * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or (at * your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "rb_gsl_histogram.h" /* determines whether to optimize for linear ranges */ #define LINEAR_OPT 1 int mygsl_find (const size_t n, const double range[], const double x, size_t * i) { size_t i_linear, lower, upper, mid; if (x < range[0]) return -1; if (x >= range[n]) return +1; /* optimize for linear case */ #ifdef LINEAR_OPT { double u = (x - range[0]) / (range[n] - range[0]); i_linear = (size_t) (n*u); } if (x >= range[i_linear] && x < range[i_linear + 1]) { *i = i_linear; return 0; } #endif /* perform binary search */ upper = n ; lower = 0 ; while (upper - lower > 1) { mid = (upper + lower) / 2 ; if (x >= range[mid]) { lower = mid ; } else { upper = mid ; } } *i = lower ; /* sanity check the result */ if (x < range[lower] || x >= range[lower + 1]) { GSL_ERROR ("x not found in range", GSL_ESANITY); } return 0; } int mygsl_find2d (const size_t nx, const double xrange[], const size_t ny, const double yrange[], const double x, const double y, size_t * i, size_t * j) { int status = mygsl_find (nx, xrange, x, i); if (status) return status; status = mygsl_find (ny, yrange, y, j); if (status) return status; return 0; } int mygsl_find3d (const size_t nx, const double xrange[], const size_t ny, const double yrange[], const size_t nz, const double zrange[], const double x, const double y, const double z, size_t * i, size_t * j, size_t *k) { int status = mygsl_find (nx, xrange, x, i); if (status) return status; status = mygsl_find (ny, yrange, y, j); if (status) return status; status = mygsl_find (nz, zrange, z, k); if (status) return status; return 0; } gsl-1.15.3/ext/eigen.c0000644000175000017500000022674112220252463014011 0ustar boutilboutil/* eigen.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_array.h" #include "rb_gsl_eigen.h" #include "rb_gsl_complex.h" #include #include #include #include static VALUE cgsl_eigen_symm_workspace; static VALUE cgsl_eigen_symmv_workspace; static VALUE cgsl_eigen_herm_workspace; static VALUE cgsl_eigen_hermv_workspace; static VALUE cgsl_eigen_values; static VALUE cgsl_eigen_vectors; static VALUE cgsl_eigen_vector; static VALUE cgsl_eigen_vector_complex; static VALUE cgsl_eigen_herm_vectors; #ifdef HAVE_EIGEN_FRANCIS static VALUE cgsl_eigen_francis_workspace; #endif #ifdef GSL_1_9_LATER static VALUE cgsl_eigen_nonsymm_workspace; static VALUE cgsl_eigen_nonsymmv_workspace; #endif #ifdef GSL_1_10_LATER static VALUE cgensymm, mgensymm; static VALUE cgensymmv, mgensymmv; static VALUE cgenherm, mgenherm; static VALUE cgenhermv, mgenhermv; static VALUE mgen, mgenv; static VALUE cgenw, cgenvw; #endif static VALUE rb_gsl_eigen_symm_alloc(VALUE klass, VALUE nn) { gsl_eigen_symm_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_symm_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgsl_eigen_symm_workspace, 0, gsl_eigen_symm_free, w); } static VALUE rb_gsl_eigen_symmv_alloc(VALUE klass, VALUE nn) { gsl_eigen_symmv_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_symmv_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgsl_eigen_symmv_workspace, 0, gsl_eigen_symmv_free, w); } static VALUE rb_gsl_eigen_herm_alloc(VALUE klass, VALUE nn) { gsl_eigen_herm_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_herm_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgsl_eigen_herm_workspace, 0, gsl_eigen_herm_free, w); } static VALUE rb_gsl_eigen_hermv_alloc(VALUE klass, VALUE nn) { gsl_eigen_hermv_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_hermv_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgsl_eigen_hermv_workspace, 0, gsl_eigen_hermv_free, w); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_symm_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_eigen_symm(int argc, VALUE *argv, VALUE obj) { gsl_matrix *Atmp = NULL, *A = NULL; gsl_eigen_symm_workspace *w = NULL; gsl_vector *v = NULL; int flagw = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symm_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, Atmp); if (CLASS_OF(argv[1]) != cgsl_eigen_symm_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Symm::Workspace expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_symm_workspace, w); break; case 1: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symm_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, Atmp); w = gsl_eigen_symm_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, Atmp); switch (argc) { case 1: if (CLASS_OF(argv[0]) != cgsl_eigen_symm_workspace) rb_raise(rb_eTypeError, "argv[0]: wrong argument type %s (Eigen::Symm::Workspace expected", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_eigen_symm_workspace, w); break; case 0: w = gsl_eigen_symm_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); } } A = make_matrix_clone(Atmp); v = gsl_vector_alloc(A->size1); gsl_eigen_symm(A, v, w); /* gsl_sort_vector(v);*/ gsl_matrix_free(A); if (flagw == 1) gsl_eigen_symm_free(w); return Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, v); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_symm_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; VALUE nary; gsl_matrix *A = NULL; gsl_eigen_symm_workspace *w = NULL; gsl_vector_view vv; int shape[1]; int flagw = 0; switch (argc) { case 2: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); if (CLASS_OF(argv[1]) != cgsl_eigen_symm_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Symm::Workspace expected", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_symm_workspace, w); flagw = 0; break; case 1: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); w = gsl_eigen_symm_alloc(A->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "matrix not given"); break; } shape[0] = A->size1; nary = na_make_object(NA_DFLOAT, 1, shape, cNVector); vv = gsl_vector_view_array(NA_PTR_TYPE(nary,double*), A->size1); gsl_eigen_symm(A, &vv.vector, w); /* gsl_sort_vector(v);*/ gsl_matrix_free(A); if (flagw == 1) gsl_eigen_symm_free(w); return nary; } #endif #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_symmv_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_eigen_symmv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *Atmp = NULL, *A = NULL, *em = NULL; gsl_eigen_symmv_workspace *w = NULL; gsl_vector *v = NULL; int flagw = 0; VALUE vval, vvec; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symmv_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, Atmp); if (CLASS_OF(argv[1]) != cgsl_eigen_symmv_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Symmv::Workspace expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_symmv_workspace, w); break; case 1: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_eigen_symmv_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, Atmp); w = gsl_eigen_symmv_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } break; default: CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, Atmp); switch (argc) { case 1: if (CLASS_OF(argv[0]) != cgsl_eigen_symmv_workspace) rb_raise(rb_eTypeError, "argv[0]: wrong argument type %s (Eigen::Symmv::Workspace expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_eigen_symmv_workspace, w); break; case 0: w = gsl_eigen_symmv_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } } A = make_matrix_clone(Atmp); em = gsl_matrix_alloc(A->size1, A->size2); v = gsl_vector_alloc(A->size1); gsl_eigen_symmv(A, v, em, w); /* gsl_eigen_symmv_sort(v, em, GSL_EIGEN_SORT_VAL_DESC);*/ gsl_matrix_free(A); if (flagw == 1) gsl_eigen_symmv_free(w); vval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, v); vvec = Data_Wrap_Struct(cgsl_eigen_vectors, 0, gsl_matrix_free, em); return rb_ary_new3(2, vval, vvec); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_symmv_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; VALUE eval, evec; gsl_matrix *A = NULL; gsl_eigen_symmv_workspace *w = NULL; gsl_matrix_view mv; gsl_vector_view vv; int shape1[1], shape2[2]; int flagw = 0; switch (argc) { case 2: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); if (CLASS_OF(argv[1]) != cgsl_eigen_symmv_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Symm::Workspace expected", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_symmv_workspace, w); flagw = 0; break; case 1: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); w = gsl_eigen_symmv_alloc(A->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "matrix not given"); break; } shape1[0] = A->size1; shape2[0] = A->size1; shape2[1] = A->size1; eval = na_make_object(NA_DFLOAT, 1, shape1, cNVector); evec = na_make_object(NA_DFLOAT, 2, shape2, CLASS_OF(argv[0])); vv = gsl_vector_view_array(NA_PTR_TYPE(eval,double*), A->size1); mv = gsl_matrix_view_array(NA_PTR_TYPE(evec,double*), A->size1, A->size2); gsl_eigen_symmv(A, &vv.vector, &mv.matrix, w); /* gsl_sort_vector(v);*/ gsl_matrix_free(A); if (flagw == 1) gsl_eigen_symmv_free(w); return rb_ary_new3(2, eval, evec); } #endif static VALUE rb_gsl_eigen_herm(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *Atmp = NULL, *A = NULL; gsl_eigen_herm_workspace *w = NULL; gsl_vector *v = NULL; int flagw = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, Atmp); if (CLASS_OF(argv[1]) != cgsl_eigen_herm_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Herm::Workspace expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_herm_workspace, w); break; case 1: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, Atmp); w = gsl_eigen_herm_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, Atmp); switch (argc) { case 1: if (CLASS_OF(argv[0]) != cgsl_eigen_herm_workspace) rb_raise(rb_eTypeError, "argv[0]: wrong argument type %s (Eigen::Herm::Workspace expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_eigen_herm_workspace, w); break; case 0: w = gsl_eigen_herm_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); } } A = make_matrix_complex_clone(Atmp); v = gsl_vector_alloc(A->size1); gsl_eigen_herm(A, v, w); /* gsl_sort_vector(v);*/ gsl_matrix_complex_free(A); if (flagw == 1) gsl_eigen_herm_free(w); return Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, v); } static VALUE rb_gsl_eigen_hermv(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *Atmp = NULL, *A = NULL, *em = NULL; gsl_eigen_hermv_workspace *w = NULL; gsl_vector *v = NULL; int flagw = 0; VALUE vval, vvec; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, Atmp); if (CLASS_OF(argv[1]) != cgsl_eigen_hermv_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Hermv::Workspace expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_hermv_workspace, w); break; case 1: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, Atmp); w = gsl_eigen_hermv_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, Atmp); switch (argc) { case 1: if (CLASS_OF(argv[0]) != cgsl_eigen_hermv_workspace) rb_raise(rb_eTypeError, "argv[0]: wrong argument type %s (Eigen::Hermv::Workspace expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_eigen_hermv_workspace, w); break; case 0: w = gsl_eigen_hermv_alloc(Atmp->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); } } A = make_matrix_complex_clone(Atmp); em = gsl_matrix_complex_alloc(A->size1, A->size2); v = gsl_vector_alloc(A->size1); gsl_eigen_hermv(A, v, em, w); /* gsl_eigen_hermv_sort(v, em, GSL_EIGEN_SORT_VAL_DESC);*/ gsl_matrix_complex_free(A); if (flagw == 1) gsl_eigen_hermv_free(w); vval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, v); vvec = Data_Wrap_Struct(cgsl_eigen_herm_vectors, 0, gsl_matrix_complex_free, em); return rb_ary_new3(2, vval, vvec); } static VALUE rb_gsl_eigen_vectors_unpack(VALUE obj) { gsl_matrix *m = NULL; gsl_vector *v = NULL; size_t i, j; double val; VALUE ary, tmp; Data_Get_Struct(obj, gsl_matrix, m); ary = rb_ary_new2(m->size1); for (i = 0; i < m->size1; i++) { v = gsl_vector_alloc(m->size2); for (j = 0; j < m->size2; j++) { val = gsl_matrix_get(m, j, i); gsl_vector_set(v, j, val); } tmp = Data_Wrap_Struct(cgsl_eigen_vector, 0, gsl_vector_free, v); rb_ary_store(ary, i, tmp); } return ary; } static VALUE rb_gsl_eigen_vectors_complex_unpack(VALUE obj) { gsl_matrix_complex *m = NULL; gsl_vector_complex *v = NULL; size_t i, j; gsl_complex z; VALUE ary, tmp; Data_Get_Struct(obj, gsl_matrix_complex, m); ary = rb_ary_new2(m->size1); for (i = 0; i < m->size1; i++) { v = gsl_vector_complex_alloc(m->size2); for (j = 0; j < m->size2; j++) { z= gsl_matrix_complex_get(m, j, i); gsl_vector_complex_set(v, j, z); } tmp = Data_Wrap_Struct(cgsl_eigen_vector_complex, 0, gsl_vector_complex_free, v); rb_ary_store(ary, i, tmp); } return ary; } static void rb_gsl_eigen_define_const(VALUE topmodule, VALUE module) { rb_define_const(topmodule, "EIGEN_SORT_VAL_ASC", INT2FIX(GSL_EIGEN_SORT_VAL_ASC)); rb_define_const(topmodule, "EIGEN_SORT_VAL_DESC", INT2FIX(GSL_EIGEN_SORT_VAL_DESC)); rb_define_const(topmodule, "EIGEN_SORT_ABS_ASC", INT2FIX(GSL_EIGEN_SORT_ABS_ASC)); rb_define_const(topmodule, "EIGEN_SORT_ABS_DESC", INT2FIX(GSL_EIGEN_SORT_ABS_DESC)); rb_define_const(module, "SORT_VAL_ASC", INT2FIX(GSL_EIGEN_SORT_VAL_ASC)); rb_define_const(module, "SORT_VAL_DESC", INT2FIX(GSL_EIGEN_SORT_VAL_DESC)); rb_define_const(module, "SORT_ABS_ASC", INT2FIX(GSL_EIGEN_SORT_ABS_ASC)); rb_define_const(module, "SORT_ABS_DESC", INT2FIX(GSL_EIGEN_SORT_ABS_DESC)); rb_define_const(module, "VAL_ASC", INT2FIX(GSL_EIGEN_SORT_VAL_ASC)); rb_define_const(module, "VAL_DESC", INT2FIX(GSL_EIGEN_SORT_VAL_DESC)); rb_define_const(module, "ABS_ASC", INT2FIX(GSL_EIGEN_SORT_ABS_ASC)); rb_define_const(module, "ABS_DESC", INT2FIX(GSL_EIGEN_SORT_ABS_DESC)); } static VALUE rb_gsl_eigen_real_sort(int argc, VALUE *argv, VALUE obj, int (*sortfunc)(gsl_vector*, gsl_matrix*, gsl_eigen_sort_t)) { gsl_vector *v = NULL; gsl_matrix *m = NULL; gsl_eigen_sort_t type = GSL_EIGEN_SORT_VAL_DESC; switch (argc) { case 3: CHECK_FIXNUM(argv[2]); type = FIX2INT(argv[2]); /* no break, do next */ case 2: if (argv[0] == Qnil) { v = NULL; } else { CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, v); } if (argv[1] == Qnil) { m = NULL; } else { CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[1], gsl_matrix, m); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } return INT2FIX((*sortfunc)(v, m, type)); } static VALUE rb_gsl_eigen_complex_sort(int argc, VALUE *argv, VALUE obj, int (*sortfunc)(gsl_vector*, gsl_matrix_complex*, gsl_eigen_sort_t)) { gsl_vector *v = NULL; gsl_matrix_complex *m = NULL; gsl_eigen_sort_t type = GSL_EIGEN_SORT_VAL_DESC; switch (argc) { case 3: CHECK_FIXNUM(argv[2]); type = FIX2INT(argv[2]); /* no break, do next */ case 2: if (argv[0] == Qnil) { v = NULL; } else { CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, v); } if (argv[1] == Qnil) { m = NULL; } else { CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[1], gsl_matrix_complex, m); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } return INT2FIX((*sortfunc)(v, m, type)); } static VALUE rb_gsl_eigen_symmv_sort(int argc, VALUE *argv, VALUE obj) { return rb_gsl_eigen_real_sort(argc, argv, obj, gsl_eigen_symmv_sort); } static VALUE rb_gsl_eigen_hermv_sort(int argc, VALUE *argv, VALUE obj) { return rb_gsl_eigen_complex_sort(argc, argv, obj, gsl_eigen_hermv_sort); } #ifdef HAVE_EIGEN_FRANCIS static VALUE rb_gsl_eigen_francis_alloc(VALUE klass) { gsl_eigen_francis_workspace *w = NULL; w = gsl_eigen_francis_alloc(); return Data_Wrap_Struct(klass, 0, gsl_eigen_francis_free, w); } static VALUE rb_gsl_eigen_francis_T(int argc, VALUE *argv, VALUE obj) { gsl_eigen_francis_workspace *w = NULL; int istart = 0; if (CLASS_OF(obj) == cgsl_eigen_francis_workspace) { Data_Get_Struct(obj, gsl_eigen_francis_workspace, w); istart = 0; } else { if (argc != 1) rb_raise(rb_eArgError, "too few arguments (%d for 1)\n", argc); Data_Get_Struct(argv[0], gsl_eigen_francis_workspace, w); istart = 1; } gsl_eigen_francis_T(FIX2INT(argv[istart]), w); return Qtrue; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_francis_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_eigen_francis(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m, *mtmp; gsl_vector_complex *v; gsl_eigen_francis_workspace *w; int vflag = 0, wflag = 0; int istart = 0; VALUE *argv2; #ifdef HAVE_NARRAY_H if (NA_IsNArray(obj)) return rb_gsl_eigen_francis_narray(argc, argv, obj); if (argc >= 1 && NA_IsNArray(argv[0])) return rb_gsl_eigen_francis_narray(argc, argv, obj); #endif if (MATRIX_P(obj)) { Data_Get_Struct(obj, gsl_matrix, m); argv2 = argv; istart = 0; } else { if (argc < 1) rb_raise(rb_eArgError, "Wrong number of arguments.\n"); Data_Get_Struct(argv[0], gsl_matrix, m); istart = 1; argv2 = argv + 1; } switch (argc-istart) { case 0: v = gsl_vector_complex_alloc(m->size1); w = gsl_eigen_francis_alloc(); vflag = 1; wflag = 1; break; case 1: if (CLASS_OF(argv2[0]) == cgsl_vector_complex) { Data_Get_Struct(argv2[0], gsl_vector_complex, v); w = gsl_eigen_francis_alloc(); wflag = 1; } else if (CLASS_OF(argv2[0]) == cgsl_eigen_francis_workspace) { v = gsl_vector_complex_alloc(m->size1); vflag = 1; Data_Get_Struct(argv2[0], gsl_eigen_francis_workspace, w); } else { rb_raise(rb_eArgError, "Wrong argument type.\n"); } break; case 2: CHECK_VECTOR_COMPLEX(argv2[0]); if (CLASS_OF(argv2[1]) != cgsl_eigen_francis_workspace) { rb_raise(rb_eArgError, "argv[1] must be a GSL::Eigen::francis::Workspace.\n"); } Data_Get_Struct(argv2[0], gsl_vector_complex, v); Data_Get_Struct(argv2[1], gsl_eigen_francis_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2).\n", argc); } mtmp = make_matrix_clone(m); gsl_eigen_francis(mtmp, v, w); gsl_matrix_free(mtmp); if (wflag == 1) gsl_eigen_francis_free(w); if (vflag == 1) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v); else return argv2[0]; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_francis_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; VALUE nary; gsl_matrix *A = NULL; gsl_eigen_francis_workspace *w = NULL; gsl_vector_complex_view vv; int shape[1]; int flagw = 0; switch (argc) { case 2: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); if (CLASS_OF(argv[1]) != cgsl_eigen_francis_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Symm::Workspace expected", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_francis_workspace, w); flagw = 0; break; case 1: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); w = gsl_eigen_francis_alloc(); flagw = 1; break; default: rb_raise(rb_eArgError, "matrix not given"); break; } shape[0] = A->size1; nary = na_make_object(NA_DCOMPLEX, 1, shape, cNVector); vv = gsl_vector_complex_view_array(NA_PTR_TYPE(nary,double*), A->size1); gsl_eigen_francis(A, &vv.vector, w); /* gsl_sort_vector(v);*/ gsl_matrix_free(A); if (flagw == 1) gsl_eigen_francis_free(w); return nary; } #endif static VALUE rb_gsl_eigen_francis_Z(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m, *mtmp, *Z; gsl_vector_complex *v; gsl_eigen_francis_workspace *w; int vflag = 0, wflag = 0; int istart = 0; VALUE *argv2, vv, ZZ; if (MATRIX_P(obj)) { Data_Get_Struct(obj, gsl_matrix, m); argv2 = argv; istart = 0; } else { if (argc < 1) rb_raise(rb_eArgError, "Wrong number of arguments.\n"); Data_Get_Struct(argv[0], gsl_matrix, m); istart = 1; argv2 = argv + 1; } switch (argc-istart) { case 0: v = gsl_vector_complex_alloc(m->size1); Z = gsl_matrix_alloc(m->size1, m->size2); w = gsl_eigen_francis_alloc(); vflag = 1; wflag = 1; break; case 1: if (CLASS_OF(argv2[0]) == cgsl_eigen_francis_workspace) { v = gsl_vector_complex_alloc(m->size1); Z = gsl_matrix_alloc(m->size1, m->size2); vflag = 1; Data_Get_Struct(argv2[0], gsl_eigen_francis_workspace, w); } else { rb_raise(rb_eArgError, "Wrong argument type.\n"); } break; case 3: CHECK_VECTOR_COMPLEX(argv2[0]); CHECK_MATRIX(argv2[1]); if (CLASS_OF(argv2[2]) != cgsl_eigen_francis_workspace) { rb_raise(rb_eArgError, "argv[1] must be a GSL::Eigen::francis::Workspace.\n"); } Data_Get_Struct(argv2[0], gsl_vector_complex, v); Data_Get_Struct(argv2[1], gsl_matrix, Z); Data_Get_Struct(argv2[2], gsl_eigen_francis_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2).\n", argc); } mtmp = make_matrix_clone(m); gsl_eigen_francis_Z(mtmp, v, Z, w); gsl_matrix_free(mtmp); if (wflag == 1) gsl_eigen_francis_free(w); if (vflag == 1) { vv = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v); ZZ = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Z); } else { vv = argv2[0]; ZZ = argv2[1]; } return rb_ary_new3(2, vv, ZZ); } #endif #ifdef GSL_1_9_LATER static VALUE rb_gsl_eigen_nonsymm_alloc(VALUE klass, VALUE nn) { size_t n; gsl_eigen_nonsymm_workspace *w = NULL; n = (size_t) FIX2UINT(nn); w = gsl_eigen_nonsymm_alloc(n); return Data_Wrap_Struct(cgsl_eigen_nonsymm_workspace, 0, gsl_eigen_nonsymm_free, w); } static VALUE rb_gsl_eigen_nonsymm_params(int argc, VALUE *argv, VALUE obj) { gsl_eigen_nonsymm_workspace *w = NULL; int istart = 0; if (CLASS_OF(obj) == cgsl_eigen_nonsymm_workspace) { Data_Get_Struct(obj, gsl_eigen_nonsymm_workspace, w); istart = 0; } else { if (argc != 3) rb_raise(rb_eArgError, "too few arguments (%d for 3)\n", argc); Data_Get_Struct(argv[2], gsl_eigen_nonsymm_workspace, w); istart = 1; } switch (argc - istart) { case 2: gsl_eigen_nonsymm_params(FIX2INT(argv[0]), FIX2INT(argv[1]), w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments.\n"); } return Qtrue; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_nonsymm_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_eigen_nonsymm(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m; gsl_vector_complex *v; gsl_eigen_nonsymm_workspace *w; int vflag = 0, wflag = 0; int istart = 0; VALUE *argv2; #ifdef HAVE_NARRAY_H if (NA_IsNArray(obj)) return rb_gsl_eigen_nonsymm_narray(argc, argv, obj); if (argc >= 1 && NA_IsNArray(argv[0])) return rb_gsl_eigen_nonsymm_narray(argc, argv, obj); #endif if (MATRIX_P(obj)) { Data_Get_Struct(obj, gsl_matrix, m); argv2 = argv; istart = 0; } else { if (argc < 1) rb_raise(rb_eArgError, "Wrong number of arguments.\n"); Data_Get_Struct(argv[0], gsl_matrix, m); istart = 1; argv2 = argv + 1; } switch (argc-istart) { case 0: v = gsl_vector_complex_alloc(m->size1); w = gsl_eigen_nonsymm_alloc(m->size1); vflag = 1; wflag = 1; break; case 1: if (CLASS_OF(argv2[0]) == cgsl_vector_complex) { Data_Get_Struct(argv2[0], gsl_vector_complex, v); w = gsl_eigen_nonsymm_alloc(m->size1); wflag = 1; } else if (CLASS_OF(argv2[0]) == cgsl_eigen_nonsymm_workspace) { v = gsl_vector_complex_alloc(m->size1); vflag = 1; Data_Get_Struct(argv2[0], gsl_eigen_nonsymm_workspace, w); } else { rb_raise(rb_eArgError, "Wrong argument type.\n"); } break; case 2: CHECK_VECTOR_COMPLEX(argv2[0]); if (CLASS_OF(argv2[1]) != cgsl_eigen_nonsymm_workspace) { rb_raise(rb_eArgError, "argv[1] must be a GSL::Eigen::Nonsymm::Workspace.\n"); } Data_Get_Struct(argv2[0], gsl_vector_complex, v); Data_Get_Struct(argv2[1], gsl_eigen_nonsymm_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2).\n", argc); } // mtmp = make_matrix_clone(m); gsl_eigen_nonsymm(m, v, w); // gsl_matrix_free(mtmp); if (wflag == 1) gsl_eigen_nonsymm_free(w); if (vflag == 1) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v); else return argv2[0]; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_nonsymm_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; VALUE nary; gsl_matrix *A = NULL; gsl_eigen_nonsymm_workspace *w = NULL; gsl_vector_complex_view vv; int shape[1]; int flagw = 0; switch (argc) { case 2: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); if (CLASS_OF(argv[1]) != cgsl_eigen_nonsymm_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Symm::Workspace expected", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_nonsymm_workspace, w); flagw = 0; break; case 1: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); w = gsl_eigen_nonsymm_alloc(A->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "matrix not given"); break; } shape[0] = A->size1; nary = na_make_object(NA_DCOMPLEX, 1, shape, cNVector); vv = gsl_vector_complex_view_array(NA_PTR_TYPE(nary,double*), A->size1); gsl_eigen_nonsymm(A, &vv.vector, w); /* gsl_sort_vector(v);*/ gsl_matrix_free(A); if (flagw == 1) gsl_eigen_nonsymm_free(w); return nary; } #endif static VALUE rb_gsl_eigen_nonsymm_Z(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m, *Z; gsl_vector_complex *v; gsl_eigen_nonsymm_workspace *w; int vflag = 0, wflag = 0; int istart = 0; VALUE *argv2, vv, ZZ; if (MATRIX_P(obj)) { Data_Get_Struct(obj, gsl_matrix, m); argv2 = argv; istart = 0; } else { if (argc < 1) rb_raise(rb_eArgError, "Wrong number of arguments.\n"); Data_Get_Struct(argv[0], gsl_matrix, m); istart = 1; argv2 = argv + 1; } switch (argc-istart) { case 0: v = gsl_vector_complex_alloc(m->size1); Z = gsl_matrix_alloc(m->size1, m->size2); w = gsl_eigen_nonsymm_alloc(m->size1); vflag = 1; wflag = 1; break; case 1: if (CLASS_OF(argv2[0]) == cgsl_eigen_nonsymm_workspace) { v = gsl_vector_complex_alloc(m->size1); Z = gsl_matrix_alloc(m->size1, m->size2); vflag = 1; Data_Get_Struct(argv2[0], gsl_eigen_nonsymm_workspace, w); } else { rb_raise(rb_eArgError, "Wrong argument type.\n"); } break; case 3: CHECK_VECTOR_COMPLEX(argv2[0]); CHECK_MATRIX(argv2[1]); if (CLASS_OF(argv2[2]) != cgsl_eigen_nonsymm_workspace) { rb_raise(rb_eArgError, "argv[1] must be a GSL::Eigen::Nonsymm::Workspace.\n"); } Data_Get_Struct(argv2[0], gsl_vector_complex, v); Data_Get_Struct(argv2[1], gsl_matrix, Z); Data_Get_Struct(argv2[2], gsl_eigen_nonsymm_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2).\n", argc); } // mtmp = make_matrix_clone(m); gsl_eigen_nonsymm_Z(m, v, Z, w); // gsl_matrix_free(mtmp); if (wflag == 1) gsl_eigen_nonsymm_free(w); if (vflag == 1) { vv = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v); ZZ = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Z); } else { vv = argv2[0]; ZZ = argv2[1]; } return rb_ary_new3(2, vv, ZZ); } static VALUE rb_gsl_eigen_nonsymmv_alloc(VALUE klass, VALUE nn) { size_t n; gsl_eigen_nonsymmv_workspace *w = NULL; n = (size_t) FIX2UINT(nn); w = gsl_eigen_nonsymmv_alloc(n); return Data_Wrap_Struct(cgsl_eigen_nonsymmv_workspace, 0, gsl_eigen_nonsymmv_free, w); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_nonsymmv_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_eigen_nonsymmv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m; gsl_vector_complex *v; gsl_matrix_complex *evec; gsl_eigen_nonsymmv_workspace *w; int vflag = 0, wflag = 0; int istart = 0; VALUE *argv2; #ifdef HAVE_NARRAY_H if (NA_IsNArray(obj)) return rb_gsl_eigen_nonsymmv_narray(argc, argv, obj); if (argc >= 1 && NA_IsNArray(argv[0])) return rb_gsl_eigen_nonsymmv_narray(argc, argv, obj); #endif if (MATRIX_P(obj)) { Data_Get_Struct(obj, gsl_matrix, m); argv2 = argv; istart = 0; } else { if (argc < 1) rb_raise(rb_eArgError, "Wrong number of arguments.\n"); Data_Get_Struct(argv[0], gsl_matrix, m); istart = 1; argv2 = argv + 1; } switch (argc-istart) { case 0: v = gsl_vector_complex_alloc(m->size1); evec = gsl_matrix_complex_alloc(m->size1, m->size2); w = gsl_eigen_nonsymmv_alloc(m->size1); vflag = 1; wflag = 1; break; case 1: if (CLASS_OF(argv2[0]) == cgsl_eigen_nonsymmv_workspace) { v = gsl_vector_complex_alloc(m->size1); evec = gsl_matrix_complex_alloc(m->size1, m->size2); vflag = 1; Data_Get_Struct(argv2[0], gsl_eigen_nonsymmv_workspace, w); } else { rb_raise(rb_eArgError, "Wrong argument type.\n"); } break; case 2: CHECK_VECTOR_COMPLEX(argv2[0]); CHECK_MATRIX_COMPLEX(argv2[1]); w = gsl_eigen_nonsymmv_alloc(m->size1); wflag = 1; break; case 3: CHECK_VECTOR_COMPLEX(argv2[0]); CHECK_MATRIX_COMPLEX(argv2[1]); if (CLASS_OF(argv2[2]) != cgsl_eigen_nonsymmv_workspace) { rb_raise(rb_eArgError, "argv[1] must be a GSL::Eigen::Nonsymm::Workspace.\n"); } Data_Get_Struct(argv2[0], gsl_vector_complex, v); Data_Get_Struct(argv2[1], gsl_matrix_complex, evec); Data_Get_Struct(argv2[2], gsl_eigen_nonsymmv_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-3).\n", argc); } // mtmp = make_matrix_clone(m); gsl_eigen_nonsymmv(m, v, evec, w); // gsl_matrix_free(mtmp); if (wflag == 1) gsl_eigen_nonsymmv_free(w); if (vflag == 1) { return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v), Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, evec)); } else { return rb_ary_new3(2, argv2[0], argv2[1]); } } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_eigen_nonsymmv_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; VALUE nary, nvec; gsl_matrix *A = NULL; gsl_eigen_nonsymmv_workspace *w = NULL; gsl_vector_complex_view vv; gsl_matrix_complex_view mm; int shape[1], shape2[2]; int flagw = 0; switch (argc) { case 2: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); if (CLASS_OF(argv[1]) != cgsl_eigen_nonsymmv_workspace) rb_raise(rb_eTypeError, "argv[1]: wrong argument type %s (Eigen::Symm::Workspace expected", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[1], gsl_eigen_nonsymmv_workspace, w); flagw = 0; break; case 1: if (!NA_IsNArray(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (NArray expected)", rb_class2name(CLASS_OF(argv[0]))); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); A = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(A->data, (double*) na->ptr, sizeof(double)*A->size1*A->size2); w = gsl_eigen_nonsymmv_alloc(A->size1); flagw = 1; break; default: rb_raise(rb_eArgError, "matrix not given"); break; } shape[0] = A->size1; shape2[0] = A->size1; shape2[1] = A->size2; nary = na_make_object(NA_DCOMPLEX, 1, shape, cNVector); vv = gsl_vector_complex_view_array(NA_PTR_TYPE(nary,double*), A->size1); nvec = na_make_object(NA_DCOMPLEX, 2, shape2, CLASS_OF(argv[0])); mm = gsl_matrix_complex_view_array(NA_PTR_TYPE(nvec,double*), A->size1, A->size2); gsl_eigen_nonsymmv(A, &vv.vector, &mm.matrix, w); /* gsl_sort_vector(v);*/ gsl_matrix_free(A); if (flagw == 1) gsl_eigen_nonsymmv_free(w); return rb_ary_new3(2, nary, nvec); } #endif static VALUE rb_gsl_eigen_nonsymmv_Z(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m, *Z; gsl_vector_complex *v; gsl_matrix_complex *evec; gsl_eigen_nonsymmv_workspace *w; int vflag = 0, wflag = 0; int istart = 0; VALUE *argv2; if (MATRIX_P(obj)) { Data_Get_Struct(obj, gsl_matrix, m); argv2 = argv; istart = 0; } else { if (argc < 1) rb_raise(rb_eArgError, "Wrong number of arguments.\n"); Data_Get_Struct(argv[0], gsl_matrix, m); istart = 1; argv2 = argv + 1; } switch (argc-istart) { case 0: v = gsl_vector_complex_alloc(m->size1); evec = gsl_matrix_complex_alloc(m->size1, m->size2); Z = gsl_matrix_alloc(m->size1, m->size2); w = gsl_eigen_nonsymmv_alloc(m->size1); vflag = 1; wflag = 1; break; case 1: if (CLASS_OF(argv2[0]) == cgsl_eigen_nonsymm_workspace) { v = gsl_vector_complex_alloc(m->size1); evec = gsl_matrix_complex_alloc(m->size1, m->size2); vflag = 1; Data_Get_Struct(argv2[0], gsl_eigen_nonsymmv_workspace, w); } else { rb_raise(rb_eArgError, "Wrong argument type.\n"); } break; case 3: CHECK_VECTOR_COMPLEX(argv2[0]); CHECK_MATRIX_COMPLEX(argv2[1]); CHECK_MATRIX(argv2[2]); w = gsl_eigen_nonsymmv_alloc(m->size1); wflag = 1; break; case 4: CHECK_VECTOR_COMPLEX(argv2[0]); CHECK_MATRIX_COMPLEX(argv2[1]); CHECK_MATRIX(argv2[2]); if (CLASS_OF(argv2[3]) != cgsl_eigen_nonsymm_workspace) { rb_raise(rb_eArgError, "argv[1] must be a GSL::Eigen::Nonsymm::Workspace.\n"); } Data_Get_Struct(argv2[0], gsl_vector_complex, v); Data_Get_Struct(argv2[1], gsl_matrix_complex, evec); Data_Get_Struct(argv2[1], gsl_matrix, Z); Data_Get_Struct(argv2[3], gsl_eigen_nonsymmv_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-3).\n", argc); } // mtmp = make_matrix_clone(m); gsl_eigen_nonsymmv_Z(m, v, evec, Z, w); // gsl_matrix_free(mtmp); if (wflag == 1) gsl_eigen_nonsymmv_free(w); if (vflag == 1) { return rb_ary_new3(3, Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, v), Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, evec), Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Z)); } else { return rb_ary_new3(2, argv2[0], argv2[1], argv2[2]); } } static VALUE rb_gsl_eigen_complex_sort2(int argc, VALUE *argv, VALUE obj, int (*sortfunc)(gsl_vector_complex*, gsl_matrix_complex*, gsl_eigen_sort_t)) { gsl_vector_complex *v = NULL; gsl_matrix_complex *m = NULL; gsl_eigen_sort_t type = GSL_EIGEN_SORT_ABS_DESC; switch (argc) { case 3: CHECK_FIXNUM(argv[2]); type = FIX2INT(argv[2]); /* no break, do next */ case 2: if (argv[0] == Qnil) { v = NULL; } else { CHECK_VECTOR_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_vector_complex, v); } if (argv[1] == Qnil) { m = NULL; } else { CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[1], gsl_matrix_complex, m); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } return INT2FIX((*sortfunc)(v, m, type)); } static VALUE rb_gsl_eigen_nonsymmv_sort(int argc, VALUE *argv, VALUE obj) { return rb_gsl_eigen_complex_sort2(argc, argv, obj, gsl_eigen_nonsymmv_sort); } #endif #ifdef GSL_1_10_LATER static VALUE rb_gsl_eigen_gensymm_alloc(VALUE klass, VALUE nn) { gsl_eigen_gensymm_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_gensymm_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgensymm, 0, gsl_eigen_gensymm_free, w); } static VALUE rb_gsl_eigen_gensymmv_alloc(VALUE klass, VALUE nn) { gsl_eigen_gensymmv_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_gensymmv_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgensymmv, 0, gsl_eigen_gensymmv_free, w); } static VALUE rb_gsl_eigen_genherm_alloc(VALUE klass, VALUE nn) { gsl_eigen_genherm_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_genherm_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgenherm, 0, gsl_eigen_genherm_free, w); } static VALUE rb_gsl_eigen_genhermv_alloc(VALUE klass, VALUE nn) { gsl_eigen_genhermv_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_eigen_genhermv_alloc(FIX2INT(nn)); return Data_Wrap_Struct(cgenhermv, 0, gsl_eigen_genhermv_free, w); } static int check_argv_gensymm(int argc, VALUE *argv, VALUE obj, gsl_matrix **A, gsl_matrix **B, gsl_vector **eval, gsl_eigen_gensymm_workspace **w) { int argc2 = argc; int flag = 0; if (CLASS_OF(obj) == cgensymm) { Data_Get_Struct(obj, gsl_eigen_gensymm_workspace, *w); } else { if (rb_obj_is_kind_of(argv[argc-1], cgensymm)) { Data_Get_Struct(argv[argc-1], gsl_eigen_gensymm_workspace, *w); argc2 = argc-1; } else { /* workspace is not given */ } } switch (argc2) { case 2: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; case 3: if (rb_obj_is_kind_of(argv[2], cgensymm)) { Data_Get_Struct(argv[2], gsl_eigen_gensymm_workspace, *w); } else { CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, *eval); } CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } if (*eval == NULL) { *eval = gsl_vector_alloc((*A)->size1); flag += 1; } if (*w == NULL) { *w = gsl_eigen_gensymm_alloc((*A)->size1); flag += 2; } return flag; } static int check_argv_gensymmv(int argc, VALUE *argv, VALUE obj, gsl_matrix **A, gsl_matrix **B, gsl_vector **eval, gsl_matrix **evec, gsl_eigen_gensymmv_workspace **w) { int argc2 = argc; int flag = 0; if (CLASS_OF(obj) == cgensymmv) { Data_Get_Struct(obj, gsl_eigen_gensymmv_workspace, *w); } else { if (rb_obj_is_kind_of(argv[argc-1], cgensymmv)) { Data_Get_Struct(argv[argc-1], gsl_eigen_gensymmv_workspace, *w); argc2 = argc-1; } else { /* workspace is not given */ } } switch (argc2) { case 2: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; case 3: if (rb_obj_is_kind_of(argv[2], cgensymmv)) { Data_Get_Struct(argv[2], gsl_eigen_gensymmv_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigen::Gensymmv::Workspace expected)", rb_class2name(CLASS_OF(argv[2]))); } CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; case 5: if (rb_obj_is_kind_of(argv[4], cgensymmv)) { Data_Get_Struct(argv[4], gsl_eigen_gensymmv_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigen::Gensymmv::Workspace expected)", rb_class2name(CLASS_OF(argv[4]))); } CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, *eval); CHECK_MATRIX(argv[3]); Data_Get_Struct(argv[3], gsl_matrix, *evec); CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2, 3 or 5)", argc); } if (*eval == NULL && *evec == NULL) { *eval = gsl_vector_alloc((*A)->size1); *evec = gsl_matrix_alloc((*A)->size1, (*A)->size2); flag += 1; } if (*w == NULL) { *w = gsl_eigen_gensymmv_alloc((*A)->size1); flag += 2; } return flag; } static int check_argv_genherm(int argc, VALUE *argv, VALUE obj, gsl_matrix_complex **A, gsl_matrix_complex **B, gsl_vector **eval, gsl_eigen_genherm_workspace **w) { int argc2 = argc; int flag = 0; if (CLASS_OF(obj) == cgenherm) { Data_Get_Struct(obj, gsl_eigen_genherm_workspace, *w); } else { if (rb_obj_is_kind_of(argv[argc-1], cgenherm)) { Data_Get_Struct(argv[argc-1], gsl_eigen_genherm_workspace, *w); argc2 = argc-1; } else { /* workspace is not given */ } } switch (argc2) { case 2: CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, *A); Data_Get_Struct(argv[1], gsl_matrix_complex, *B); break; case 3: if (rb_obj_is_kind_of(argv[2], cgenherm)) { Data_Get_Struct(argv[2], gsl_eigen_genherm_workspace, *w); } else { CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, *eval); } CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, *A); Data_Get_Struct(argv[1], gsl_matrix_complex, *B); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } if (*eval == NULL) { *eval = gsl_vector_alloc((*A)->size1); flag += 1; } if (*w == NULL) { *w = gsl_eigen_genherm_alloc((*A)->size1); flag += 2; } return flag; } static int check_argv_genhermv(int argc, VALUE *argv, VALUE obj, gsl_matrix_complex **A, gsl_matrix_complex **B, gsl_vector **eval, gsl_matrix_complex **evec, gsl_eigen_genhermv_workspace **w) { int argc2 = argc; int flag = 0; if (CLASS_OF(obj) == cgenhermv) { Data_Get_Struct(obj, gsl_eigen_genhermv_workspace, *w); } else { if (rb_obj_is_kind_of(argv[argc-1], cgenhermv)) { Data_Get_Struct(argv[argc-1], gsl_eigen_genhermv_workspace, *w); argc2 = argc-1; } else { /* workspace is not given */ } } switch (argc2) { case 2: CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, *A); Data_Get_Struct(argv[1], gsl_matrix_complex, *B); break; case 3: if (rb_obj_is_kind_of(argv[2], cgenhermv)) { Data_Get_Struct(argv[2], gsl_eigen_genhermv_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigen::Genhermv::Workspace expected)", rb_class2name(CLASS_OF(argv[2]))); } CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, *A); Data_Get_Struct(argv[1], gsl_matrix_complex, *B); break; case 5: if (rb_obj_is_kind_of(argv[4], cgenhermv)) { Data_Get_Struct(argv[4], gsl_eigen_genhermv_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigen::Genhermv::Workspace expected)", rb_class2name(CLASS_OF(argv[4]))); } CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, *eval); CHECK_MATRIX_COMPLEX(argv[3]); Data_Get_Struct(argv[3], gsl_matrix_complex, *evec); CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, *A); Data_Get_Struct(argv[1], gsl_matrix_complex, *B); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2, 3 or 5)", argc); } if (*eval == NULL && *evec == NULL) { *eval = gsl_vector_alloc((*A)->size1); *evec = gsl_matrix_complex_alloc((*A)->size1, (*A)->size2); flag += 1; } if (*w == NULL) { *w = gsl_eigen_genhermv_alloc((*A)->size1); flag += 2; } return flag; } static VALUE rb_gsl_eigen_gensymm(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL; gsl_matrix *Atmp = NULL; gsl_vector *eval = NULL; gsl_eigen_gensymm_workspace *w = NULL; int flag; VALUE veval; flag = check_argv_gensymm(argc, argv, obj, &A, &B, &eval, &w); Atmp = make_matrix_clone(A); // Btmp = make_matrix_clone(B); gsl_eigen_gensymm(Atmp, B, eval, w); gsl_matrix_free(Atmp); // gsl_matrix_free(Btmp); switch (flag) { case 0: veval = argv[2]; break; case 1: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); break; case 2: veval = argv[2]; gsl_eigen_gensymm_free(w); break; case 3: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); gsl_eigen_gensymm_free(w); break; } return veval; } static VALUE rb_gsl_eigen_gensymmv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL; gsl_matrix *Atmp = NULL; gsl_vector *eval = NULL; gsl_matrix *evec = NULL; gsl_eigen_gensymmv_workspace *w = NULL; int flag; VALUE veval, vevec; flag = check_argv_gensymmv(argc, argv, obj, &A, &B, &eval, &evec, &w); Atmp = make_matrix_clone(A); // Btmp = make_matrix_clone(B); gsl_eigen_gensymmv(Atmp, B, eval, evec, w); gsl_matrix_free(Atmp); // gsl_matrix_free(Btmp); switch (flag) { case 0: veval = argv[2]; vevec = argv[3]; break; case 1: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); vevec = Data_Wrap_Struct(cgsl_eigen_vectors, 0, gsl_matrix_free, evec); break; case 2: veval = argv[2]; vevec = argv[3]; gsl_eigen_gensymmv_free(w); break; case 3: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); vevec = Data_Wrap_Struct(cgsl_eigen_vectors, 0, gsl_matrix_free, evec); gsl_eigen_gensymmv_free(w); break; } return rb_ary_new3(2, veval, vevec); } static VALUE rb_gsl_eigen_genherm(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *B = NULL; gsl_matrix_complex *Atmp = NULL, *Btmp = NULL; gsl_vector *eval = NULL; gsl_eigen_genherm_workspace *w = NULL; int flag; VALUE veval; flag = check_argv_genherm(argc, argv, obj, &A, &B, &eval, &w); Atmp = make_matrix_complex_clone(A); Btmp = make_matrix_complex_clone(B); gsl_eigen_genherm(Atmp, Btmp, eval, w); gsl_matrix_complex_free(Atmp); gsl_matrix_complex_free(Btmp); switch (flag) { case 0: veval = argv[2]; break; case 1: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); break; case 2: veval = argv[2]; gsl_eigen_genherm_free(w); break; case 3: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); gsl_eigen_genherm_free(w); break; } return veval; } static VALUE rb_gsl_eigen_genhermv(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *B = NULL; gsl_matrix_complex *Atmp = NULL, *Btmp = NULL; gsl_vector *eval = NULL; gsl_matrix_complex *evec = NULL; gsl_eigen_genhermv_workspace *w = NULL; int flag; VALUE veval, vevec; flag = check_argv_genhermv(argc, argv, obj, &A, &B, &eval, &evec, &w); Atmp = make_matrix_complex_clone(A); Btmp = make_matrix_complex_clone(B); gsl_eigen_genhermv(Atmp, Btmp, eval, evec, w); gsl_matrix_complex_free(Atmp); gsl_matrix_complex_free(Btmp); switch (flag) { case 0: veval = argv[2]; vevec = argv[3]; break; case 1: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); vevec = Data_Wrap_Struct(cgsl_eigen_herm_vectors, 0, gsl_matrix_complex_free, evec); break; case 2: veval = argv[2]; vevec = argv[3]; gsl_eigen_genhermv_free(w); break; case 3: veval = Data_Wrap_Struct(cgsl_eigen_values, 0, gsl_vector_free, eval); vevec = Data_Wrap_Struct(cgsl_eigen_herm_vectors, 0, gsl_matrix_complex_free, evec); gsl_eigen_genhermv_free(w); break; } return rb_ary_new3(2, veval, vevec); } static VALUE rb_gsl_eigen_gensymmv_sort(int argc, VALUE *argv, VALUE obj) { return rb_gsl_eigen_real_sort(argc, argv, obj, gsl_eigen_gensymmv_sort); } static VALUE rb_gsl_eigen_genhermv_sort(int argc, VALUE *argv, VALUE obj) { return rb_gsl_eigen_complex_sort(argc, argv, obj, gsl_eigen_genhermv_sort); } static VALUE rb_gsl_eigen_gen_alloc(VALUE klass, VALUE n) { gsl_eigen_gen_workspace *w; w = gsl_eigen_gen_alloc(FIX2INT(n)); return Data_Wrap_Struct(cgenw, 0, gsl_eigen_gen_free, w); } static VALUE rb_gsl_eigen_genv_alloc(VALUE klass, VALUE n) { gsl_eigen_genv_workspace *w; w = gsl_eigen_genv_alloc(FIX2INT(n)); return Data_Wrap_Struct(cgenvw, 0, gsl_eigen_genv_free, w); } static VALUE rb_gsl_eigen_gen_params(int argc, VALUE *argv, VALUE obj) { gsl_eigen_gen_workspace *w = NULL; int istart = 0; if (CLASS_OF(obj) == cgenw) { Data_Get_Struct(obj, gsl_eigen_gen_workspace, w); istart = 0; } else { if (argc != 4) rb_raise(rb_eArgError, "too few arguments (%d for 3)\n", argc); if (CLASS_OF(argv[3]) != cgenw) rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigen::Gen::Workspace expected)", rb_class2name(CLASS_OF(argv[3]))); Data_Get_Struct(argv[3], gsl_eigen_gen_workspace, w); istart = 1; } switch (argc - istart) { case 3: gsl_eigen_gen_params(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2]), w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments.\n"); } return Qtrue; } static int check_argv_gen(int argc, VALUE *argv, VALUE obj, gsl_matrix **A, gsl_matrix **B, gsl_vector_complex **alpha, gsl_vector **beta, gsl_eigen_gen_workspace **w) { int argc2 = argc; int flag = 0; if (CLASS_OF(obj) == cgenw) { Data_Get_Struct(obj, gsl_eigen_gen_workspace, *w); } else { if (rb_obj_is_kind_of(argv[argc-1], cgenw)) { Data_Get_Struct(argv[argc-1], gsl_eigen_gen_workspace, *w); argc2 = argc-1; } else { /* workspace is not given */ } } switch (argc2) { case 2: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; case 3: if (rb_obj_is_kind_of(argv[2], cgenw)) { Data_Get_Struct(argv[2], gsl_eigen_gen_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigen::Gen::Workspace expected)", rb_class2name(CLASS_OF(argv[2]))); } CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; case 5: if (rb_obj_is_kind_of(argv[4], cgenw)) { Data_Get_Struct(argv[4], gsl_eigen_gen_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigen::Gen::Workspace expected)", rb_class2name(CLASS_OF(argv[4]))); } CHECK_VECTOR_COMPLEX(argv[2]); Data_Get_Struct(argv[2], gsl_vector_complex, *alpha); CHECK_VECTOR(argv[3]); Data_Get_Struct(argv[3], gsl_vector, *beta); CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2, 3 or 5)", argc); } if (*alpha == NULL && *beta == NULL) { *alpha = gsl_vector_complex_alloc((*A)->size1); *beta = gsl_vector_alloc((*A)->size1); flag += 1; } if (*w == NULL) { *w = gsl_eigen_gen_alloc((*A)->size1); flag += 2; } return flag; } static VALUE rb_gsl_eigen_gen(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL; // gsl_matrix *Atmp = NULL, *Btmp = NULL; gsl_vector_complex *alpha = NULL; gsl_vector *beta = NULL; gsl_eigen_gen_workspace *w = NULL; int flag; VALUE valpha, vbeta; flag = check_argv_gen(argc, argv, obj, &A, &B, &alpha, &beta, &w); // Atmp = make_matrix_clone(A); // Btmp = make_matrix_clone(B); gsl_eigen_gen(A, B, alpha, beta, w); // gsl_matrix_free(Atmp); // gsl_matrix_free(Btmp); switch (flag) { case 0: valpha = argv[2]; vbeta = argv[3]; break; case 1: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); break; case 2: valpha = argv[2]; vbeta = argv[3]; gsl_eigen_gen_free(w); break; case 3: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); gsl_eigen_gen_free(w); break; } return rb_ary_new3(2, valpha, vbeta); } static VALUE rb_gsl_eigen_gen_QZ(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL; // gsl_matrix *Atmp = NULL, *Btmp = NULL; gsl_vector_complex *alpha = NULL; gsl_vector *beta = NULL; gsl_matrix *Q, *Z; gsl_eigen_gen_workspace *w = NULL; int flag; VALUE valpha, vbeta, vQ, vZ; flag = check_argv_gen(argc, argv, obj, &A, &B, &alpha, &beta, &w); /* Atmp = make_matrix_clone(A); Btmp = make_matrix_clone(B); */ Q = gsl_matrix_alloc(A->size1, A->size2); Z = gsl_matrix_alloc(A->size1, A->size2); // gsl_eigen_gen_QZ(Atmp, Btmp, alpha, beta, Q, Z, w); gsl_eigen_gen_QZ(A, B, alpha, beta, Q, Z, w); /* gsl_matrix_free(Atmp); gsl_matrix_free(Btmp); */ switch (flag) { case 0: valpha = argv[2]; vbeta = argv[3]; break; case 1: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); break; case 2: valpha = argv[2]; vbeta = argv[3]; gsl_eigen_gen_free(w); break; case 3: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); gsl_eigen_gen_free(w); break; } vQ = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Q); vZ = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Z); return rb_ary_new3(4, valpha, vbeta, vQ, vZ); } static int check_argv_genv(int argc, VALUE *argv, VALUE obj, gsl_matrix **A, gsl_matrix **B, gsl_vector_complex **alpha, gsl_vector **beta, gsl_matrix_complex **evec, gsl_eigen_genv_workspace **w) { int argc2 = argc; int flag = 0; if (CLASS_OF(obj) == cgenvw) { Data_Get_Struct(obj, gsl_eigen_genv_workspace, *w); } else { if (rb_obj_is_kind_of(argv[argc-1], cgenvw)) { Data_Get_Struct(argv[argc-1], gsl_eigen_genv_workspace, *w); argc2 = argc-1; } else { /* workspace is not given */ } } switch (argc2) { case 2: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; case 3: if (rb_obj_is_kind_of(argv[2], cgenvw)) { Data_Get_Struct(argv[2], gsl_eigen_genv_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigenv::Gen::Workspace expected)", rb_class2name(CLASS_OF(argv[2]))); } CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; case 6: if (rb_obj_is_kind_of(argv[4], cgenvw)) { Data_Get_Struct(argv[4], gsl_eigen_genv_workspace, *w); } else { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::Eigenv::Gen::Workspace expected)", rb_class2name(CLASS_OF(argv[4]))); } CHECK_VECTOR_COMPLEX(argv[2]); Data_Get_Struct(argv[2], gsl_vector_complex, *alpha); CHECK_VECTOR(argv[3]); Data_Get_Struct(argv[3], gsl_vector, *beta); CHECK_MATRIX_COMPLEX(argv[3]); Data_Get_Struct(argv[4], gsl_matrix_complex, *evec); CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, *A); Data_Get_Struct(argv[1], gsl_matrix, *B); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2, 3 or 6)", argc); } if (*alpha == NULL && *beta == NULL) { *alpha = gsl_vector_complex_alloc((*A)->size1); *beta = gsl_vector_alloc((*A)->size1); *evec = gsl_matrix_complex_alloc((*A)->size1, (*A)->size2); flag += 1; } if (*w == NULL) { *w = gsl_eigen_genv_alloc((*A)->size1); flag += 2; } return flag; } static VALUE rb_gsl_eigen_genv(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL; // gsl_matrix *Atmp = NULL, *Btmp = NULL; gsl_vector_complex *alpha = NULL; gsl_vector *beta = NULL; gsl_matrix_complex *evec = NULL; gsl_eigen_genv_workspace *w = NULL; int flag; VALUE valpha, vbeta, vevec; flag = check_argv_genv(argc, argv, obj, &A, &B, &alpha, &beta, &evec, &w); // Atmp = make_matrix_clone(A); // Btmp = make_matrix_clone(B); // gsl_eigen_genv(Atmp, Btmp, alpha, beta, evec, w); gsl_eigen_genv(A, B, alpha, beta, evec, w); // gsl_matrix_free(Atmp); // gsl_matrix_free(Btmp); switch (flag) { case 0: valpha = argv[2]; vbeta = argv[3]; vevec = argv[4]; break; case 1: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); vevec = Data_Wrap_Struct(cgsl_eigen_herm_vectors, 0, gsl_matrix_complex_free, evec); break; case 2: valpha = argv[2]; vbeta = argv[3]; vevec = argv[4]; gsl_eigen_genv_free(w); break; case 3: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); vevec = Data_Wrap_Struct(cgsl_eigen_herm_vectors, 0, gsl_matrix_complex_free, evec); gsl_eigen_genv_free(w); break; } return rb_ary_new3(3, valpha, vbeta, vevec); } static VALUE rb_gsl_eigen_genv_QZ(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL; // gsl_matrix *Atmp = NULL, *Btmp = NULL; gsl_vector_complex *alpha = NULL; gsl_vector *beta = NULL; gsl_matrix_complex *evec = NULL; gsl_matrix *Q, *Z; gsl_eigen_genv_workspace *w = NULL; int flag; VALUE valpha, vbeta, vevec, vQ, vZ; flag = check_argv_genv(argc, argv, obj, &A, &B, &alpha, &beta, &evec, &w); /* Atmp = make_matrix_clone(A); Btmp = make_matrix_clone(B); */ Q = gsl_matrix_alloc(A->size1, A->size2); Z = gsl_matrix_alloc(A->size1, A->size2); // gsl_eigen_genv_QZ(Atmp, Btmp, alpha, beta, evec, Q, Z, w); gsl_eigen_genv_QZ(A, B, alpha, beta, evec, Q, Z, w); /* gsl_matrix_free(Atmp); gsl_matrix_free(Btmp); */ switch (flag) { case 0: valpha = argv[2]; vbeta = argv[3]; vevec = argv[4]; break; case 1: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); vevec = Data_Wrap_Struct(cgsl_eigen_herm_vectors, 0, gsl_matrix_complex_free, evec); break; case 2: valpha = argv[2]; vbeta = argv[3]; vevec = argv[4]; gsl_eigen_genv_free(w); break; case 3: valpha = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, alpha); vbeta = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, beta); vevec = Data_Wrap_Struct(cgsl_eigen_herm_vectors, 0, gsl_matrix_complex_free, evec); gsl_eigen_genv_free(w); break; } vQ = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Q); vZ = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Z); return rb_ary_new3(5, valpha, vbeta, vevec, vQ, vZ); } static VALUE rb_gsl_eigen_genv_sort(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *alpha = NULL; gsl_vector *beta = NULL; gsl_matrix_complex *evec = NULL; gsl_eigen_sort_t type = GSL_EIGEN_SORT_VAL_DESC; switch (argc) { case 4: CHECK_FIXNUM(argv[3]); type = FIX2INT(argv[3]); /* no break, do next */ case 3: if (argv[0] == Qnil) { alpha = NULL; } else { CHECK_VECTOR_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_vector_complex, alpha); } if (argv[1] == Qnil) { beta = NULL; } else { CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, beta); } if (argv[2] == Qnil) { evec = NULL; } else { CHECK_MATRIX_COMPLEX(argv[2]); Data_Get_Struct(argv[2], gsl_matrix_complex, evec); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); } return INT2FIX(gsl_eigen_genv_sort(alpha, beta, evec, type)); } #endif void Init_gsl_eigen(VALUE module) { VALUE mgsl_eigen; VALUE mgsl_eigen_symm; VALUE mgsl_eigen_symmv; VALUE mgsl_eigen_herm; VALUE mgsl_eigen_hermv; #ifdef HAVE_EIGEN_FRANCIS VALUE mgsl_eigen_francis; #endif #ifdef GSL_1_9_LATER VALUE mgsl_eigen_nonsymmv; VALUE mgsl_eigen_nonsymm; #endif mgsl_eigen = rb_define_module_under(module, "Eigen"); mgsl_eigen_symm = rb_define_module_under(mgsl_eigen, "Symm"); mgsl_eigen_symmv = rb_define_module_under(mgsl_eigen, "Symmv"); mgsl_eigen_herm = rb_define_module_under(mgsl_eigen, "Herm"); mgsl_eigen_hermv = rb_define_module_under(mgsl_eigen, "Hermv"); cgsl_eigen_values = rb_define_class_under(mgsl_eigen, "EigenValues", cgsl_vector); cgsl_eigen_vectors = rb_define_class_under(mgsl_eigen, "EigenVectors", cgsl_matrix); cgsl_eigen_vector = rb_define_class_under(mgsl_eigen, "EigenVector", cgsl_vector); cgsl_eigen_herm_vectors = rb_define_class_under(mgsl_eigen, "ComplexEigenVectors", cgsl_matrix_complex); cgsl_eigen_vector_complex = rb_define_class_under(mgsl_eigen, "ComplexEigenVector", cgsl_vector_complex); cgsl_eigen_symm_workspace = rb_define_class_under(mgsl_eigen_symm, "Workspace", cGSL_Object); cgsl_eigen_symmv_workspace = rb_define_class_under(mgsl_eigen_symmv, "Workspace", cGSL_Object); cgsl_eigen_herm_workspace = rb_define_class_under(mgsl_eigen_herm, "Workspace", cGSL_Object); cgsl_eigen_hermv_workspace = rb_define_class_under(mgsl_eigen_hermv, "Workspace", cGSL_Object); rb_define_singleton_method(cgsl_eigen_symm_workspace, "alloc", rb_gsl_eigen_symm_alloc, 1); rb_define_singleton_method(cgsl_eigen_symmv_workspace, "alloc", rb_gsl_eigen_symmv_alloc, 1); rb_define_singleton_method(cgsl_eigen_herm_workspace, "alloc", rb_gsl_eigen_herm_alloc, 1); rb_define_singleton_method(cgsl_eigen_hermv_workspace, "alloc", rb_gsl_eigen_hermv_alloc, 1); rb_define_singleton_method(mgsl_eigen_symm, "alloc", rb_gsl_eigen_symm_alloc, 1); rb_define_singleton_method(mgsl_eigen_symmv, "alloc", rb_gsl_eigen_symmv_alloc, 1); rb_define_singleton_method(mgsl_eigen_herm, "alloc", rb_gsl_eigen_herm_alloc, 1); rb_define_singleton_method(mgsl_eigen_hermv, "alloc", rb_gsl_eigen_hermv_alloc, 1); rb_define_module_function(mgsl_eigen, "symm", rb_gsl_eigen_symm, -1); rb_define_module_function(mgsl_eigen, "symmv", rb_gsl_eigen_symmv, -1); rb_define_module_function(mgsl_eigen, "herm", rb_gsl_eigen_herm, -1); rb_define_module_function(mgsl_eigen, "hermv", rb_gsl_eigen_hermv, -1); rb_define_module_function(module, "eigen_symm", rb_gsl_eigen_symm, -1); rb_define_module_function(module, "eigen_symmv", rb_gsl_eigen_symmv, -1); rb_define_module_function(module, "eigen_herm", rb_gsl_eigen_herm, -1); rb_define_module_function(module, "eigen_hermv", rb_gsl_eigen_hermv, -1); rb_define_method(cgsl_matrix, "eigen_symm", rb_gsl_eigen_symm, -1); rb_define_method(cgsl_matrix, "eigen_symmv", rb_gsl_eigen_symmv, -1); rb_define_method(cgsl_matrix_complex, "eigen_herm", rb_gsl_eigen_herm, -1); rb_define_method(cgsl_matrix_complex, "eigen_hermv", rb_gsl_eigen_hermv, -1); rb_define_method(cgsl_eigen_vectors, "unpack", rb_gsl_eigen_vectors_unpack, 0); rb_define_method(cgsl_eigen_herm_vectors, "unpack", rb_gsl_eigen_vectors_complex_unpack, 0); rb_gsl_eigen_define_const(module, mgsl_eigen); rb_define_module_function(mgsl_eigen, "symmv_sort", rb_gsl_eigen_symmv_sort, -1); rb_define_module_function(mgsl_eigen, "hermv_sort", rb_gsl_eigen_hermv_sort, -1); rb_define_module_function(mgsl_eigen_symmv, "sort", rb_gsl_eigen_symmv_sort, -1); rb_define_module_function(mgsl_eigen_hermv, "sort", rb_gsl_eigen_hermv_sort, -1); #ifdef HAVE_EIGEN_FRANCIS mgsl_eigen_francis = rb_define_module_under(mgsl_eigen, "francis"); cgsl_eigen_francis_workspace = rb_define_class_under(mgsl_eigen_francis, "Workspace", cGSL_Object); rb_define_singleton_method(cgsl_eigen_francis_workspace, "alloc", rb_gsl_eigen_francis_alloc, 0); rb_define_method(cgsl_matrix, "eigen_francis", rb_gsl_eigen_francis, -1); rb_define_module_function(mgsl_eigen, "francis", rb_gsl_eigen_francis, -1); rb_define_module_function(module, "eigen_francis", rb_gsl_eigen_francis, -1); rb_define_method(cgsl_matrix, "eigen_francis_Z", rb_gsl_eigen_francis_Z, -1); rb_define_module_function(mgsl_eigen, "francis_Z", rb_gsl_eigen_francis_Z, -1); rb_define_module_function(module, "eigen_francis_Z", rb_gsl_eigen_francis_Z, -1); rb_define_method(cgsl_eigen_francis_workspace, "T", rb_gsl_eigen_francis_T, -1); rb_define_module_function(mgsl_eigen_francis, "T", rb_gsl_eigen_francis_T, -1); #endif #ifdef GSL_1_9_LATER mgsl_eigen_nonsymm = rb_define_module_under(mgsl_eigen, "Nonsymm"); mgsl_eigen_nonsymmv = rb_define_module_under(mgsl_eigen, "Nonsymmv"); cgsl_eigen_nonsymm_workspace = rb_define_class_under(mgsl_eigen_nonsymm, "Workspace", cGSL_Object); rb_define_singleton_method(cgsl_eigen_nonsymm_workspace, "alloc", rb_gsl_eigen_nonsymm_alloc, 1); rb_define_singleton_method(mgsl_eigen_nonsymm, "alloc", rb_gsl_eigen_nonsymm_alloc, 1); rb_define_method(cgsl_matrix, "eigen_nonsymm", rb_gsl_eigen_nonsymm, -1); rb_define_module_function(mgsl_eigen, "nonsymm", rb_gsl_eigen_nonsymm, -1); rb_define_module_function(module, "eigen_nonsymm", rb_gsl_eigen_nonsymm, -1); rb_define_method(cgsl_matrix, "eigen_nonsymm_Z", rb_gsl_eigen_nonsymm_Z, -1); rb_define_module_function(mgsl_eigen, "nonsymm_Z", rb_gsl_eigen_nonsymm_Z, -1); rb_define_module_function(module, "eigen_nonsymm_Z", rb_gsl_eigen_nonsymm_Z, -1); rb_define_method(cgsl_eigen_nonsymm_workspace, "params", rb_gsl_eigen_nonsymm_params, -1); rb_define_module_function(mgsl_eigen_nonsymm, "params", rb_gsl_eigen_nonsymm_params, -1); cgsl_eigen_nonsymmv_workspace = rb_define_class_under(mgsl_eigen_nonsymmv, "Workspace", cGSL_Object); rb_define_singleton_method(cgsl_eigen_nonsymmv_workspace, "alloc", rb_gsl_eigen_nonsymmv_alloc, 1); rb_define_singleton_method(mgsl_eigen_nonsymmv, "alloc", rb_gsl_eigen_nonsymmv_alloc, 1); rb_define_method(cgsl_matrix, "eigen_nonsymmv", rb_gsl_eigen_nonsymmv, -1); rb_define_module_function(mgsl_eigen, "nonsymmv", rb_gsl_eigen_nonsymmv, -1); rb_define_module_function(module, "eigen_nonsymmv", rb_gsl_eigen_nonsymmv, -1); rb_define_method(cgsl_matrix, "eigen", rb_gsl_eigen_nonsymmv, -1); rb_define_alias(cgsl_matrix, "eig", "eigen"); rb_define_method(cgsl_matrix, "eigen_nonsymmv_Z", rb_gsl_eigen_nonsymmv_Z, -1); rb_define_module_function(mgsl_eigen, "nonsymmv_Z", rb_gsl_eigen_nonsymmv_Z, -1); rb_define_module_function(module, "eigen_nonsymmv_Z", rb_gsl_eigen_nonsymmv_Z, -1); rb_define_module_function(mgsl_eigen, "nonsymmv_sort", rb_gsl_eigen_nonsymmv_sort, -1); rb_define_module_function(mgsl_eigen_nonsymmv, "sort", rb_gsl_eigen_nonsymmv_sort, -1); rb_define_module_function(module, "eigen_nonsymmv_sort", rb_gsl_eigen_nonsymmv_sort, -1); #endif #ifdef GSL_1_10_LATER /** gensymm, gensymmv **/ mgensymm = rb_define_module_under(mgsl_eigen, "Gensymm"); cgensymm = rb_define_class_under(mgensymm, "Workspace", cGSL_Object); mgensymmv = rb_define_module_under(mgsl_eigen, "Gensymmv"); cgensymmv = rb_define_class_under(mgensymmv, "Workspace", cGSL_Object); rb_define_singleton_method(cgensymm, "alloc", rb_gsl_eigen_gensymm_alloc, 1); rb_define_singleton_method(cgensymmv, "alloc", rb_gsl_eigen_gensymmv_alloc, 1); rb_define_singleton_method(mgensymm, "alloc", rb_gsl_eigen_gensymm_alloc, 1); rb_define_singleton_method(mgensymmv, "alloc", rb_gsl_eigen_gensymmv_alloc, 1); rb_define_method(cgensymm, "gensymm", rb_gsl_eigen_gensymm, -1); rb_define_module_function(module, "eigen_gensymm", rb_gsl_eigen_gensymm, -1); rb_define_module_function(mgsl_eigen, "gensymm", rb_gsl_eigen_gensymm, -1); rb_define_module_function(mgensymm, "gensymm", rb_gsl_eigen_gensymm, -1); rb_define_method(cgensymmv, "gensymmv", rb_gsl_eigen_gensymmv, -1); rb_define_module_function(module, "eigen_gensymmv", rb_gsl_eigen_gensymmv, -1); rb_define_module_function(mgsl_eigen, "gensymmv", rb_gsl_eigen_gensymmv, -1); rb_define_module_function(mgensymmv, "gensymmv", rb_gsl_eigen_gensymmv, -1); rb_define_module_function(mgsl_eigen, "gensymmv_sort", rb_gsl_eigen_gensymmv_sort, -1); rb_define_module_function(mgensymmv, "sort", rb_gsl_eigen_gensymmv_sort, -1); rb_define_module_function(module, "eigen_gensymmv_sort", rb_gsl_eigen_gensymmv_sort, -1); /** genherm, genhermv **/ mgenherm = rb_define_module_under(mgsl_eigen, "Genherm"); cgenherm = rb_define_class_under(mgenherm, "Workspace", cGSL_Object); mgenhermv = rb_define_module_under(mgsl_eigen, "Genhermv"); cgenhermv = rb_define_class_under(mgenhermv, "Workspace", cGSL_Object); rb_define_singleton_method(cgenherm, "alloc", rb_gsl_eigen_genherm_alloc, 1); rb_define_singleton_method(cgenhermv, "alloc", rb_gsl_eigen_genhermv_alloc, 1); rb_define_singleton_method(mgenherm, "alloc", rb_gsl_eigen_genherm_alloc, 1); rb_define_singleton_method(mgenhermv, "alloc", rb_gsl_eigen_genhermv_alloc, 1); rb_define_method(cgenherm, "genherm", rb_gsl_eigen_genherm, -1); rb_define_module_function(module, "eigen_genherm", rb_gsl_eigen_genherm, -1); rb_define_module_function(mgsl_eigen, "genherm", rb_gsl_eigen_genherm, -1); rb_define_module_function(mgenherm, "genherm", rb_gsl_eigen_genherm, -1); rb_define_method(cgenhermv, "genhermv", rb_gsl_eigen_genhermv, -1); rb_define_module_function(module, "eigen_genhermv", rb_gsl_eigen_genhermv, -1); rb_define_module_function(mgsl_eigen, "genhermv", rb_gsl_eigen_genhermv, -1); rb_define_module_function(mgenhermv, "genhermv", rb_gsl_eigen_genhermv, -1); rb_define_module_function(mgsl_eigen, "genhermv_sort", rb_gsl_eigen_genhermv_sort, -1); rb_define_module_function(mgenhermv, "sort", rb_gsl_eigen_genhermv_sort, -1); rb_define_module_function(module, "eigen_genhermv_sort", rb_gsl_eigen_genhermv_sort, -1); /* gen */ mgen = rb_define_module_under(mgsl_eigen, "Gen"); mgenv = rb_define_module_under(mgsl_eigen, "Genv"); cgenw = rb_define_class_under(mgen, "Workspace", cGSL_Object); cgenvw = rb_define_class_under(mgenv, "Workspace", cGSL_Object); rb_define_singleton_method(mgen, "alloc", rb_gsl_eigen_gen_alloc, 1); rb_define_singleton_method(cgenw, "alloc", rb_gsl_eigen_gen_alloc, 1); rb_define_singleton_method(mgenv, "alloc", rb_gsl_eigen_genv_alloc, 1); rb_define_singleton_method(cgenvw, "alloc", rb_gsl_eigen_genv_alloc, 1); rb_define_module_function(mgen, "params", rb_gsl_eigen_gen_params, -1); rb_define_method(cgenw, "params", rb_gsl_eigen_gen_params, -1); rb_define_module_function(mgsl_eigen, "gen_params", rb_gsl_eigen_gen_params, -1); rb_define_module_function(mgen, "gen", rb_gsl_eigen_gen, -1); rb_define_module_function(mgsl_eigen, "gen", rb_gsl_eigen_gen, -1); rb_define_method(cgenw, "gen", rb_gsl_eigen_gen, -1); rb_define_module_function(mgenv, "genv", rb_gsl_eigen_genv, -1); rb_define_module_function(mgsl_eigen, "genv", rb_gsl_eigen_genv, -1); rb_define_method(cgenvw, "genv", rb_gsl_eigen_genv, -1); rb_define_module_function(mgen, "gen_QZ", rb_gsl_eigen_gen_QZ, -1); rb_define_module_function(mgsl_eigen, "gen_QZ", rb_gsl_eigen_gen_QZ, -1); rb_define_method(cgenw, "gen_QZ", rb_gsl_eigen_gen_QZ, -1); rb_define_module_function(mgenv, "genv_QZ", rb_gsl_eigen_genv_QZ, -1); rb_define_module_function(mgsl_eigen, "genv_QZ", rb_gsl_eigen_genv_QZ, -1); rb_define_method(cgenvw, "genv_QZ", rb_gsl_eigen_genv_QZ, -1); rb_define_module_function(mgsl_eigen, "genv_sort", rb_gsl_eigen_genv_sort, -1); rb_define_module_function(mgenv, "sort", rb_gsl_eigen_genv_sort, -1); rb_define_module_function(module, "eigen_genv_sort", rb_gsl_eigen_genv_sort, -1); #endif } gsl-1.15.3/ext/sf_log.c0000644000175000017500000000626712220252463014172 0ustar boutilboutil/* sf_log.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_log(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) return rb_gsl_math_complex_eval(gsl_complex_log, x); return rb_gsl_sf_eval1(gsl_sf_log, x); } static VALUE rb_gsl_sf_log10(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) return rb_gsl_math_complex_eval(gsl_complex_log10, x); return rb_gsl_sf_eval1(log10, x); } static VALUE rb_gsl_sf_log_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_log_e, x); } static VALUE rb_gsl_sf_log_abs(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_log_abs, x); } static VALUE rb_gsl_sf_log_abs_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_log_abs_e, x); } static VALUE rb_gsl_sf_complex_log_e(int argc, VALUE *argv, VALUE obj) { gsl_sf_result *rslt1 = NULL, *rslt2 = NULL; gsl_complex *z = NULL; VALUE vlnr, vtheta; double re, im; // local variable "status" was defined and set, but never used //int status; switch (argc) { case 1: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, z); re = GSL_REAL(*z); im = GSL_IMAG(*z); break; case 2: Need_Float(argv[0]); Need_Float(argv[1]); re = NUM2DBL(argv[0]); im = NUM2DBL(argv[1]); default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } vlnr = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt1); vtheta = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt2); /*status =*/ gsl_sf_complex_log_e(re, im, rslt1, rslt2); return rb_ary_new3(2, vlnr, vtheta); } static VALUE rb_gsl_sf_log_1plusx(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_log_1plusx, x); } static VALUE rb_gsl_sf_log_1plusx_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_log_1plusx_e, x); } static VALUE rb_gsl_sf_log_1plusx_mx(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_log_1plusx_mx, x); } static VALUE rb_gsl_sf_log_1plusx_mx_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_log_1plusx_mx_e, x); } void Init_gsl_sf_log(VALUE module) { rb_define_module_function(module, "log", rb_gsl_sf_log, 1); rb_define_module_function(module, "log10", rb_gsl_sf_log10, 1); rb_define_module_function(module, "log_e", rb_gsl_sf_log_e, 1); rb_define_module_function(module, "log_abs", rb_gsl_sf_log_abs, 1); rb_define_module_function(module, "log_abs_e", rb_gsl_sf_log_abs_e, 1); rb_define_module_function(module, "complex_log_e", rb_gsl_sf_complex_log_e, -1); rb_define_module_function(module, "log_1plusx", rb_gsl_sf_log_1plusx, 1); rb_define_module_function(module, "log_1plusx_e", rb_gsl_sf_log_1plusx_e, 1); rb_define_module_function(module, "log_1plusx_mx", rb_gsl_sf_log_1plusx_mx, 1); rb_define_module_function(module, "log_1plusx_mx_e", rb_gsl_sf_log_1plusx_mx_e, 1); } gsl-1.15.3/ext/ndlinear.c0000644000175000017500000002346312220252463014512 0ustar boutilboutil#include "rb_gsl.h" #ifdef HAVE_NDLINEAR_GSL_MULTIFIT_NDLINEAR_H #include #include #include #include #include static VALUE cWorkspace; enum Index_Ndlinear { INDEX_NDIM = 0, INDEX_N = 1, INDEX_PROCS = 2, INDEX_PARAMS = 3, INDEX_FUNCS = 4, INDEX_NDIM_I = 5, NDLINEAR_ARY_SIZE = 6, }; static void multifit_ndlinear_mark(gsl_multifit_ndlinear_workspace *w) { rb_gc_mark((VALUE) w->params); } typedef int (*UFUNC)(double, double[], void*); typedef struct ufunc_struct { UFUNC *fptr; } ufunc_struct; static VALUE cUFunc; static ufunc_struct* ufunc_struct_alloc(size_t n_dim) { ufunc_struct *p; p = (ufunc_struct*) malloc(sizeof(ufunc_struct)); p->fptr = malloc(sizeof(UFUNC)*n_dim); return p; } static void ufunc_struct_free(ufunc_struct *p) { free(p->fptr); free(p); } static int func_u(double x, double y[], void *data); static VALUE rb_gsl_multifit_ndlinear_alloc(int argc, VALUE *argv, VALUE klass) { gsl_multifit_ndlinear_workspace *w; int istart = 0; size_t n_dim = 0, *N, i; struct ufunc_struct *p; VALUE params, wspace, pp; switch (argc) { case 4: istart = 1; CHECK_FIXNUM(argv[0]); n_dim = FIX2INT(argv[0]); /* no break */ case 3: if (TYPE(argv[istart]) != T_ARRAY) { rb_raise(rb_eTypeError, "Wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[istart]))); } if (TYPE(argv[istart+1]) != T_ARRAY) { rb_raise(rb_eTypeError, "Wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[istart+1]))); } // n_dim = RARRAY(argv[istart])->len; n_dim = RARRAY_LEN(argv[istart]); N = (size_t*) malloc(sizeof(size_t)*n_dim); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 3 or 4)", argc); } for (i = 0; i < n_dim; i++) { N[i] = FIX2INT(rb_ary_entry(argv[istart], i)); } params = rb_ary_new2(NDLINEAR_ARY_SIZE); rb_ary_store(params, INDEX_NDIM, INT2FIX((int) n_dim)); rb_ary_store(params, INDEX_N, argv[istart]); /* N */ rb_ary_store(params, INDEX_PROCS, argv[istart+1]); /* procs */ rb_ary_store(params, INDEX_PARAMS, argv[istart+2]); /* params */ rb_ary_store(params, INDEX_NDIM_I, INT2FIX(0)); /* for the first parameter */ p = ufunc_struct_alloc(n_dim); for (i = 0; i < n_dim; i++) p->fptr[i] = func_u; pp = Data_Wrap_Struct(cUFunc, 0, ufunc_struct_free, p); rb_ary_store(params, INDEX_FUNCS, pp); w = gsl_multifit_ndlinear_alloc(n_dim, N, p->fptr, (void*) params); free((size_t*) N); wspace = Data_Wrap_Struct(cWorkspace, multifit_ndlinear_mark, gsl_multifit_ndlinear_free, w); return wspace; } static int func_u(double x, double y[], void *data) { VALUE ary, vN, procs, proc, vy, params; gsl_vector_view ytmp; size_t i, n_dim; int rslt; ary = (VALUE) data; n_dim = FIX2INT(rb_ary_entry(ary, INDEX_NDIM)); vN = rb_ary_entry(ary, INDEX_N); procs = rb_ary_entry(ary, INDEX_PROCS); params = rb_ary_entry(ary, INDEX_PARAMS); i = FIX2INT(rb_ary_entry(ary, INDEX_NDIM_I)); proc = rb_ary_entry(procs, i); ytmp.vector.data = (double*) y; ytmp.vector.stride = 1; ytmp.vector.size = FIX2INT(rb_ary_entry(vN, i)); vy = Data_Wrap_Struct(cgsl_vector_view, 0, NULL, &ytmp); rslt = rb_funcall((VALUE) proc, RBGSL_ID_call, 3, rb_float_new(x), vy, params); /* for the next parameter */ i += 1; if (i == n_dim) i = 0; rb_ary_store(ary, INDEX_NDIM_I, INT2FIX(i)); return GSL_SUCCESS; } static VALUE rb_gsl_multifit_ndlinear_design(int argc, VALUE *argv, VALUE obj) { gsl_multifit_ndlinear_workspace *w; gsl_matrix *vars = NULL, *X = NULL; int argc2, flag = 0, ret; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (!rb_obj_is_kind_of(argv[argc-1], cWorkspace)) { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::MultiFit::Ndlinear::Workspace expected)", rb_class2name(CLASS_OF(argv[argc-1]))); } Data_Get_Struct(argv[argc-1], gsl_multifit_ndlinear_workspace, w); argc2 = argc-1; break; default: Data_Get_Struct(obj, gsl_multifit_ndlinear_workspace, w); argc2 = argc; } switch (argc2) { case 1: CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, vars); X = gsl_matrix_alloc(vars->size1, w->n_coeffs); flag = 1; break; case 2: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, vars); Data_Get_Struct(argv[1], gsl_matrix, X); break; default: rb_raise(rb_eArgError, "Wrong number of arguments."); } ret = gsl_multifit_ndlinear_design(vars, X, w); if (flag == 1) { return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, X); } else { return INT2FIX(ret); } } static VALUE rb_gsl_multifit_ndlinear_est(int argc, VALUE *argv, VALUE obj) { gsl_multifit_ndlinear_workspace *w; gsl_vector *x = NULL, *c = NULL; gsl_matrix *cov = NULL; double y, yerr; int argc2; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (!rb_obj_is_kind_of(argv[argc-1], cWorkspace)) { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::MultiFit::Ndlinear::Workspace expected)", rb_class2name(CLASS_OF(argv[argc-1]))); } Data_Get_Struct(argv[argc-1], gsl_multifit_ndlinear_workspace, w); argc2 = argc-1; break; default: Data_Get_Struct(obj, gsl_multifit_ndlinear_workspace, w); argc2 = argc; } switch (argc2) { case 3: CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); CHECK_MATRIX(argv[2]); Data_Get_Struct(argv[0], gsl_vector, x); Data_Get_Struct(argv[1], gsl_vector, c); Data_Get_Struct(argv[2], gsl_matrix, cov); break; default: rb_raise(rb_eArgError, "Wrong number of arguments."); } gsl_multifit_ndlinear_est(x, c, cov, &y, &yerr, w); return rb_ary_new3(2, rb_float_new(y), rb_float_new(yerr)); } static VALUE rb_gsl_multifit_ndlinear_calc(int argc, VALUE *argv, VALUE obj) { gsl_multifit_ndlinear_workspace *w; gsl_vector *x = NULL, *c = NULL; double val; int argc2; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (!rb_obj_is_kind_of(argv[argc-1], cWorkspace)) { rb_raise(rb_eTypeError, "Wrong argument type %s (GSL::MultiFit::Ndlinear::Workspace expected)", rb_class2name(CLASS_OF(argv[argc-1]))); } Data_Get_Struct(argv[argc-1], gsl_multifit_ndlinear_workspace, w); argc2 = argc-1; break; default: Data_Get_Struct(obj, gsl_multifit_ndlinear_workspace, w); argc2 = argc; } switch (argc2) { case 2: CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_vector, x); Data_Get_Struct(argv[1], gsl_vector, c); break; default: rb_raise(rb_eArgError, "Wrong number of arguments."); } val = gsl_multifit_ndlinear_calc(x, c, w); return rb_float_new(val); } static VALUE rb_gsl_multifit_ndlinear_n_coeffs(VALUE obj) { gsl_multifit_ndlinear_workspace *w; Data_Get_Struct(obj, gsl_multifit_ndlinear_workspace, w); return INT2FIX(w->n_coeffs); } static VALUE rb_gsl_multifit_ndlinear_n_dim(VALUE obj) { gsl_multifit_ndlinear_workspace *w; Data_Get_Struct(obj, gsl_multifit_ndlinear_workspace, w); return INT2FIX(w->n_dim); } static VALUE rb_gsl_multifit_ndlinear_N(VALUE obj) { gsl_multifit_ndlinear_workspace *w; VALUE ary; Data_Get_Struct(obj, gsl_multifit_ndlinear_workspace, w); ary = (VALUE) w->params; return rb_ary_entry(ary, INDEX_N); } /* static VALUE rb_gsl_multifit_linear_Rsq(VALUE module, VALUE vy, VALUE vchisq) { gsl_vector *y; double chisq, Rsq; CHECK_VECTOR(vy); Data_Get_Struct(vy, gsl_vector, y); chisq = NUM2DBL(vchisq); gsl_multifit_linear_Rsq(y, chisq, &Rsq); return rb_float_new(Rsq); } */ void Init_ndlinear(VALUE module) { VALUE mNdlinear; mNdlinear = rb_define_module_under(module, "Ndlinear"); cUFunc = rb_define_class_under(mNdlinear, "UFunc", rb_cObject); cWorkspace = rb_define_class_under(mNdlinear, "Workspace", cGSL_Object); rb_define_singleton_method(mNdlinear, "alloc", rb_gsl_multifit_ndlinear_alloc, -1); rb_define_singleton_method(cWorkspace, "alloc", rb_gsl_multifit_ndlinear_alloc, -1); rb_define_singleton_method(mNdlinear, "design", rb_gsl_multifit_ndlinear_design, -1); rb_define_singleton_method(cWorkspace, "design", rb_gsl_multifit_ndlinear_design, -1); rb_define_method(cWorkspace, "design",rb_gsl_multifit_ndlinear_est, -1); rb_define_singleton_method(mNdlinear, "est", rb_gsl_multifit_ndlinear_est, -1); rb_define_singleton_method(cWorkspace, "est", rb_gsl_multifit_ndlinear_est, -1); rb_define_method(cWorkspace, "est",rb_gsl_multifit_ndlinear_est, -1); rb_define_singleton_method(mNdlinear, "calc", rb_gsl_multifit_ndlinear_calc, -1); rb_define_singleton_method(cWorkspace, "calc", rb_gsl_multifit_ndlinear_calc, -1); rb_define_method(cWorkspace, "calc",rb_gsl_multifit_ndlinear_calc, -1); rb_define_method(cWorkspace, "n_coeffs",rb_gsl_multifit_ndlinear_n_coeffs, 0); rb_define_method(cWorkspace, "n_dim",rb_gsl_multifit_ndlinear_n_dim, 0); rb_define_method(cWorkspace, "N",rb_gsl_multifit_ndlinear_N, 0); // rb_define_module_function(module, "linear_Rsq", rb_gsl_multifit_linear_Rsq, 2); } #endif gsl-1.15.3/ext/sf_bessel.c0000644000175000017500000010316212220252463014656 0ustar boutilboutil/* sf_bessel.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" EXTERN VALUE cgsl_vector; /* Cylindrical Bessel Functions */ static VALUE rb_gsl_sf_bessel_J0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_J0, x); } static VALUE rb_gsl_sf_bessel_J0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_J0_e, x); } static VALUE rb_gsl_sf_bessel_J1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_J1, x); } static VALUE rb_gsl_sf_bessel_J1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_J1_e, x); } static VALUE rb_gsl_sf_bessel_Jn(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_Jn, n, x); } static VALUE rb_gsl_sf_bessel_Jn_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_Jn_e, n, x); } static VALUE rb_gsl_sf_bessel_Xn_array(VALUE obj, VALUE n0, VALUE n1, VALUE x, int (*f)(int, int, double, double[])) { int nmin, nmax, n; gsl_vector *v = NULL; CHECK_FIXNUM(n0); CHECK_FIXNUM(n1); Need_Float(x); nmin = FIX2INT(n0); nmax = FIX2INT(n1); n = nmax - nmin + 1; v = gsl_vector_alloc(n); (*f)(nmin, nmax, NUM2DBL(x), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_sf_bessel_Jn_array(VALUE obj, VALUE n0, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_Xn_array(obj, n0, n1, x, gsl_sf_bessel_Jn_array); } /* Irregular Cylindrical Bessel Functions */ static VALUE rb_gsl_sf_bessel_Y0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_Y0, x); } static VALUE rb_gsl_sf_bessel_Y0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_Y0_e, x); } static VALUE rb_gsl_sf_bessel_Y1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_Y1, x); } static VALUE rb_gsl_sf_bessel_Y1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_Y1_e, x); } static VALUE rb_gsl_sf_bessel_Yn(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_Yn, n, x); } static VALUE rb_gsl_sf_bessel_Yn_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_Yn_e, n, x); } static VALUE rb_gsl_sf_bessel_Yn_array(VALUE obj, VALUE n0, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_Xn_array(obj, n0, n1, x, gsl_sf_bessel_Yn_array); } /* Regular Modified Cylindrical Bessel Functions */ static VALUE rb_gsl_sf_bessel_I0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_I0, x); } static VALUE rb_gsl_sf_bessel_I0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_I0_e, x); } static VALUE rb_gsl_sf_bessel_I1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_I1, x); } static VALUE rb_gsl_sf_bessel_I1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_I1_e, x); } static VALUE rb_gsl_sf_bessel_In(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_In, n, x); } static VALUE rb_gsl_sf_bessel_In_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_In_e, n, x); } static VALUE rb_gsl_sf_bessel_In_array(VALUE obj, VALUE n0, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_Xn_array(obj, n0, n1, x, gsl_sf_bessel_In_array); } static VALUE rb_gsl_sf_bessel_I0_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_I0_scaled, x); } static VALUE rb_gsl_sf_bessel_I0_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_I0_scaled_e, x); } static VALUE rb_gsl_sf_bessel_I1_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_I1_scaled, x); } static VALUE rb_gsl_sf_bessel_I1_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_I1_scaled_e, x); } static VALUE rb_gsl_sf_bessel_In_scaled(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_In_scaled, n, x); } static VALUE rb_gsl_sf_bessel_In_scaled_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_In_scaled_e, n, x); } static VALUE rb_gsl_sf_bessel_In_scaled_array(VALUE obj, VALUE n0, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_Xn_array(obj, n0, n1, x, gsl_sf_bessel_In_scaled_array); } /* Irregular Modified Cylindrical Bessel Functions */ static VALUE rb_gsl_sf_bessel_K0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_K0, x); } static VALUE rb_gsl_sf_bessel_K0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_K0_e, x); } static VALUE rb_gsl_sf_bessel_K1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_K1, x); } static VALUE rb_gsl_sf_bessel_K1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_K1_e, x); } static VALUE rb_gsl_sf_bessel_Kn(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_Kn, n, x); } static VALUE rb_gsl_sf_bessel_Kn_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_Kn_e, n, x); } static VALUE rb_gsl_sf_bessel_Kn_array(VALUE obj, VALUE n0, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_Xn_array(obj, n0, n1, x, gsl_sf_bessel_Kn_array); } static VALUE rb_gsl_sf_bessel_K0_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_K0_scaled, x); } static VALUE rb_gsl_sf_bessel_K0_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_K0_scaled_e, x); } static VALUE rb_gsl_sf_bessel_K1_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_K1_scaled, x); } static VALUE rb_gsl_sf_bessel_K1_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_K1_scaled_e, x); } static VALUE rb_gsl_sf_bessel_Kn_scaled(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_Kn_scaled, n, x); } static VALUE rb_gsl_sf_bessel_Kn_scaled_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_Kn_scaled_e, n, x); } static VALUE rb_gsl_sf_bessel_Kn_scaled_array(VALUE obj, VALUE n0, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_Xn_array(obj, n0, n1, x, gsl_sf_bessel_Kn_scaled_array); } /* Spherical Bessel Functions */ static VALUE rb_gsl_sf_bessel_j0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_j0, x); } static VALUE rb_gsl_sf_bessel_j0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_j0_e, x); } static VALUE rb_gsl_sf_bessel_j1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_j1, x); } static VALUE rb_gsl_sf_bessel_j1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_j1_e, x); } static VALUE rb_gsl_sf_bessel_j2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_j2, x); } static VALUE rb_gsl_sf_bessel_j2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_j2_e, x); } static VALUE rb_gsl_sf_bessel_jl(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_jl, n, x); } static VALUE rb_gsl_sf_bessel_jl_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_jl_e, n, x); } static VALUE rb_gsl_sf_bessel_xl_array(VALUE obj, VALUE n1, VALUE x, int (*f)(int, double, double[])) { int nmax, n; // local variable "status" declared and set, but never used //int status; gsl_vector *v = NULL; CHECK_FIXNUM(n1); Need_Float(x); nmax = FIX2INT(n1); n = nmax + 1; v = gsl_vector_alloc(n); /*status =*/ (*f)(nmax, NUM2DBL(x), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_sf_bessel_jl_array(VALUE obj, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_xl_array(obj, n1, x, gsl_sf_bessel_jl_array); } static VALUE rb_gsl_sf_bessel_jl_steed_array(VALUE obj, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_xl_array(obj, n1, x, gsl_sf_bessel_jl_steed_array); } /* Irregular Cylindrical Bessel Functions */ static VALUE rb_gsl_sf_bessel_y0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_y0, x); } static VALUE rb_gsl_sf_bessel_y0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_y0_e, x); } static VALUE rb_gsl_sf_bessel_y1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_y1, x); } static VALUE rb_gsl_sf_bessel_y1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_y1_e, x); } static VALUE rb_gsl_sf_bessel_y2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_y2, x); } static VALUE rb_gsl_sf_bessel_y2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_y2_e, x); } static VALUE rb_gsl_sf_bessel_yl(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_yl, n, x); } static VALUE rb_gsl_sf_bessel_yl_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_yl_e, n, x); } static VALUE rb_gsl_sf_bessel_yl_array(VALUE obj, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_xl_array(obj, n1, x, gsl_sf_bessel_yl_array); } /* Regular Modified Cylindrical Bessel Functions */ static VALUE rb_gsl_sf_bessel_i0_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_i0_scaled, x); } static VALUE rb_gsl_sf_bessel_i0_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_i0_scaled_e, x); } static VALUE rb_gsl_sf_bessel_i1_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_i1_scaled, x); } static VALUE rb_gsl_sf_bessel_i1_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_i1_scaled_e, x); } static VALUE rb_gsl_sf_bessel_i2_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_i2_scaled, x); } static VALUE rb_gsl_sf_bessel_i2_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_i2_scaled_e, x); } static VALUE rb_gsl_sf_bessel_il_scaled(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_il_scaled, n, x); } static VALUE rb_gsl_sf_bessel_il_scaled_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_il_scaled_e, n, x); } static VALUE rb_gsl_sf_bessel_il_scaled_array(VALUE obj, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_xl_array(obj, n1, x, gsl_sf_bessel_il_scaled_array); } /* Irregular Modified Cylindrical Bessel Functions */ static VALUE rb_gsl_sf_bessel_k0_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_k0_scaled, x); } static VALUE rb_gsl_sf_bessel_k0_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_k0_scaled_e, x); } static VALUE rb_gsl_sf_bessel_k1_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_k1_scaled, x); } static VALUE rb_gsl_sf_bessel_k1_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_k1_scaled_e, x); } static VALUE rb_gsl_sf_bessel_k2_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_bessel_k2_scaled, x); } static VALUE rb_gsl_sf_bessel_k2_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_bessel_k2_scaled_e, x); } static VALUE rb_gsl_sf_bessel_kl_scaled(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_bessel_kl_scaled, n, x); } static VALUE rb_gsl_sf_bessel_kl_scaled_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_bessel_kl_scaled_e, n, x); } static VALUE rb_gsl_sf_bessel_kl_scaled_array(VALUE obj, VALUE n1, VALUE x) { return rb_gsl_sf_bessel_xl_array(obj, n1, x, gsl_sf_bessel_kl_scaled_array); } /* Regular Bessel Function - Fractional Order */ static VALUE rb_gsl_sf_bessel_Jnu(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_bessel_Jnu, nu, x); } static VALUE rb_gsl_sf_bessel_Jnu_e(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_bessel_Jnu_e, nu, x); } /* The new array will be returned, the original array "ary" is not modified */ static VALUE rb_gsl_sf_bessel_sequence_Jnu_e(int argc, VALUE *argv, VALUE obj) { size_t i, size; // local variable "status" declared and set, but never used //int status; int flag = 0; gsl_vector *v = NULL; gsl_mode_t mode; char c; VALUE nu, m, ary; nu = argv[0]; switch (argc) { case 2: ary = argv[1]; mode = GSL_PREC_DOUBLE; break; case 3: m = argv[1]; ary = argv[2]; switch (TYPE(m)) { case T_STRING: c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; break; case T_FIXNUM: mode = FIX2INT(m); break; default: rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)", rb_class2name(CLASS_OF(m))); break; } default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } switch (TYPE(ary)) { case T_ARRAY: size = RARRAY_LEN(ary); v = gsl_vector_alloc(size); for (i = 0; i < size; i++) gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(ary, i))); flag = 1; break; default: CHECK_VECTOR(ary); Data_Get_Struct(ary, gsl_vector, v); size = v->size; flag = 0; break; } /*status =*/ gsl_sf_bessel_sequence_Jnu_e(NUM2DBL(nu), mode, size, v->data); if (flag == 1) return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); else return ary; } /* Irregular Bessel Function - Fractional Order */ static VALUE rb_gsl_sf_bessel_Ynu(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_bessel_Ynu, nu, x); } static VALUE rb_gsl_sf_bessel_Ynu_e(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_bessel_Ynu_e, nu, x); } /* Regular Modified Bessel Function - Fractional Order */ static VALUE rb_gsl_sf_bessel_Inu(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_bessel_Inu, nu, x); } static VALUE rb_gsl_sf_bessel_Inu_e(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_bessel_Inu_e, nu, x); } static VALUE rb_gsl_sf_bessel_Inu_scaled(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_bessel_Inu_scaled, nu, x); } static VALUE rb_gsl_sf_bessel_Inu_scaled_e(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_bessel_Inu_scaled_e, nu, x); } /* Irregular Modified Bessel Function - Fractional Order */ static VALUE rb_gsl_sf_bessel_Knu(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_bessel_Knu, nu, x); } static VALUE rb_gsl_sf_bessel_Knu_e(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_bessel_Knu_e, nu, x); } static VALUE rb_gsl_sf_bessel_lnKnu(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_bessel_lnKnu, nu, x); } static VALUE rb_gsl_sf_bessel_lnKnu_e(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_bessel_lnKnu_e, nu, x); } static VALUE rb_gsl_sf_bessel_Knu_scaled(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_bessel_Knu_scaled, nu, x); } static VALUE rb_gsl_sf_bessel_Knu_scaled_e(VALUE obj, VALUE nu, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_bessel_Knu_scaled_e, nu, x); } static VALUE rb_gsl_sf_eval_double_uint(double (*func)(double, unsigned int), VALUE ff, VALUE argv); static VALUE rb_gsl_sf_eval_double_uint(double (*func)(double, unsigned int), VALUE ff, VALUE argv) { gsl_vector *v, *vnew; VALUE ary; size_t i, n; double val, f; f = NUM2DBL(ff); switch (TYPE(argv)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*func)(f, NUM2UINT(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { val = (*func)(f, NUM2UINT(rb_ary_entry(argv, i))); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(f, (unsigned int) gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); break; } } /* find s-th 0 point of J0 */ static VALUE rb_gsl_sf_bessel_zero_J0(VALUE obj, VALUE s) { return rb_gsl_sf_eval1_uint(gsl_sf_bessel_zero_J0, s); } static VALUE rb_gsl_sf_bessel_zero_J0_e(VALUE obj, VALUE s) { return rb_gsl_sf_eval_e_uint(gsl_sf_bessel_zero_J0_e, s); } static VALUE rb_gsl_sf_bessel_zero_J1(VALUE obj, VALUE s) { return rb_gsl_sf_eval1_uint(gsl_sf_bessel_zero_J1, s); } static VALUE rb_gsl_sf_bessel_zero_J1_e(VALUE obj, VALUE s) { return rb_gsl_sf_eval_e_uint(gsl_sf_bessel_zero_J1_e, s); } static VALUE rb_gsl_sf_bessel_zero_Jnu(VALUE obj, VALUE n, VALUE s) { return rb_gsl_sf_eval_double_uint(gsl_sf_bessel_zero_Jnu, n, s); } static VALUE rb_gsl_sf_bessel_zero_Jnu_e(VALUE obj, VALUE n, VALUE s) { return rb_gsl_sf_eval_e_double_uint(gsl_sf_bessel_zero_Jnu_e, n, s); } void Init_gsl_sf_bessel(VALUE module) { VALUE mgsl_sf_bessel; rb_define_module_function(module, "bessel_J0", rb_gsl_sf_bessel_J0, 1); rb_define_module_function(module, "bessel_J0_e", rb_gsl_sf_bessel_J0_e, 1); rb_define_module_function(module, "bessel_J1", rb_gsl_sf_bessel_J1, 1); rb_define_module_function(module, "bessel_J1_e", rb_gsl_sf_bessel_J1_e, 1); rb_define_module_function(module, "bessel_Jn", rb_gsl_sf_bessel_Jn, 2); rb_define_module_function(module, "bessel_Jn_e", rb_gsl_sf_bessel_Jn_e, 2); rb_define_module_function(module, "bessel_Jn_array", rb_gsl_sf_bessel_Jn_array, 3); rb_define_module_function(module, "bessel_Y0", rb_gsl_sf_bessel_Y0, 1); rb_define_module_function(module, "bessel_Y0_e", rb_gsl_sf_bessel_Y0_e, 1); rb_define_module_function(module, "bessel_Y1", rb_gsl_sf_bessel_Y1, 1); rb_define_module_function(module, "bessel_Y1_e", rb_gsl_sf_bessel_Y1_e, 1); rb_define_module_function(module, "bessel_Yn", rb_gsl_sf_bessel_Yn, 2); rb_define_module_function(module, "bessel_Yn_e", rb_gsl_sf_bessel_Yn_e, 2); rb_define_module_function(module, "bessel_Yn_array", rb_gsl_sf_bessel_Yn_array, 3); rb_define_module_function(module, "bessel_I0", rb_gsl_sf_bessel_I0, 1); rb_define_module_function(module, "bessel_I0_e", rb_gsl_sf_bessel_I0_e, 1); rb_define_module_function(module, "bessel_I1", rb_gsl_sf_bessel_I1, 1); rb_define_module_function(module, "bessel_I1_e", rb_gsl_sf_bessel_I1_e, 1); rb_define_module_function(module, "bessel_In", rb_gsl_sf_bessel_In, 2); rb_define_module_function(module, "bessel_In_e", rb_gsl_sf_bessel_In_e, 2); rb_define_module_function(module, "bessel_In_array", rb_gsl_sf_bessel_In_array, 3); rb_define_module_function(module, "bessel_I0_scaled", rb_gsl_sf_bessel_I0_scaled, 1); rb_define_module_function(module, "bessel_I0_scaled_e", rb_gsl_sf_bessel_I0_scaled_e, 1); rb_define_module_function(module, "bessel_I1_scaled", rb_gsl_sf_bessel_I1_scaled, 1); rb_define_module_function(module, "bessel_I1_scaled_e", rb_gsl_sf_bessel_I1_scaled_e, 1); rb_define_module_function(module, "bessel_In_scaled", rb_gsl_sf_bessel_In_scaled, 2); rb_define_module_function(module, "bessel_In_scaled_e", rb_gsl_sf_bessel_In_scaled_e, 2); rb_define_module_function(module, "bessel_In_scaled_array", rb_gsl_sf_bessel_In_scaled_array, 3); rb_define_module_function(module, "bessel_K0", rb_gsl_sf_bessel_K0, 1); rb_define_module_function(module, "bessel_K0_e", rb_gsl_sf_bessel_K0_e, 1); rb_define_module_function(module, "bessel_K1", rb_gsl_sf_bessel_K1, 1); rb_define_module_function(module, "bessel_K1_e", rb_gsl_sf_bessel_K1_e, 1); rb_define_module_function(module, "bessel_Kn", rb_gsl_sf_bessel_Kn, 2); rb_define_module_function(module, "bessel_Kn_e", rb_gsl_sf_bessel_Kn_e, 2); rb_define_module_function(module, "bessel_Kn_array", rb_gsl_sf_bessel_Kn_array, 3); rb_define_module_function(module, "bessel_K0_scaled", rb_gsl_sf_bessel_K0_scaled, 1); rb_define_module_function(module, "bessel_K0_scaled_e", rb_gsl_sf_bessel_K0_scaled_e, 1); rb_define_module_function(module, "bessel_K1_scaled", rb_gsl_sf_bessel_K1_scaled, 1); rb_define_module_function(module, "bessel_K1_scaled_e", rb_gsl_sf_bessel_K1_scaled_e, 1); rb_define_module_function(module, "bessel_Kn_scaled", rb_gsl_sf_bessel_Kn_scaled, 2); rb_define_module_function(module, "bessel_Kn_scaled_e", rb_gsl_sf_bessel_Kn_scaled_e, 2); rb_define_module_function(module, "bessel_Kn_scaled_array", rb_gsl_sf_bessel_Kn_scaled_array, 3); rb_define_module_function(module, "bessel_j0", rb_gsl_sf_bessel_j0, 1); rb_define_module_function(module, "bessel_j0_e", rb_gsl_sf_bessel_j0_e, 1); rb_define_module_function(module, "bessel_j1", rb_gsl_sf_bessel_j1, 1); rb_define_module_function(module, "bessel_j1_e", rb_gsl_sf_bessel_j1_e, 1); rb_define_module_function(module, "bessel_j2", rb_gsl_sf_bessel_j2, 1); rb_define_module_function(module, "bessel_j2_e", rb_gsl_sf_bessel_j2_e, 1); rb_define_module_function(module, "bessel_jl", rb_gsl_sf_bessel_jl, 2); rb_define_module_function(module, "bessel_jl_e", rb_gsl_sf_bessel_jl_e, 2); rb_define_module_function(module, "bessel_jl_array", rb_gsl_sf_bessel_jl_array, 2); rb_define_module_function(module, "bessel_jl_steed_array", rb_gsl_sf_bessel_jl_steed_array, 2); rb_define_module_function(module, "bessel_y0", rb_gsl_sf_bessel_y0, 1); rb_define_module_function(module, "bessel_y0_e", rb_gsl_sf_bessel_y0_e, 1); rb_define_module_function(module, "bessel_y1", rb_gsl_sf_bessel_y1, 1); rb_define_module_function(module, "bessel_y1_e", rb_gsl_sf_bessel_y1_e, 1); rb_define_module_function(module, "bessel_y2", rb_gsl_sf_bessel_y2, 1); rb_define_module_function(module, "bessel_y2_e", rb_gsl_sf_bessel_y2_e, 1); rb_define_module_function(module, "bessel_yl", rb_gsl_sf_bessel_yl, 2); rb_define_module_function(module, "bessel_yl_e", rb_gsl_sf_bessel_yl_e, 2); rb_define_module_function(module, "bessel_yl_array", rb_gsl_sf_bessel_yl_array, 2); rb_define_module_function(module, "bessel_i0_scaled", rb_gsl_sf_bessel_i0_scaled, 1); rb_define_module_function(module, "bessel_i0_scaled_e", rb_gsl_sf_bessel_i0_scaled_e, 1); rb_define_module_function(module, "bessel_i1_scaled", rb_gsl_sf_bessel_i1_scaled, 1); rb_define_module_function(module, "bessel_i1_scaled_e", rb_gsl_sf_bessel_i1_scaled_e, 1); rb_define_module_function(module, "bessel_i2_scaled", rb_gsl_sf_bessel_i2_scaled, 1); rb_define_module_function(module, "bessel_i2_scaled_e", rb_gsl_sf_bessel_i2_scaled_e, 1); rb_define_module_function(module, "bessel_il_scaled", rb_gsl_sf_bessel_il_scaled, 2); rb_define_module_function(module, "bessel_il_scaled_e", rb_gsl_sf_bessel_il_scaled_e, 2); rb_define_module_function(module, "bessel_il_scaled_array", rb_gsl_sf_bessel_il_scaled_array, 2); rb_define_module_function(module, "bessel_k0_scaled", rb_gsl_sf_bessel_k0_scaled, 1); rb_define_module_function(module, "bessel_k0_scaled_e", rb_gsl_sf_bessel_k0_scaled_e, 1); rb_define_module_function(module, "bessel_k1_scaled", rb_gsl_sf_bessel_k1_scaled, 1); rb_define_module_function(module, "bessel_k1_scaled_e", rb_gsl_sf_bessel_k1_scaled_e, 1); rb_define_module_function(module, "bessel_k2_scaled", rb_gsl_sf_bessel_k2_scaled, 1); rb_define_module_function(module, "bessel_k2_scaled_e", rb_gsl_sf_bessel_k2_scaled_e, 1); rb_define_module_function(module, "bessel_kl_scaled", rb_gsl_sf_bessel_kl_scaled, 2); rb_define_module_function(module, "bessel_kl_scaled_e", rb_gsl_sf_bessel_kl_scaled_e, 2); rb_define_module_function(module, "bessel_kl_scaled_array", rb_gsl_sf_bessel_kl_scaled_array, 2); rb_define_module_function(module, "bessel_Jnu", rb_gsl_sf_bessel_Jnu, 2); rb_define_module_function(module, "bessel_Jnu_e", rb_gsl_sf_bessel_Jnu_e, 2); rb_define_module_function(module, "bessel_sequence_Jnu_e", rb_gsl_sf_bessel_sequence_Jnu_e, -1); rb_define_module_function(module, "bessel_Ynu", rb_gsl_sf_bessel_Ynu, 2); rb_define_module_function(module, "bessel_Ynu_e", rb_gsl_sf_bessel_Ynu_e, 2); rb_define_module_function(module, "bessel_Inu", rb_gsl_sf_bessel_Inu, 2); rb_define_module_function(module, "bessel_Inu_e", rb_gsl_sf_bessel_Inu_e, 2); rb_define_module_function(module, "bessel_Inu_scaled", rb_gsl_sf_bessel_Inu_scaled, 2); rb_define_module_function(module, "bessel_Inu_scaled_e", rb_gsl_sf_bessel_Inu_scaled_e, 2); rb_define_module_function(module, "bessel_Knu", rb_gsl_sf_bessel_Knu, 2); rb_define_module_function(module, "bessel_Knu_e", rb_gsl_sf_bessel_Knu_e, 2); rb_define_module_function(module, "bessel_lnKnu", rb_gsl_sf_bessel_lnKnu, 2); rb_define_module_function(module, "bessel_lnKnu_e", rb_gsl_sf_bessel_lnKnu_e, 2); rb_define_module_function(module, "bessel_Knu_scaled", rb_gsl_sf_bessel_Knu_scaled, 2); rb_define_module_function(module, "bessel_Knu_scaled_e", rb_gsl_sf_bessel_Knu_scaled_e, 2); rb_define_module_function(module, "bessel_zero_J0", rb_gsl_sf_bessel_zero_J0, 1); rb_define_module_function(module, "bessel_zero_J0_e", rb_gsl_sf_bessel_zero_J0_e, 1); rb_define_module_function(module, "bessel_zero_J1", rb_gsl_sf_bessel_zero_J1, 1); rb_define_module_function(module, "bessel_zero_J1_e", rb_gsl_sf_bessel_zero_J1_e, 1); rb_define_module_function(module, "bessel_zero_Jnu", rb_gsl_sf_bessel_zero_Jnu, 2); rb_define_module_function(module, "bessel_zero_Jnu_e", rb_gsl_sf_bessel_zero_Jnu_e, 2); /*******************************/ mgsl_sf_bessel = rb_define_module_under(module, "Bessel"); rb_define_module_function(mgsl_sf_bessel, "J0", rb_gsl_sf_bessel_J0, 1); rb_define_module_function(mgsl_sf_bessel, "J0_e", rb_gsl_sf_bessel_J0_e, 1); rb_define_module_function(mgsl_sf_bessel, "J1", rb_gsl_sf_bessel_J1, 1); rb_define_module_function(mgsl_sf_bessel, "J1_e", rb_gsl_sf_bessel_J1_e, 1); rb_define_module_function(mgsl_sf_bessel, "Jn", rb_gsl_sf_bessel_Jn, 2); rb_define_module_function(mgsl_sf_bessel, "Jn_e", rb_gsl_sf_bessel_Jn_e, 2); rb_define_module_function(mgsl_sf_bessel, "Jn_array", rb_gsl_sf_bessel_Jn_array, 3); rb_define_module_function(mgsl_sf_bessel, "Y0", rb_gsl_sf_bessel_Y0, 1); rb_define_module_function(mgsl_sf_bessel, "Y0_e", rb_gsl_sf_bessel_Y0_e, 1); rb_define_module_function(mgsl_sf_bessel, "Y1", rb_gsl_sf_bessel_Y1, 1); rb_define_module_function(mgsl_sf_bessel, "Y1_e", rb_gsl_sf_bessel_Y1_e, 1); rb_define_module_function(mgsl_sf_bessel, "Yn", rb_gsl_sf_bessel_Yn, 2); rb_define_module_function(mgsl_sf_bessel, "Yn_e", rb_gsl_sf_bessel_Yn_e, 2); rb_define_module_function(mgsl_sf_bessel, "Yn_array", rb_gsl_sf_bessel_Yn_array, 3); rb_define_module_function(mgsl_sf_bessel, "I0", rb_gsl_sf_bessel_I0, 1); rb_define_module_function(mgsl_sf_bessel, "I0_e", rb_gsl_sf_bessel_I0_e, 1); rb_define_module_function(mgsl_sf_bessel, "I1", rb_gsl_sf_bessel_I1, 1); rb_define_module_function(mgsl_sf_bessel, "I1_e", rb_gsl_sf_bessel_I1_e, 1); rb_define_module_function(mgsl_sf_bessel, "In", rb_gsl_sf_bessel_In, 2); rb_define_module_function(mgsl_sf_bessel, "In_e", rb_gsl_sf_bessel_In_e, 2); rb_define_module_function(mgsl_sf_bessel, "In_array", rb_gsl_sf_bessel_In_array, 3); rb_define_module_function(mgsl_sf_bessel, "I0_scaled", rb_gsl_sf_bessel_I0_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "I0_scaled_e", rb_gsl_sf_bessel_I0_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "I1_scaled", rb_gsl_sf_bessel_I1_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "I1_scaled_e", rb_gsl_sf_bessel_I1_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "In_scaled", rb_gsl_sf_bessel_In_scaled, 2); rb_define_module_function(mgsl_sf_bessel, "In_scaled_e", rb_gsl_sf_bessel_In_scaled_e, 2); rb_define_module_function(mgsl_sf_bessel, "In_scaled_array", rb_gsl_sf_bessel_In_scaled_array, 3); rb_define_module_function(mgsl_sf_bessel, "K0", rb_gsl_sf_bessel_K0, 1); rb_define_module_function(mgsl_sf_bessel, "K0_e", rb_gsl_sf_bessel_K0_e, 1); rb_define_module_function(mgsl_sf_bessel, "K1", rb_gsl_sf_bessel_K1, 1); rb_define_module_function(mgsl_sf_bessel, "K1_e", rb_gsl_sf_bessel_K1_e, 1); rb_define_module_function(mgsl_sf_bessel, "Kn", rb_gsl_sf_bessel_Kn, 2); rb_define_module_function(mgsl_sf_bessel, "Kn_e", rb_gsl_sf_bessel_Kn_e, 2); rb_define_module_function(mgsl_sf_bessel, "Kn_array", rb_gsl_sf_bessel_Kn_array, 3); rb_define_module_function(mgsl_sf_bessel, "K0_scaled", rb_gsl_sf_bessel_K0_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "K0_scaled_e", rb_gsl_sf_bessel_K0_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "K1_scaled", rb_gsl_sf_bessel_K1_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "K1_scaled_e", rb_gsl_sf_bessel_K1_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "Kn_scaled", rb_gsl_sf_bessel_Kn_scaled, 2); rb_define_module_function(mgsl_sf_bessel, "Kn_scaled_e", rb_gsl_sf_bessel_Kn_scaled_e, 2); rb_define_module_function(mgsl_sf_bessel, "Kn_scaled_array", rb_gsl_sf_bessel_Kn_scaled_array, 3); rb_define_module_function(mgsl_sf_bessel, "j0", rb_gsl_sf_bessel_j0, 1); rb_define_module_function(mgsl_sf_bessel, "j0_e", rb_gsl_sf_bessel_j0_e, 1); rb_define_module_function(mgsl_sf_bessel, "j1", rb_gsl_sf_bessel_j1, 1); rb_define_module_function(mgsl_sf_bessel, "j1_e", rb_gsl_sf_bessel_j1_e, 1); rb_define_module_function(mgsl_sf_bessel, "j2", rb_gsl_sf_bessel_j2, 1); rb_define_module_function(mgsl_sf_bessel, "j2_e", rb_gsl_sf_bessel_j2_e, 1); rb_define_module_function(mgsl_sf_bessel, "jl", rb_gsl_sf_bessel_jl, 2); rb_define_module_function(mgsl_sf_bessel, "jl_e", rb_gsl_sf_bessel_jl_e, 2); rb_define_module_function(mgsl_sf_bessel, "jl_array", rb_gsl_sf_bessel_jl_array, 2); rb_define_module_function(mgsl_sf_bessel, "jl_steed_array", rb_gsl_sf_bessel_jl_steed_array, 2); rb_define_module_function(mgsl_sf_bessel, "y0", rb_gsl_sf_bessel_y0, 1); rb_define_module_function(mgsl_sf_bessel, "y0_e", rb_gsl_sf_bessel_y0_e, 1); rb_define_module_function(mgsl_sf_bessel, "y1", rb_gsl_sf_bessel_y1, 1); rb_define_module_function(mgsl_sf_bessel, "y1_e", rb_gsl_sf_bessel_y1_e, 1); rb_define_module_function(mgsl_sf_bessel, "y2", rb_gsl_sf_bessel_y2, 1); rb_define_module_function(mgsl_sf_bessel, "y2_e", rb_gsl_sf_bessel_y2_e, 1); rb_define_module_function(mgsl_sf_bessel, "yl", rb_gsl_sf_bessel_yl, 2); rb_define_module_function(mgsl_sf_bessel, "yl_e", rb_gsl_sf_bessel_yl_e, 2); rb_define_module_function(mgsl_sf_bessel, "yl_array", rb_gsl_sf_bessel_yl_array, 2); rb_define_module_function(mgsl_sf_bessel, "i0_scaled", rb_gsl_sf_bessel_i0_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "i0_scaled_e", rb_gsl_sf_bessel_i0_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "i1_scaled", rb_gsl_sf_bessel_i1_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "i1_scaled_e", rb_gsl_sf_bessel_i1_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "i2_scaled", rb_gsl_sf_bessel_i2_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "i2_scaled_e", rb_gsl_sf_bessel_i2_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "il_scaled", rb_gsl_sf_bessel_il_scaled, 2); rb_define_module_function(mgsl_sf_bessel, "il_scaled_e", rb_gsl_sf_bessel_il_scaled_e, 2); rb_define_module_function(mgsl_sf_bessel, "il_scaled_array", rb_gsl_sf_bessel_il_scaled_array, 2); rb_define_module_function(mgsl_sf_bessel, "k0_scaled", rb_gsl_sf_bessel_k0_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "k0_scaled_e", rb_gsl_sf_bessel_k0_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "k1_scaled", rb_gsl_sf_bessel_k1_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "k1_scaled_e", rb_gsl_sf_bessel_k1_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "k2_scaled", rb_gsl_sf_bessel_k2_scaled, 1); rb_define_module_function(mgsl_sf_bessel, "k2_scaled_e", rb_gsl_sf_bessel_k2_scaled_e, 1); rb_define_module_function(mgsl_sf_bessel, "kl_scaled", rb_gsl_sf_bessel_kl_scaled, 2); rb_define_module_function(mgsl_sf_bessel, "kl_scaled_e", rb_gsl_sf_bessel_kl_scaled_e, 2); rb_define_module_function(mgsl_sf_bessel, "kl_scaled_array", rb_gsl_sf_bessel_kl_scaled_array, 2); rb_define_module_function(mgsl_sf_bessel, "Jnu", rb_gsl_sf_bessel_Jnu, 2); rb_define_module_function(mgsl_sf_bessel, "Jnu_e", rb_gsl_sf_bessel_Jnu_e, 2); rb_define_module_function(mgsl_sf_bessel, "sequence_Jnu_e", rb_gsl_sf_bessel_sequence_Jnu_e, 3); rb_define_module_function(mgsl_sf_bessel, "Ynu", rb_gsl_sf_bessel_Ynu, 2); rb_define_module_function(mgsl_sf_bessel, "Ynu_e", rb_gsl_sf_bessel_Ynu_e, 2); rb_define_module_function(mgsl_sf_bessel, "Inu", rb_gsl_sf_bessel_Inu, 2); rb_define_module_function(mgsl_sf_bessel, "Inu_e", rb_gsl_sf_bessel_Inu_e, 2); rb_define_module_function(mgsl_sf_bessel, "Inu_scaled", rb_gsl_sf_bessel_Inu_scaled, 2); rb_define_module_function(mgsl_sf_bessel, "Inu_scaled_e", rb_gsl_sf_bessel_Inu_scaled_e, 2); rb_define_module_function(mgsl_sf_bessel, "Knu", rb_gsl_sf_bessel_Knu, 2); rb_define_module_function(mgsl_sf_bessel, "Knu_e", rb_gsl_sf_bessel_Knu_e, 2); rb_define_module_function(mgsl_sf_bessel, "lnKnu", rb_gsl_sf_bessel_lnKnu, 2); rb_define_module_function(mgsl_sf_bessel, "lnKnu_e", rb_gsl_sf_bessel_lnKnu_e, 2); rb_define_module_function(mgsl_sf_bessel, "Knu_scaled", rb_gsl_sf_bessel_Knu_scaled, 2); rb_define_module_function(mgsl_sf_bessel, "Knu_scaled_e", rb_gsl_sf_bessel_Knu_scaled_e, 2); rb_define_module_function(mgsl_sf_bessel, "zero_J0", rb_gsl_sf_bessel_zero_J0, 1); rb_define_module_function(mgsl_sf_bessel, "zero_J0_e", rb_gsl_sf_bessel_zero_J0_e, 1); rb_define_module_function(mgsl_sf_bessel, "zero_J1", rb_gsl_sf_bessel_zero_J1, 1); rb_define_module_function(mgsl_sf_bessel, "zero_J1_e", rb_gsl_sf_bessel_zero_J1_e, 1); rb_define_module_function(mgsl_sf_bessel, "zero_Jnu", rb_gsl_sf_bessel_zero_Jnu, 2); rb_define_module_function(mgsl_sf_bessel, "zero_Jnu_e", rb_gsl_sf_bessel_zero_Jnu_e, 2); } gsl-1.15.3/ext/sf_laguerre.c0000644000175000017500000000745412220252463015216 0ustar boutilboutil/* sf_laguerre.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_laguerre_X(int argc, VALUE *argv, VALUE obj, double (*f)(double, double)) { switch (argc) { case 2: return rb_gsl_sf_eval_double_double(f, argv[0], argv[1]); break; case 1: return rb_gsl_sf_eval_double_double(f, INT2FIX(0), argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } } static VALUE rb_gsl_sf_laguerre_1(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_laguerre_X(argc, argv, obj, gsl_sf_laguerre_1); } static VALUE rb_gsl_sf_laguerre_1_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_laguerre_1_e, a, x); } static VALUE rb_gsl_sf_laguerre_2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_laguerre_X(argc, argv, obj, gsl_sf_laguerre_2); } static VALUE rb_gsl_sf_laguerre_2_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_laguerre_2_e, a, x); } static VALUE rb_gsl_sf_laguerre_3(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_laguerre_X(argc, argv, obj, gsl_sf_laguerre_3); } static VALUE rb_gsl_sf_laguerre_3_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_laguerre_3_e, a, x); } static VALUE rb_gsl_sf_laguerre_n(int argc, VALUE *argv, VALUE obj) { switch (argc) { case 3: return rb_gsl_sf_eval_int_double_double(gsl_sf_laguerre_n, argv[0], argv[1], argv[2]); break; case 2: return rb_gsl_sf_eval_int_double_double(gsl_sf_laguerre_n, argv[0], INT2FIX(0), argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } } static VALUE rb_gsl_sf_laguerre_n_e(VALUE obj, VALUE n, VALUE a, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(n); Need_Float(a); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_laguerre_n_e(FIX2INT(n), NUM2DBL(a), NUM2DBL(x), rslt); return v; } void Init_gsl_sf_laguerre(VALUE module) { VALUE mgsl_sf_laguerre; rb_define_module_function(module, "laguerre_1", rb_gsl_sf_laguerre_1, -1); rb_define_module_function(module, "laguerre_1_e", rb_gsl_sf_laguerre_1_e, 2); rb_define_module_function(module, "laguerre_2", rb_gsl_sf_laguerre_2, -1); rb_define_module_function(module, "laguerre_2_e", rb_gsl_sf_laguerre_2_e, 2); rb_define_module_function(module, "laguerre_3", rb_gsl_sf_laguerre_3, -1); rb_define_module_function(module, "laguerre_3_e", rb_gsl_sf_laguerre_3_e, 2); rb_define_module_function(module, "laguerre_n", rb_gsl_sf_laguerre_n, -1); rb_define_module_function(module, "laguerre_n_e", rb_gsl_sf_laguerre_n_e, 3); mgsl_sf_laguerre = rb_define_module_under(module, "Laguerre"); rb_define_module_function(mgsl_sf_laguerre, "one", rb_gsl_sf_laguerre_1, -1); rb_define_module_function(mgsl_sf_laguerre, "one_e", rb_gsl_sf_laguerre_1_e, 2); rb_define_module_function(mgsl_sf_laguerre, "two", rb_gsl_sf_laguerre_2, -1); rb_define_module_function(mgsl_sf_laguerre, "two_e", rb_gsl_sf_laguerre_2_e, 2); rb_define_module_function(mgsl_sf_laguerre, "three_3", rb_gsl_sf_laguerre_3, -1); rb_define_module_function(mgsl_sf_laguerre, "three_e", rb_gsl_sf_laguerre_3_e, 2); rb_define_module_function(mgsl_sf_laguerre, "n", rb_gsl_sf_laguerre_n, -1); rb_define_module_function(mgsl_sf_laguerre, "n_e", rb_gsl_sf_laguerre_n_e, 3); } gsl-1.15.3/ext/multiset.c0000644000175000017500000001276012220252463014562 0ustar boutilboutil#include "rb_gsl.h" #ifdef GSL_1_14_LATER VALUE cMultiset; VALUE rb_gsl_multiset_alloc(VALUE klass, VALUE nn, VALUE kk) { gsl_multiset *m; m = gsl_multiset_alloc(FIX2INT(nn), FIX2INT(kk)); return Data_Wrap_Struct(klass, 0, gsl_multiset_free, m); } VALUE rb_gsl_multiset_calloc(VALUE klass, VALUE nn, VALUE kk) { gsl_multiset *m; m = gsl_multiset_alloc(FIX2INT(nn), FIX2INT(kk)); return Data_Wrap_Struct(klass, 0, gsl_multiset_free, m); } VALUE rb_gsl_multiset_init_first(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); gsl_multiset_init_first(m); return Qnil; } VALUE rb_gsl_multiset_init_last(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); gsl_multiset_init_last(m); return Qnil; } VALUE rb_gsl_multiset_memcpy(VALUE klass, VALUE m1, VALUE m2) { gsl_multiset *mm1, *mm2; if (!rb_obj_is_kind_of(m1, klass)) { rb_raise(rb_eTypeError, "Wrong type %s (GSL::Multiset expected)", rb_class2name(CLASS_OF(m1))); } if (!rb_obj_is_kind_of(m2, klass)) { rb_raise(rb_eTypeError, "Wrong type %s (GSL::Multiset expected)", rb_class2name(CLASS_OF(m2))); } Data_Get_Struct(m1, gsl_multiset, mm1); Data_Get_Struct(m2, gsl_multiset, mm2); return FIX2INT(gsl_multiset_memcpy(mm1, mm2)); } VALUE rb_gsl_multiset_get(VALUE mm, VALUE i) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); return INT2FIX(gsl_multiset_get(m, FIX2INT(i))); } VALUE rb_gsl_multiset_n(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); return INT2FIX(gsl_multiset_n(m)); } VALUE rb_gsl_multiset_k(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); return INT2FIX(gsl_multiset_k(m)); } VALUE rb_gsl_multiset_valid(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); return INT2FIX(gsl_multiset_valid(m)); } VALUE rb_gsl_multiset_valid2(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); if (gsl_multiset_valid(m)) return Qtrue; else return Qfalse; } VALUE rb_gsl_multiset_next(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); return INT2FIX(gsl_multiset_next(m)); } VALUE rb_gsl_multiset_prev(VALUE mm) { gsl_multiset *m; Data_Get_Struct(mm, gsl_multiset, m); return INT2FIX(gsl_multiset_prev(m)); } VALUE rb_gsl_multiset_fwrite(VALUE mm, VALUE name) { gsl_multiset *m; FILE *fp = NULL; int ret; Data_Get_Struct(mm, gsl_multiset, m); fp = fopen(STR2CSTR(name), "wb"); if (fp == NULL) { rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name)); } ret = gsl_multiset_fwrite(fp, m); fclose(fp); return INT2FIX(ret); } VALUE rb_gsl_multiset_fread(VALUE mm, VALUE name) { gsl_multiset *m; FILE *fp = NULL; int ret; Data_Get_Struct(mm, gsl_multiset, m); fp = fopen(STR2CSTR(name), "wb"); if (fp == NULL) { rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name)); } ret = gsl_multiset_fread(fp, m); fclose(fp); return INT2FIX(ret); } VALUE rb_gsl_multiset_fprintf(VALUE mm, VALUE name, VALUE format) { gsl_multiset *m; FILE *fp = NULL; int ret; Data_Get_Struct(mm, gsl_multiset, m); fp = fopen(STR2CSTR(name), "w"); if (fp == NULL) { rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name)); } ret = gsl_multiset_fprintf(fp, m, STR2CSTR(format)); fclose(fp); return INT2FIX(ret); } VALUE rb_gsl_multiset_fscanf(VALUE mm, VALUE name) { gsl_multiset *m; FILE *fp = NULL; int ret; Data_Get_Struct(mm, gsl_multiset, m); fp = fopen(STR2CSTR(name), "r"); if (fp == NULL) { rb_raise(rb_eIOError, "Cannot open file %s", STR2CSTR(name)); } ret = gsl_multiset_fscanf(fp, m); fclose(fp); return INT2FIX(ret); } VALUE rb_gsl_multiset_data(VALUE mm) { gsl_multiset *m; size_t *p; gsl_vector_int *v; size_t i; Data_Get_Struct(mm, gsl_multiset, m); p = gsl_multiset_data(m); v = gsl_vector_int_alloc(m->k); for (i = 0; i < v->size; i++) gsl_vector_int_set(v, i, p[i]); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v); } VALUE rb_gsl_multiset_data2(VALUE mm, VALUE i) { gsl_multiset *m; size_t *p; Data_Get_Struct(mm, gsl_multiset, m); p = gsl_multiset_data(m); return INT2FIX(p[i]); } void Init_multiset(VALUE module) { cMultiset = rb_define_class_under(module, "Multiset", cGSL_Object); rb_define_singleton_method(cMultiset, "alloc", rb_gsl_multiset_alloc, 2); rb_define_singleton_method(cMultiset, "calloc", rb_gsl_multiset_calloc, 2); rb_define_singleton_method(cMultiset, "memcpy", rb_gsl_multiset_memcpy, 2); rb_define_method(cMultiset, "init_first", rb_gsl_multiset_init_first, 0); rb_define_method(cMultiset, "init_last", rb_gsl_multiset_init_last, 0); rb_define_method(cMultiset, "get", rb_gsl_multiset_get, 1); rb_define_alias(cMultiset, "[]", "get"); rb_define_method(cMultiset, "n", rb_gsl_multiset_n, 0); rb_define_method(cMultiset, "k", rb_gsl_multiset_k, 0); rb_define_method(cMultiset, "data", rb_gsl_multiset_data, 0); rb_define_method(cMultiset, "data[]", rb_gsl_multiset_data2, 1); rb_define_method(cMultiset, "valid", rb_gsl_multiset_valid, 0); rb_define_method(cMultiset, "valid?", rb_gsl_multiset_valid2, 0); rb_define_method(cMultiset, "next", rb_gsl_multiset_next, 0); rb_define_method(cMultiset, "prev", rb_gsl_multiset_prev, 0); rb_define_method(cMultiset, "fwrite", rb_gsl_multiset_fwrite, 1); rb_define_method(cMultiset, "fread", rb_gsl_multiset_fread, 1); rb_define_method(cMultiset, "fprintf", rb_gsl_multiset_fprintf, 2); rb_define_method(cMultiset, "fscanf", rb_gsl_multiset_fscanf, 1); } #endif gsl-1.15.3/ext/vector_source.c0000644000175000017500000031372412220252463015602 0ustar boutilboutil/* vector_source.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2005 by Yoshiki Tsunesada Cameron McBride Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #ifdef BASE_DOUBLE #define NUMCONV(x) NUM2DBL(x) #define NUMCONV2(x) NUM2DBL(x) #define PRINTF_FORMAT "%5.3e " #define VEC_ROW_COL VECTOR_ROW_COL #define VEC_P VECTOR_P #define VEC_ROW_P VECTOR_ROW_P #define VEC_COL_P VECTOR_COL_P #define C_TO_VALUE rb_float_new #define C_TO_VALUE2 rb_float_new #define CHECK_VEC CHECK_VECTOR #define VEC_VIEW_P VECTOR_VIEW_P #elif defined(BASE_INT) #define NUMCONV(x) FIX2INT(x) #define NUMCONV2(x) NUM2INT(x) #define PRINTF_FORMAT "%d " #define VEC_ROW_COL VECTOR_INT_ROW_COL #define VEC_P VECTOR_INT_P #define C_TO_VALUE INT2FIX #define C_TO_VALUE2 INT2NUM #define VEC_ROW_P VECTOR_INT_ROW_P #define VEC_COL_P VECTOR_INT_COL_P #define CHECK_VEC CHECK_VECTOR_INT #define VEC_VIEW_P VECTOR_INT_VIEW_P #endif void FUNCTION(get_range,beg_en_n)(VALUE range, BASE *beg, BASE *en, size_t *n, int *step); void get_range_beg_en_n_for_size(VALUE range, int *beg, int *en, size_t *n, int *step, size_t size); void parse_subvector_args(int argc, VALUE *argv, size_t size, size_t *offset, size_t *stride, size_t *n); void FUNCTION(get_range,beg_en_n)(VALUE range, BASE *beg, BASE *en, size_t *n, int *step) { *beg = NUMCONV2(rb_funcall3(range, rb_gsl_id_beg, 0, NULL)); *en = NUMCONV2(rb_funcall3(range, rb_gsl_id_end, 0, NULL)); *n = (size_t) fabs(*en - *beg); if (!RTEST(rb_funcall3(range, rb_gsl_id_excl, 0, NULL))) *n += 1; if (*en < *beg) *step = -1; else *step = 1; } #ifdef BASE_INT void get_range_beg_en_n_for_size(VALUE range, int *beg, int *en, size_t *n, int *step, size_t size) { *beg = NUM2INT(rb_funcall3(range, rb_gsl_id_beg, 0, NULL)); if(*beg < 0) *beg += size; *en = NUM2INT(rb_funcall3(range, rb_gsl_id_end, 0, NULL)); if(*en < 0) *en += size; *n = (size_t) fabs(*en - *beg); if (!RTEST(rb_funcall3(range, rb_gsl_id_excl, 0, NULL))) *n += 1; if (*en < *beg) *step = -1; else *step = 1; } void parse_subvector_args(int argc, VALUE *argv, size_t size, size_t *offset, size_t *stride, size_t *n) { int begin = 0, end, step, length; *stride = 1; switch (argc) { case 0: *n = size; break; case 1: if(rb_obj_is_kind_of(argv[0], rb_cRange)) { get_range_beg_en_n_for_size(argv[0], &begin, &end, n, &step, size); // TODO Should we do bounds checking or risk letting GSL do it? // On one hand, it seems like we should do as little as possible to stay as // thin and fast as possible. On the other hand, it seems like we don't // want to let Ruby crash if GSL does not have bounds checking enabled. if(begin < 0 || (size_t)begin >= size) { rb_raise(rb_eRangeError, "begin value %d is out of range for Vector of length %d", begin, (int) size); } if(end < 0 || (size_t)end >= size) { rb_raise(rb_eRangeError, "end value %d is out of range for Vector of length %d", end, (int) size); } *stride = (size_t)step; } else { CHECK_FIXNUM(argv[0]); length = FIX2INT(argv[0]); if((length < 0 && -length > size) || (length > 0 && length > size)) { rb_raise(rb_eRangeError, "length %d is out of range for Vector of length %d", length, (int) size); } else if(length < 0) { begin = length; *n = (size_t)(-length); } else { // begin was initialized to 0 *n = (size_t)length; } } break; case 2: if(rb_obj_is_kind_of(argv[0], rb_cRange)) { get_range_beg_en_n_for_size(argv[0], &begin, &end, n, &step, size); if(begin < 0 || (size_t)begin >= size) { rb_raise(rb_eRangeError, "begin value %d is out of range for Vector of length %d", (int) begin, (int) size); } if(end < 0 || (size_t)end >= size) { rb_raise(rb_eRangeError, "end value %d is out of range for Vector of length %d", (int) end, (int) size); } CHECK_FIXNUM(argv[1]); step = FIX2INT(argv[1]); if(step == 0 && begin != end) { rb_raise(rb_eArgError, "stride must be non-zero"); } else if((step < 0 && begin <= end) || (step > 0 && end < begin)) { step = -step; } if(step < 0) { *n = (*n-1)/(-step) + 1; } else if(step > 0) { *n = (*n-1)/step + 1; } *stride = (size_t)step; } else { CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); begin = FIX2INT(argv[0]); length = FIX2INT(argv[1]); if(length < 0) { length = -length; *stride = -1; } *n = (size_t)length; } break; case 3: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); begin = FIX2INT(argv[0]); step = FIX2INT(argv[1]); length = FIX2INT(argv[2]); if(length < 0) { step = -step; length = -length; } *stride = (size_t)step; *n = (size_t)length; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-3)", argc); break; } if(begin < 0) { begin += size; } *offset = (size_t)begin; } #endif void FUNCTION(set_ptr_data,by_range)(BASE *ptr, size_t n, VALUE range) { size_t n2, i; BASE beg, en, val; int step; FUNCTION(get_range,beg_en_n)(range, &beg, &en, &n2, &step); val = beg; for (i = 0; i < n; i++) { if (i < n2) ptr[i] = val; else ptr[i] = (BASE) 0; val += step; } } void FUNCTION(cvector,set_from_rarray)(GSL_TYPE(gsl_vector) *v, VALUE ary) { size_t i; if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary); Check_Type(ary, T_ARRAY); #ifdef RUBY_1_9_LATER if (RARRAY_LEN(ary) == 0) return; #else if (RARRAY_LEN(ary) == 0) return; #endif for (i = 0; i < v->size; i++) FUNCTION(gsl_vector,set)(v, i, NUMCONV(rb_ary_entry(ary, i))); } GSL_TYPE(gsl_vector)* FUNCTION(make_cvector,from_rarray)(VALUE ary) { GSL_TYPE(gsl_vector) *v = NULL; if (CLASS_OF(ary) == rb_cRange) ary = rb_gsl_range2ary(ary); Check_Type(ary, T_ARRAY); v = FUNCTION(gsl_vector,alloc)(RARRAY_LEN(ary)); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); FUNCTION(cvector,set_from_rarray)(v, ary); return v; } VALUE FUNCTION(rb_gsl_vector,new)(int argc, VALUE *argv, VALUE klass) { GSL_TYPE(gsl_vector) *v = NULL, *vtmp = NULL; BASE xnative; size_t n, i; BASE beg, en; int step; #ifdef HAVE_NARRAY_H VALUE ary2; #endif switch (argc) { case 1: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) { n = NA_TOTAL(argv[0]); v = FUNCTION(gsl_vector,alloc)(n); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); #ifdef BASE_DOUBLE ary2 = na_change_type(argv[0], NA_DFLOAT); #else ary2 = na_change_type(argv[0], NA_LINT); #endif memcpy(v->data, NA_PTR_TYPE(ary2,BASE*), n*sizeof(BASE)); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_vector,free), v); } #endif switch (TYPE(argv[0])) { case T_FIXNUM: /*! if an integer n is given, create an empty vector of length n */ CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); v = FUNCTION(gsl_vector,calloc)(n); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); break; case T_BIGNUM: rb_raise(rb_eRangeError, "vector length is limited within the range of Fixnum."); break; case T_FLOAT: v = FUNCTION(gsl_vector,alloc)(1); switch(TYPE(argv[0])) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: xnative = NUMCONV2(argv[0]); break; default: xnative = (BASE)0; } FUNCTION(gsl_vector,set)(v, 0, xnative); break; #ifdef BASE_DOUBLE case T_ARRAY: v = make_cvector_from_rarrays(argv[0]); break; #endif default: if (CLASS_OF(argv[0]) == rb_cRange) { FUNCTION(get_range,beg_en_n)(argv[0], &beg, &en, &n, &step); v = FUNCTION(gsl_vector,alloc)(n); FUNCTION(set_ptr_data,by_range)(v->data, v->size, argv[0]); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_vector,free), v); } else if (VEC_P(argv[0])) { /*! Create a new vector with the same elements of the vector given */ Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), vtmp); v = FUNCTION(gsl_vector,alloc)(vtmp->size); for (i = 0; i < vtmp->size; i++) FUNCTION(gsl_vector,set)(v, i, FUNCTION(gsl_vector,get)(vtmp, i)); return Data_Wrap_Struct(VEC_ROW_COL(argv[0]), 0, FUNCTION(gsl_vector,free), v); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); } break; } break; default: v = FUNCTION(gsl_vector,alloc)(argc); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); for (i = 0; i < argc; i++) { switch(TYPE(argv[i])) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: xnative = NUMCONV2(argv[i]); break; default: xnative = (BASE)0; } FUNCTION(gsl_vector,set)(v, i, xnative); } break; } return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_vector,free), v); } static VALUE FUNCTION(rb_gsl_vector,calloc)(VALUE klass, VALUE nn) { GSL_TYPE(gsl_vector) *v = NULL; CHECK_FIXNUM(nn); v = FUNCTION(gsl_vector,calloc)(FIX2INT(nn)); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_calloc failed"); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_vector,free), v); } static VALUE FUNCTION(rb_gsl_vector,subvector)(int argc, VALUE *argv, VALUE obj); static VALUE FUNCTION(rb_gsl_vector,get)(int argc, VALUE *argv, VALUE obj) { VALUE retval = Qnil; GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; // QUALIFIED_VIEW(gsl_vector,view) *vv; gsl_index *p; int i; /*! not size_t, since a negative index is allowed */ size_t j, k; // If argc is not 1 or argv[0] is a Range if( argc != 1 || rb_obj_is_kind_of(argv[0], rb_cRange)) { // Treat as call to subvector retval = FUNCTION(rb_gsl_vector,subvector)(argc, argv, obj); } else { Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (TYPE(argv[0])) { case T_FIXNUM: i = FIX2INT(argv[0]); if (i < 0) retval = C_TO_VALUE2(FUNCTION(gsl_vector,get)(v, (size_t) (v->size + i))); else retval = C_TO_VALUE2(FUNCTION(gsl_vector,get)(v, (size_t) (i))); break; case T_ARRAY: vnew = FUNCTION(gsl_vector,alloc)(RARRAY_LEN(argv[0])); for (j = 0; j < vnew->size; j++) { i = NUMCONV(rb_ary_entry(argv[0], j)); if (i < 0) k = v->size + i; // else k = j; else k = i; FUNCTION(gsl_vector,set)(vnew, j, FUNCTION(gsl_vector,get)(v, k)); } retval = Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); break; default: if (PERMUTATION_P(argv[0])) { Data_Get_Struct(argv[0], gsl_index, p); vnew = FUNCTION(gsl_vector,alloc)(p->size); for (j = 0; j < p->size; j++) { k = p->data[j]; if (k < 0) k = p->size + j; FUNCTION(gsl_vector,set)(vnew, j, FUNCTION(gsl_vector,get)(v, k)); } retval = Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); } else { // TODO Support Vector::Int (and even Vector?) rb_raise(rb_eTypeError, "wrong argument type %s (Array, Range, GSL::Permutation, or Fixnum expected)", rb_class2name(CLASS_OF(argv[0]))); } break; } } return retval; } static VALUE FUNCTION(rb_gsl_vector,size)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX(v->size); } static VALUE FUNCTION(rb_gsl_vector,stride)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX(v->stride); } static VALUE FUNCTION(rb_gsl_vector,set_stride)(VALUE obj, VALUE ss) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); v->stride = (size_t) FIX2INT(ss); return obj; } static VALUE FUNCTION(rb_gsl_vector,owner)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX(v->owner); } void FUNCTION(rb_gsl_vector,set_subvector)(int argc, VALUE *argv, GSL_TYPE(gsl_vector) *v, VALUE other) { GSL_TYPE(gsl_vector) *vother; QUALIFIED_VIEW(gsl_vector,view) vv; int step; size_t i, offset, stride, n, nother; BASE beg, end; // assignment to v.subvector(...) parse_subvector_args(argc, argv, v->size, &offset, &stride, &n); vv = FUNCTION(gsl_vector,subvector_with_stride)(v, offset, stride, n); if(rb_obj_is_kind_of(other, GSL_TYPE(cgsl_vector))) { Data_Get_Struct(other, GSL_TYPE(gsl_vector), vother); if(n != vother->size) { rb_raise(rb_eRangeError, "lengths do not match (%d != %d)",(int) n, (int) vother->size); } // TODO Change to gsl_vector_memmove if/when GSL has such a function // because gsl_vector_memcpy does not handle overlapping regions (e.g. // Views) well. FUNCTION(gsl_vector,memcpy)(&vv.vector, vother); } else if(rb_obj_is_kind_of(other, rb_cArray)) { if(n != RARRAY_LEN(other)) { rb_raise(rb_eRangeError, "lengths do not match (%d != %d)", (int) n, (int) RARRAY_LEN(other)); } for(i = 0; i < n; i++) { FUNCTION(gsl_vector,set)(&vv.vector, i, NUMCONV2(rb_ary_entry(other, i))); } } else if(rb_obj_is_kind_of(other, rb_cRange)) { FUNCTION(get_range,beg_en_n)(other, &beg, &end, ¬her, &step); if(n != nother) { rb_raise(rb_eRangeError, "lengths do not match (%d != %d)", (int) n, (int) nother); } for(i = 0; i < n; i++) { FUNCTION(gsl_vector,set)(&vv.vector, i, beg); beg += step; } } else { FUNCTION(gsl_vector,set_all)(&vv.vector, NUMCONV2(other)); } } static VALUE FUNCTION(rb_gsl_vector,set)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v; VALUE other; int ii; if(argc < 1 || argc > 4) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-4)", argc); } Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); other = argv[argc-1]; if(argc == 1) { // // If assigning from another vector if(VECTOR_P(other) || VECTOR_INT_P(other)) { // treat as assignment to v.subvector(...) FUNCTION(rb_gsl_vector,set_subvector)(argc-1, argv, v, other); } else { FUNCTION(gsl_vector,set_all)(v, NUMCONV2(other)); } } else if(argc == 2 && TYPE(argv[0]) == T_FIXNUM) { // v[i] = x ii = FIX2INT(argv[0]); if(ii < 0) ii += v->size; FUNCTION(gsl_vector,set)(v, (size_t)ii, NUMCONV2(other)); } else { // assignment to v.subvector(...) FUNCTION(rb_gsl_vector,set_subvector)(argc-1, argv, v, other); } return obj; } static VALUE FUNCTION(rb_gsl_vector,set_all)(VALUE obj, VALUE xx) { GSL_TYPE(gsl_vector) *v = NULL; BASE xnative = NUMCONV2(xx); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,set_all)(v, xnative); return obj; } VALUE FUNCTION(rb_gsl_vector,do_something)(VALUE obj, void (*func)(GSL_TYPE(gsl_vector)*)) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); (*func)(v); return obj; } static VALUE FUNCTION(rb_gsl_vector,set_zero)(VALUE obj) { return FUNCTION(rb_gsl_vector,do_something)(obj, FUNCTION(gsl_vector,set_zero)); } static VALUE FUNCTION(rb_gsl_vector,set_basis)(VALUE obj, VALUE ii) { GSL_TYPE(gsl_vector) *v = NULL; CHECK_FIXNUM(ii); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,set_basis)(v, (size_t) FIX2INT(ii)); return obj; } static VALUE FUNCTION(rb_gsl_vector,each)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = 0; i < v->size; i++) rb_yield(C_TO_VALUE2(FUNCTION(gsl_vector,get)(v, i))); return Qnil; } static VALUE FUNCTION(rb_gsl_vector,reverse_each)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = v->size-1; i >= 0; i--) { rb_yield(C_TO_VALUE2(FUNCTION(gsl_vector,get)(v, i))); if (i == 0) break; } return Qnil; } static VALUE FUNCTION(rb_gsl_vector,each_index)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = 0; i < v->size; i++) rb_yield(INT2FIX(i)); return Qnil; } static VALUE FUNCTION(rb_gsl_vector,reverse_each_index)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = v->size-1; i >= 0; i--) { rb_yield(INT2FIX(i)); if (i == 0) break; } return Qnil; } static VALUE FUNCTION(rb_gsl_vector,to_a)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; VALUE ary; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); ary = rb_ary_new2(v->size); for (i = 0; i < v->size; i++) rb_ary_store(ary, i, C_TO_VALUE2(FUNCTION(gsl_vector,get)(v, i))); return ary; } static VALUE FUNCTION(rb_gsl_vector,reverse_bang)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,reverse)(v); return obj; } static VALUE FUNCTION(rb_gsl_vector,reverse)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_int_alloc failed"); FUNCTION(gsl_vector,memcpy)(vnew, v); FUNCTION(gsl_vector,reverse)(vnew); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,max)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return C_TO_VALUE2(FUNCTION(gsl_vector,max)(v)); } static VALUE FUNCTION(rb_gsl_vector,min)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return C_TO_VALUE2(FUNCTION(gsl_vector,min)(v)); } static VALUE FUNCTION(rb_gsl_vector,minmax)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; BASE min, max; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,minmax)(v, &min, &max); return rb_ary_new3(2, C_TO_VALUE2(min), C_TO_VALUE2(max)); } static VALUE FUNCTION(rb_gsl_vector,maxmin)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; BASE min, max; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,minmax)(v, &min, &max); return rb_ary_new3(2, C_TO_VALUE2(max), C_TO_VALUE2(min)); } static VALUE FUNCTION(rb_gsl_vector,max_index)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX(FUNCTION(gsl_vector,max_index)(v)); } static VALUE FUNCTION(rb_gsl_vector,min_index)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX(FUNCTION(gsl_vector,min_index)(v)); } static VALUE FUNCTION(rb_gsl_vector,minmax_index)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t imin, imax; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,minmax_index)(v, &imin, &imax); return rb_ary_new3(2, INT2FIX(imin), INT2FIX(imax)); } static VALUE FUNCTION(rb_gsl_vector,maxmin_index)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t imin, imax; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,minmax_index)(v, &imin, &imax); return rb_ary_new3(2, INT2FIX(imax), INT2FIX(imin)); } static VALUE FUNCTION(rb_gsl_vector,isnull)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX(FUNCTION(gsl_vector,isnull)(v)); } static VALUE FUNCTION(rb_gsl_vector,isnull2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (FUNCTION(gsl_vector,isnull)(v)) return Qtrue; else return Qfalse; } static VALUE FUNCTION(rb_gsl_vector,trans)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(make_vector,clone)(v); #ifdef BASE_DOUBLE if (VECTOR_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); else return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, vnew); #elif defined(BASE_INT) if (VECTOR_INT_ROW_P(obj)) return Data_Wrap_Struct(cgsl_vector_int_col, 0, gsl_vector_int_free, vnew); else if (VECTOR_INT_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, vnew); else rb_raise(rb_eTypeError, "wrong type %s (Vector::Int or Vector::Int::Col expected)", rb_class2name(CLASS_OF(obj))); #endif return Qnil; } static VALUE FUNCTION(rb_gsl_vector,trans_bang)(VALUE obj) { #ifdef BASE_DOUBLE if (CLASS_OF(obj) == cgsl_vector) RBASIC(obj)->klass = cgsl_vector_col; else if (CLASS_OF(obj) == cgsl_vector_col) RBASIC(obj)->klass = cgsl_vector; else { rb_raise(rb_eRuntimeError, "method trans! for %s is not permitted.", rb_class2name(CLASS_OF(obj))); } #elif defined(BASE_INT) if (CLASS_OF(obj) == cgsl_vector_int) RBASIC(obj)->klass = cgsl_vector_int_col; else if (CLASS_OF(obj) == cgsl_vector_int_col) RBASIC(obj)->klass = cgsl_vector_int; else { rb_raise(rb_eRuntimeError, "method trans! for %s is not permitted.", rb_class2name(CLASS_OF(obj))); } #endif return obj; } static VALUE FUNCTION(rb_gsl_vector,uplus)(VALUE obj) { return obj; } EXTERN VALUE cgsl_poly; VALUE FUNCTION(rb_gsl_vector,uminus)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { FUNCTION(gsl_vector,set)(vnew, i, -FUNCTION(gsl_vector,get)(v, i)); } if (CLASS_OF(obj) == GSL_TYPE(cgsl_poly)) return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); else return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,sum)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; BASE sum = 0; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = 0; i < v->size; i++) sum += FUNCTION(gsl_vector,get)(v, i); return C_TO_VALUE2(sum); } /* Vector#sumsq is defined in blas1.c */ #ifdef BASE_INT static VALUE FUNCTION(rb_gsl_vector,sumsq)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; BASE sum = 0, x; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = 0; i < v->size; i++) { x = FUNCTION(gsl_vector,get)(v, i); sum += x*x; } return C_TO_VALUE2(sum); } #endif static VALUE FUNCTION(rb_gsl_vector,prod)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; BASE x = 1; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = 0; i < v->size; i++) x *= FUNCTION(gsl_vector,get)(v, i); return C_TO_VALUE(x); } static VALUE FUNCTION(rb_gsl_vector,connect)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; BASE *ptr = NULL; size_t i, total = 0; if (VEC_P(obj)) { Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); total += v->size; } for (i = 0; i < argc; i++) { CHECK_VEC(argv[i]); Data_Get_Struct(argv[i], GSL_TYPE(gsl_vector), v); total += v->size; } vnew = FUNCTION(gsl_vector,alloc)(total); ptr = vnew->data; if (VEC_P(obj)) { Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); memcpy(ptr, v->data, sizeof(BASE)*v->size); ptr += v->size; } for (i = 0; i < argc; i++) { Data_Get_Struct(argv[i], GSL_TYPE(gsl_vector), v); memcpy(ptr, v->data, sizeof(BASE)*v->size); ptr += v->size; } return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); } GSL_TYPE(gsl_vector)* FUNCTION(mygsl_vector,up)(GSL_TYPE(gsl_vector) *p) { GSL_TYPE(gsl_vector) *pnew; pnew = FUNCTION(gsl_vector,alloc)(p->size + 1); FUNCTION(gsl_vector,set)(pnew, 0, 0); memcpy(pnew->data+1, p->data, sizeof(BASE)*p->size); return pnew; } void FUNCTION(mygsl_vector,up2)(GSL_TYPE(gsl_vector) *pnew, GSL_TYPE(gsl_vector) *p) { FUNCTION(gsl_vector,set_all)(pnew, 0); memcpy(pnew->data+1, p->data, sizeof(BASE)*p->size); } GSL_TYPE(gsl_vector)* FUNCTION(mygsl_vector,down)(GSL_TYPE(gsl_vector) *p) { GSL_TYPE(gsl_vector) *pnew; if (p->size <= 1) { rb_raise(rb_eRangeError, "Length <= 1, cannot be shortened."); } pnew = FUNCTION(gsl_vector,alloc)(p->size - 1); memcpy(pnew->data, p->data + 1, sizeof(BASE)*(p->size-1)); return pnew; } static VALUE FUNCTION(rb_gsl_vector,sgn)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; BASE x; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { x = FUNCTION(gsl_vector,get)(v, i); FUNCTION(gsl_vector,set)(vnew, i, (BASE)(x>0 ? 1 : (x<0 ? -1 : 0))); } return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,abs)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { FUNCTION(gsl_vector,set)(vnew, i, (BASE) fabs(FUNCTION(gsl_vector,get)(v, i))); } return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,square)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { FUNCTION(gsl_vector,set)(vnew, i, gsl_pow_2(FUNCTION(gsl_vector,get)(v, i))); } return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,sqrt)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { FUNCTION(gsl_vector,set)(vnew, i, sqrt(FUNCTION(gsl_vector,get)(v, i))); } return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,memcpy)(VALUE obj, VALUE dest, VALUE src) { GSL_TYPE(gsl_vector) *vdest = NULL, *vsrc = NULL; Data_Get_Struct(dest, GSL_TYPE(gsl_vector), vdest); Data_Get_Struct(src, GSL_TYPE(gsl_vector), vsrc); FUNCTION(gsl_vector,memcpy)(vdest, vsrc); return dest; } static VALUE FUNCTION(rb_gsl_vector,clone)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); FUNCTION(gsl_vector,memcpy)(vnew, v); if (!VEC_VIEW_P(obj)) return Data_Wrap_Struct(CLASS_OF(obj), 0, FUNCTION(gsl_vector,free), vnew); else return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } /* singleton */ static VALUE FUNCTION(rb_gsl_vector,swap)(VALUE obj, VALUE vv, VALUE ww) { GSL_TYPE(gsl_vector) *v = NULL, *w = NULL; Data_Get_Struct(vv, GSL_TYPE(gsl_vector), v); Data_Get_Struct(ww, GSL_TYPE(gsl_vector), w); FUNCTION(gsl_vector,swap)(v, w); return obj; } static VALUE FUNCTION(rb_gsl_vector,swap_elements)(VALUE obj, VALUE i, VALUE j) { GSL_TYPE(gsl_vector) *v = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,swap_elements)(v, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE FUNCTION(rb_gsl_vector,fwrite)(VALUE obj, VALUE io) { GSL_TYPE(gsl_vector) *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), h); f = rb_gsl_open_writefile(io, &flag); status = FUNCTION(gsl_vector,fwrite)(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_vector,fread)(VALUE obj, VALUE io) { GSL_TYPE(gsl_vector) *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), h); f = rb_gsl_open_readfile(io, &flag); status = FUNCTION(gsl_vector,fread)(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_vector,fprintf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *h = NULL; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 2) { if (TYPE(argv[1]) == T_STRING) status = FUNCTION(gsl_vector,fprintf)(fp, h, STR2CSTR(argv[1])); else rb_raise(rb_eTypeError, "argv 2 String expected"); } else { status = FUNCTION(gsl_vector,fprintf)(fp, h, "%g"); } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_vector,printf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *h = NULL; int status; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), h); if (argc == 1) { if (TYPE(argv[0]) != T_STRING) rb_raise(rb_eTypeError, "String expected"); else status = FUNCTION(gsl_vector,fprintf)(stdout, h, STR2CSTR(argv[0])); } else { status = FUNCTION(gsl_vector,fprintf)(stdout, h, "%g"); } return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_vector,fscanf)(VALUE obj, VALUE io) { GSL_TYPE(gsl_vector) *h = NULL; FILE *fp = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), h); fp = rb_gsl_open_readfile(io, &flag); status = FUNCTION(gsl_vector,fscanf)(fp, h); if (flag == 1) fclose(fp); return INT2FIX(status); } /* 2.Aug.2004 */ VALUE FUNCTION(rb_gsl_vector,inner_product)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *v2 = NULL; BASE prod = 0; #ifndef BASE_DOUBLE size_t i; #endif switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_VEC(argv[0]); CHECK_VEC(argv[1]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); Data_Get_Struct(argv[1], GSL_TYPE(gsl_vector), v2); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_VEC(argv[0]); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v2); break; } if (v->size != v2->size) rb_raise(rb_eRangeError, "vector lengths are different."); #ifdef BASE_DOUBLE gsl_blas_ddot(v, v2, &prod); #else for (i = 0; i < v->size; i++) { prod += FUNCTION(gsl_vector,get)(v, i)*FUNCTION(gsl_vector,get)(v2, i); } #endif return C_TO_VALUE2(prod); } int FUNCTION(rbgsl_vector,equal)(const GSL_TYPE(gsl_vector) *v1, const GSL_TYPE(gsl_vector) *v2, double eps) { size_t i; BASE x, y; if (v1->size != v2->size) return 0; for (i = 0; i < v2->size; i++) { x = FUNCTION(gsl_vector,get)(v1, i); y = FUNCTION(gsl_vector,get)(v2, i); if (fabs(x - y) > eps) return 0; } return 1; } #ifdef HAVE_TENSOR_TENSOR_H EXTERN VALUE cgsl_tensor, cgsl_tensor_int; VALUE rb_gsl_tensor_equal(int argc, VALUE *argv, VALUE obj); VALUE rb_gsl_tensor_int_equal(int argc, VALUE *argv, VALUE obj); #ifdef BASE_DOUBLE #define TEN_P(x) TENSOR_P(x) #else #define TEN_P(x) TENSOR_INT_P(x) #endif #endif static VALUE FUNCTION(rb_gsl_vector,equal)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v1, *v2; VALUE other; size_t i; double eps = 1e-10; double x; switch (argc) { case 2: other = argv[0]; eps = NUM2DBL(argv[1]); break; case 1: other = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } #ifdef HAVE_TENSOR_TENSOR_H if (TEN_P(other)) { return FUNCTION(rb_gsl_tensor,equal)(argc, argv, obj); } #endif switch (TYPE(other)) { case T_FIXNUM: case T_FLOAT: x = NUM2DBL(other); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v1); for (i = 0; i < v1->size; i++) if (fabs(x-FUNCTION(gsl_vector,get)(v1, i)) > eps) return Qfalse; return Qtrue; break; default: CHECK_VEC(other); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v1); Data_Get_Struct(other, GSL_TYPE(gsl_vector), v2); if (FUNCTION(rbgsl_vector,equal)(v1, v2, eps)) return Qtrue; else return Qfalse; break; } return Qnil; } #ifdef HAVE_TENSOR_TENSOR_H #ifdef TEN_P #undef TEN_P #endif #endif static VALUE FUNCTION(rb_gsl_vector,to_poly)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; GSL_TYPE(gsl_poly) *p = NULL; if (CLASS_OF(obj) == GSL_TYPE(cgsl_poly)) return obj; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); p = FUNCTION(make_vector,clone)(v); return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), p); } static VALUE FUNCTION(rb_gsl_vector,graph)(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH GSL_TYPE(gsl_vector) *x = NULL, *y = NULL; FILE *fp = NULL; size_t i; char command[1024]; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), y); switch (argc) { case 0: strcpy(command, "graph -T X -g 3"); break; case 1: if (TYPE(argv[0]) == T_STRING) { make_graphcommand(command, argv[0]); } else if (VEC_P(argv[0])) { strcpy(command, "graph -T X -g 3"); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), x); } else { } break; case 2: if (TYPE(argv[1]) == T_STRING) { make_graphcommand(command, argv[1]); if (VEC_P(argv[0])) { Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), x); } else { rb_raise(rb_eTypeError, "argv[0] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } } else { rb_raise(rb_eTypeError, "argv[1] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[1]))); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } if (y == NULL) rb_raise(rb_eRuntimeError, "ydata not given"); fp = popen(command, "w"); for (i = 0; i < y->size; i++) { if (x == NULL) fprintf(fp, "%d %e\n", (int) i, (double) FUNCTION(gsl_vector,get)(y, i)); else fprintf(fp, "%e %e\n", (double) FUNCTION(gsl_vector,get)(x, i), (double) FUNCTION(gsl_vector,get)(y, i)); } fflush(fp); pclose(fp); fp = NULL; return Qtrue; #else rb_raise(rb_eNoMethodError, "not implemented"); return Qfalse; #endif } static VALUE FUNCTION(rb_gsl_vector,graph_step)(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH GSL_TYPE(gsl_vector) *x = NULL, *y = NULL; FILE *fp = NULL; size_t i; char command[1024]; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), y); switch (argc) { case 0: strcpy(command, "graph -T X -g 3"); break; case 1: if (TYPE(argv[0]) == T_STRING) { make_graphcommand(command, argv[0]); } else if (VECTOR_P(argv[0])) { strcpy(command, "graph -T X -g 3"); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), x); } else { } break; case 2: if (TYPE(argv[1]) == T_STRING) { make_graphcommand(command, argv[1]); if (VEC_P(argv[0])) { Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), x); } else { rb_raise(rb_eTypeError, "argv[0] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } } else { rb_raise(rb_eTypeError, "argv[1] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[1]))); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } if (y == NULL) rb_raise(rb_eRuntimeError, "ydata not given"); fp = popen(command, "w"); for (i = 0; i < y->size; i++) { if (x == NULL) { fprintf(fp, "%d %e\n%d %e\n", (int) i, (double) FUNCTION(gsl_vector,get)(y, i), (int) (i+1), (double) FUNCTION(gsl_vector,get)(y, i)); } else { if (i != y->size-1) fprintf(fp, "%e %e\n%e %e\n", (double) FUNCTION(gsl_vector,get)(x, i), (double) FUNCTION(gsl_vector,get)(y, i), (double) FUNCTION(gsl_vector,get)(x, i+1), (double) FUNCTION(gsl_vector,get)(y, i)); else fprintf(fp, "%e %e\n%e %e", (double) FUNCTION(gsl_vector,get)(x, i), (double) FUNCTION(gsl_vector,get)(y, i), 2.0*FUNCTION(gsl_vector,get)(x, i)-FUNCTION(gsl_vector,get)(x, i-1), (double) FUNCTION(gsl_vector,get)(y, i)); } } fflush(fp); pclose(fp); fp = NULL; return Qtrue; #else rb_raise(rb_eNoMethodError, "not implemented"); return Qfalse; #endif } static VALUE FUNCTION(rb_gsl_vector,plot)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *x = NULL, *y = NULL; FILE *fp = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), y); fp = popen("gnuplot -persist", "w"); switch (argc) { case 0: fprintf(fp, "plot '-'\n"); break; case 1: if (TYPE(argv[0]) == T_STRING) { fprintf(fp, "plot '-' %s\n", STR2CSTR(argv[0])); } else if (VEC_P(argv[0])) { fprintf(fp, "plot '-'\n"); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), x); } else { rb_raise(rb_eTypeError, "wrong argument type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } break; case 2: if (TYPE(argv[1]) == T_STRING) fprintf(fp, "plot '-' %s\n", STR2CSTR(argv[1])); if (VEC_P(argv[0])) Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), x); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } if (y == NULL) rb_raise(rb_eRuntimeError, "ydata not given"); for (i = 0; i < y->size; i++) { if (x == NULL) fprintf(fp, "%d %e\n", (int) i, (double) FUNCTION(gsl_vector,get)(y, i)); else fprintf(fp, "%e %e\n", (double) FUNCTION(gsl_vector,get)(x, i), (double) FUNCTION(gsl_vector,get)(y, i)); } fprintf(fp, "e\n"); fflush(fp); pclose(fp); fp = NULL; return Qtrue; } void FUNCTION(gsl_vector,print)(const GSL_TYPE(gsl_vector) *v, VALUE klass) { size_t i; printf("[ "); if (klass == cgsl_vector_col || klass == cgsl_vector_col_view || klass == cgsl_vector_col_view_ro || klass == cgsl_vector_int_col || klass == cgsl_vector_int_col_view || klass == cgsl_vector_int_col_view_ro) { printf(PRINTF_FORMAT, FUNCTION(gsl_vector,get)(v, 0)); for (i = 1; i < v->size; i++) { printf(PRINTF_FORMAT, FUNCTION(gsl_vector,get)(v, i)); if (i != v->size-1) printf("\n"); } } else { for (i = 0; i < v->size; i++) printf(PRINTF_FORMAT, FUNCTION(gsl_vector,get)(v, i)); } printf("]\n"); } VALUE FUNCTION(rb_gsl_vector,print)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,print)(v, CLASS_OF(obj)); return Qnil; } #ifdef BASE_DOUBLE #define SHOW_ELM 6 #else #define SHOW_ELM 15 #endif VALUE FUNCTION(rb_gsl_vector,to_s)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; char buf[32], format[32], format2[32]; size_t i; VALUE str; BASE x; int dig = 8; #ifdef BASE_INT BASE min; BASE max; dig = 1; #endif Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->size == 0) return rb_str_new2("[ ]"); str = rb_str_new2("[ "); if (VEC_COL_P(obj)) { #ifdef BASE_INT min = FUNCTION(gsl_vector,min)(v); max = gsl_vector_int_max(v); dig = (int) GSL_MAX(fabs(max),fabs(min)); if (dig > 0) dig = ceil(log10(dig+1e-10)); else dig = 1; if (min < 0) dig += 1; sprintf(format, "%%%dd ", (int) dig); strcpy(format2, format); #else strcpy(format, PRINTF_FORMAT); strcpy(format2, " "PRINTF_FORMAT); #endif for (i = 0; i < v->size; i++) { if (i != 0) { strcpy(buf, " "); rb_str_cat(str, buf, strlen(buf)); } x = FUNCTION(gsl_vector,get)(v, i); if (x < 0) sprintf(buf, format, x); else sprintf(buf, format2, x); if (i != v->size-1) strcat(buf, "\n"); rb_str_cat(str, buf, strlen(buf)); if (i >= 20 && i != v->size-1) { strcpy(buf, " ..."); rb_str_cat(str, buf, strlen(buf)); break; } } } else { sprintf(buf, PRINTF_FORMAT, FUNCTION(gsl_vector,get)(v, 0)); rb_str_cat(str, buf, strlen(buf)); for (i = 1; i < v->size; i++) { sprintf(buf, PRINTF_FORMAT, FUNCTION(gsl_vector,get)(v, i)); rb_str_cat(str, buf, strlen(buf)); if (i >= (55/dig) && i != v->size-1) { strcpy(buf, "... "); rb_str_cat(str, buf, strlen(buf)); break; } } } sprintf(buf, "]"); rb_str_cat(str, buf, strlen(buf)); return str; } #undef SHOW_ELM static VALUE FUNCTION(rb_gsl_vector,inspect)(VALUE obj) { VALUE str; char buf[64]; sprintf(buf, "%s\n", rb_class2name(CLASS_OF(obj))); str = rb_str_new2(buf); return rb_str_concat(str, FUNCTION(rb_gsl_vector,to_s)(obj)); } static VALUE FUNCTION(rb_gsl_vector,subvector)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; size_t offset, stride, n; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); parse_subvector_args(argc, argv, v->size, &offset, &stride, &n); vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_vector,subvector_with_stride)(v, offset, stride, n); if (VEC_COL_P(obj)) return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,col_view), 0, free, vv); else return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, vv); } static VALUE FUNCTION(rb_gsl_vector,subvector_with_stride)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; int offset = 0, step, length; size_t stride = 1, n; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (argc) { case 1: CHECK_FIXNUM(argv[0]); step = FIX2INT(argv[0]); if(step == 0) { rb_raise(rb_eArgError, "stride must be non-zero"); } stride = (size_t)step; //n = v->size/stride; n = (v->size-1)/stride + 1; break; case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); offset = FIX2INT(argv[0]); step = FIX2INT(argv[1]); if(offset < 0) { offset += v->size; if(offset < 0) { rb_raise(rb_eRangeError, "offset %d out of range", offset - (int)v->size); } } else if(offset >= v->size) { rb_raise(rb_eRangeError, "offset %d out of range", offset); } if(step == 0) { rb_raise(rb_eArgError, "stride must be non-zero"); } stride = (size_t)step; //n = (v->size-(size_t)offset)/stride; n = (v->size-(size_t)offset-1)/stride + 1; break; case 3: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); offset = FIX2INT(argv[0]); step = FIX2INT(argv[1]); length = FIX2INT(argv[2]); if(offset < 0) { offset += v->size; if(offset < 0) { rb_raise(rb_eRangeError, "offset %d out of range", offset - (int)v->size); } } if(step == 0) { rb_raise(rb_eArgError, "stride must be non-zero"); } if(length < 0) { rb_raise(rb_eArgError, "length must be non-negative"); } stride = (size_t)step; n = (size_t)length; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 - 3)", argc); break; } vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_vector,subvector_with_stride)(v, (size_t)offset, stride, n); if (VEC_COL_P(obj)) return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,col_view), 0, free, vv); else return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, vv); } static VALUE FUNCTION(rb_gsl_vector,matrix_view)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; QUALIFIED_VIEW(gsl_matrix,view) *mv = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (argc) { case 2: mv = ALLOC(QUALIFIED_VIEW(gsl_matrix,view)); *mv = FUNCTION(gsl_matrix,view_vector)(v, FIX2INT(argv[0]), FIX2INT(argv[1])); break; case 3: mv = ALLOC(QUALIFIED_VIEW(gsl_matrix,view)); *mv = FUNCTION(gsl_matrix,view_vector_with_tda)(v, FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2])); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_matrix,view), 0, free, mv); } static VALUE FUNCTION(rb_gsl_vector,matrix_view_with_tda)(VALUE obj, VALUE nn1, VALUE nn2, VALUE tda) { GSL_TYPE(gsl_vector) *v = NULL; QUALIFIED_VIEW(gsl_matrix,view) *mv = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); mv = ALLOC(QUALIFIED_VIEW(gsl_matrix,view)); *mv = FUNCTION(gsl_matrix,view_vector_with_tda)(v, FIX2INT(nn1), FIX2INT(nn2), FIX2INT(tda)); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_matrix,view), 0, free, mv); } void FUNCTION(mygsl_vector,shift)(GSL_TYPE(gsl_vector) *p, size_t n) { size_t i; for (i = n; i >= 0; i--) { FUNCTION(gsl_vector,set)(p, i+1, FUNCTION(gsl_vector,get)(p, i)); if (i == 0) break; } FUNCTION(gsl_vector,set)(p, 0, 0); } void FUNCTION(mygsl_vector,shift_scale2)(GSL_TYPE(gsl_vector) *p, size_t n) { size_t i; for (i = n; i >= 0; i--) { FUNCTION(gsl_vector,set)(p, i+1, 2*FUNCTION(gsl_vector,get)(p, i)); if (i == 0) break; } FUNCTION(gsl_vector,set)(p, 0, 0); } GSL_TYPE(gsl_vector)* FUNCTION(make_vector,clone)(const GSL_TYPE(gsl_vector) *v) { GSL_TYPE(gsl_vector) *vnew = NULL; vnew = FUNCTION(gsl_vector,alloc)(v->size); if (v->stride == 1) memcpy(vnew->data, v->data, sizeof(BASE)*v->size); else FUNCTION(gsl_vector,memcpy)(vnew, v); return vnew; } VALUE FUNCTION(rb_gsl_vector,scale)(VALUE obj, VALUE x) { GSL_TYPE(gsl_vector) *v, *vnew; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(make_vector,clone)(v); FUNCTION(gsl_vector,scale)(vnew, NUMCONV(x)); // return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } VALUE FUNCTION(rb_gsl_vector,scale_bang)(VALUE obj, VALUE x) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,scale)(v, NUMCONV(x)); return obj; } VALUE FUNCTION(rb_gsl_vector,add_constant)(VALUE obj, VALUE x) { GSL_TYPE(gsl_vector) *v, *vnew; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(make_vector,clone)(v); FUNCTION(gsl_vector,add_constant)(vnew, NUMCONV(x)); // return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } VALUE FUNCTION(rb_gsl_vector,add_constant_bang)(VALUE obj, VALUE x) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(gsl_vector,add_constant)(v, NUMCONV(x)); return obj; } QUALIFIED_VIEW(gsl_vector,view)* FUNCTION(rb_gsl_make_vector,view)(BASE *data, size_t size, size_t stride) { QUALIFIED_VIEW(gsl_vector,view) *v = NULL; v = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); v->vector.size = size; v->vector.stride = stride; v->vector.owner = 0; v->vector.data = data; return v; } #ifdef HAVE_TENSOR_TENSOR_H #include "rb_gsl_tensor.h" static VALUE FUNCTION(rb_gsl_vector,to_tensor)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; GSL_TYPE(rbgsl_tensor) *t; unsigned int rank; size_t dim; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (argc) { case 0: rank = 1; dim = v->size; break; case 2: rank = FIX2UINT(argv[0]); dim = FIX2UINT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 2)", argc); break; } t = FUNCTION(rbgsl_tensor,alloc)(rank, dim); memcpy(t->tensor->data, v->data, sizeof(BASE)*v->size); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), t); } #endif #ifdef BASE_DOUBLE #define PRINTF_FORMAT2 "%g " #else #define PRINTF_FORMAT2 "%d " #endif static VALUE FUNCTION(rb_gsl_vector,to_gplot)(int argc, VALUE *argv, VALUE obj) { char buf[1024] = ""; size_t i, j, len = 0, nv, istart; VALUE str, tmp; GSL_TYPE(gsl_vector) *v, **vp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "no vectors given"); if (TYPE(argv[0]) == T_ARRAY) nv = RARRAY_LEN(argv[0]); else nv = argc; vp = (GSL_TYPE(gsl_vector)**) ALLOC_N(GSL_TYPE(gsl_vector)*, nv); istart = 0; break; default: CHECK_VEC(obj); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (argc >= 1 && TYPE(argv[0]) == T_ARRAY) nv = 1 + RARRAY_LEN(argv[0]); else nv = argc + 1; vp = (GSL_TYPE(gsl_vector)**) ALLOC_N(GSL_TYPE(gsl_vector)*, nv); vp[0] = v; len = v->size; istart = 1; break; } for (i = 0; i < argc; i++) { if (TYPE(argv[0]) == T_ARRAY) tmp = rb_ary_entry(argv[0], i); else tmp = argv[i]; CHECK_VEC(tmp); Data_Get_Struct(tmp, GSL_TYPE(gsl_vector), v); if (len == 0) len = v->size; if (len != v->size) rb_raise(rb_eRuntimeError, "vectors must have equal lengths"); vp[i+istart] = v; } str = rb_str_new2(buf); for (j = 0; j < len; j++) { for (i = 0; i < nv; i++) { sprintf(buf, PRINTF_FORMAT2, FUNCTION(gsl_vector,get)(vp[i], j)); rb_str_buf_cat(str, buf, strlen(buf)); } rb_str_buf_cat2(str, "\n"); } rb_str_buf_cat2(str, "\n"); free((GSL_TYPE(gsl_vector)**)vp); return str; } #undef PRINTF_FORMAT2 static VALUE FUNCTION(rb_gsl_vector,to_m_diagonal)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; GSL_TYPE(gsl_matrix) *m = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); m = FUNCTION(gsl_matrix,calloc)(v->size, v->size); for (i = 0; i < v->size; i++) FUNCTION(gsl_matrix,set)(m, i, i, FUNCTION(gsl_vector,get)(v, i)); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_vector,collect)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { FUNCTION(gsl_vector,set)(vnew, i, NUMCONV(rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i))))); } return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); } /* 2004/May/03 */ static VALUE FUNCTION(rb_gsl_vector,collect_bang)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); for (i = 0; i < v->size; i++) { FUNCTION(gsl_vector,set)(v, i, NUMCONV(rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i))))); } return obj; } /* Modified 2006/Sep/26 */ GSL_TYPE(gsl_vector)* FUNCTION(mygsl_vector,mul_matrix)(GSL_TYPE(gsl_vector) *v, GSL_TYPE(gsl_matrix) *m) { GSL_TYPE(gsl_vector) *vnew; size_t i, j; BASE sum; if (v->size != m->size1) rb_raise(rb_eRuntimeError, "vector/matrix sizes are different."); vnew = FUNCTION(gsl_vector,alloc)(m->size2); for (i = 0; i < m->size2; i++) { sum = 0; for (j = 0; j < m->size1; j++) { sum += FUNCTION(gsl_vector,get)(v, j)*FUNCTION(gsl_matrix,get)(m, j, i); } FUNCTION(gsl_vector,set)(vnew, i, sum); } return vnew; } void FUNCTION(mygsl_vector,to_m_circulant)(GSL_TYPE(gsl_matrix) *m, GSL_TYPE(gsl_vector) *v) { size_t i, j; for (i = v->size-1; i >= 0; i--) { for (j = 0; j < v->size; j++) { if (j <= i) FUNCTION(gsl_matrix,set)(m, i, j, FUNCTION(gsl_vector,get)(v, v->size-1-i+j)); else FUNCTION(gsl_matrix,set)(m, i, j, FUNCTION(gsl_vector,get)(v, j-i-1)); } if (i == 0) break; } } static VALUE FUNCTION(rb_gsl_vector,to_m_circulant)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); m = FUNCTION(gsl_matrix,alloc)(v->size, v->size); FUNCTION(mygsl_vector,to_m_circulant)(m, v); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } static void FUNCTION(mygsl_vector,indgen)(GSL_TYPE(gsl_vector) *v, BASE start, BASE step) { size_t k = 0; BASE i; i = start; for (k = 0; k < v->size; k++) { FUNCTION(gsl_vector,set)(v, k, i); i += step; } } static VALUE FUNCTION(rb_gsl_vector,indgen_singleton)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t n; BASE start = 0, step = 1; switch (argc) { case 3: step = NUMCONV2(argv[2]); /* no break */ case 2: start = NUMCONV2(argv[1]); /* no break */ case 1: n = NUM2INT(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-3)", argc); break; } v = FUNCTION(gsl_vector,alloc)(n); FUNCTION(mygsl_vector,indgen)(v, start, step); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), v); } static VALUE FUNCTION(rb_gsl_vector,indgen)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v, *vnew; BASE start = 0, step = 1; switch (argc) { case 2: step = NUMCONV2(argv[1]); /* no break */ case 1: start = NUMCONV2(argv[0]); break; case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); FUNCTION(mygsl_vector,indgen)(vnew, start, step); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,indgen_bang)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; BASE start = 0, step = 1; switch (argc) { case 2: step = NUMCONV2(argv[1]); /* no break */ case 1: start = NUMCONV2(argv[0]); break; case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); FUNCTION(mygsl_vector,indgen)(v, start, step); return obj; } static VALUE FUNCTION(rb_gsl_vector,to_m)(VALUE obj, VALUE ii, VALUE jj) { GSL_TYPE(gsl_matrix) *m; GSL_TYPE(gsl_vector) *v = NULL; size_t i, j, n; CHECK_FIXNUM(ii); CHECK_FIXNUM(jj); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); i = (size_t) FIX2INT(ii); j = (size_t) FIX2INT(jj); n = i*j; m = FUNCTION(gsl_matrix,alloc)(i, j); memcpy(m->data, v->data, sizeof(BASE)*v->size); for (i = n; i < v->size; i++) m->data[i] = (BASE) 0; return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_vector,block)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return Data_Wrap_Struct(GSL_TYPE(cgsl_block), 0, NULL, v->block); } /*****/ static VALUE GSL_TYPE(rb_gsl_sort_vector)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); GSL_TYPE(gsl_sort_vector)(v); return obj; } static VALUE GSL_TYPE(rb_gsl_sort_vector2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); FUNCTION(gsl_vector,memcpy)(vnew, v); GSL_TYPE(gsl_sort_vector)(vnew); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_sort_vector,index)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_index *p = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); p = gsl_permutation_alloc(v->size); FUNCTION(gsl_sort_vector,index)(p, v); return Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, p); } static VALUE FUNCTION(rb_gsl_sort_vector,smallest)(VALUE obj, VALUE kk) { GSL_TYPE(gsl_vector) *v = NULL, *v2 = NULL; size_t k; CHECK_FIXNUM(kk); k = FIX2INT(kk); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); v2 = FUNCTION(gsl_vector,alloc)(k); FUNCTION(gsl_sort_vector,smallest)(v2->data, k, v); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), v2); } static VALUE FUNCTION(rb_gsl_sort_vector,largest)(VALUE obj, VALUE kk) { GSL_TYPE(gsl_vector) *v = NULL, *v2 = NULL; size_t k; CHECK_FIXNUM(kk); k = FIX2INT(kk); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); v2 = FUNCTION(gsl_vector,alloc)(k); FUNCTION(gsl_sort_vector,largest)(v2->data, k, v); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), v2); } static VALUE FUNCTION(rb_gsl_sort_vector,smallest_index)(VALUE obj, VALUE kk) { GSL_TYPE(gsl_vector) *v = NULL; gsl_index *p = NULL; size_t k; CHECK_FIXNUM(kk); k = FIX2INT(kk); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); p = gsl_permutation_alloc(k); FUNCTION(gsl_sort_vector,smallest_index)(p->data, k, v); return Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, p); } static VALUE FUNCTION(rb_gsl_sort_vector,largest_index)(VALUE obj, VALUE kk) { GSL_TYPE(gsl_vector) *v = NULL; gsl_index *p = NULL; size_t k; CHECK_FIXNUM(kk); k = FIX2INT(kk); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); p = gsl_permutation_alloc(k); FUNCTION(gsl_sort_vector,largest_index)(p->data, k, v); return Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, p); } static VALUE FUNCTION(rb_gsl_vector,histogram)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_histogram *h; gsl_vector *ranges; double min, max; size_t i, n; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (argc) { case 1: if (rb_obj_is_kind_of(argv[0], rb_cRange)) argv[0] = rb_gsl_range2ary(argv[0]); switch (TYPE(argv[0])) { case T_FIXNUM: n = NUM2INT(argv[0]); min = FUNCTION(gsl_vector,min)(v) - 4*GSL_DBL_EPSILON; max = FUNCTION(gsl_vector,max)(v) + 4*GSL_DBL_EPSILON; h = gsl_histogram_alloc(n); gsl_histogram_set_ranges_uniform(h, min, max); break; case T_ARRAY: n = RARRAY_LEN(argv[0]) - 1; h = gsl_histogram_alloc(n); for (i = 0; i <= n; i++) h->range[i] = NUM2DBL(rb_ary_entry(argv[0], i)); break; default: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, ranges); n = ranges->size - 1; h = gsl_histogram_alloc(n); gsl_histogram_set_ranges(h, ranges->data, ranges->size); break; } break; case 2: n = NUM2INT(argv[0]); switch (TYPE(argv[1])) { case T_ARRAY: min = NUM2DBL(rb_ary_entry(argv[1], 0)); max = NUM2DBL(rb_ary_entry(argv[1], 1)); break; default: rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[1]))); break; } h = gsl_histogram_alloc(n); gsl_histogram_set_ranges_uniform(h, min, max); break; case 3: n = NUM2INT(argv[0]); min = NUM2DBL(argv[1]); max = NUM2DBL(argv[2]); h = gsl_histogram_alloc(n); gsl_histogram_set_ranges_uniform(h, min, max); break; default: rb_raise(rb_eArgError, "wrong number of arguments %d", argc); break; } for (i = 0; i < v->size; i++) gsl_histogram_increment(h, FUNCTION(gsl_vector,get)(v, i)); return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, h); } static VALUE FUNCTION(rb_gsl_vector,last)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return C_TO_VALUE(FUNCTION(gsl_vector,get)(v, v->size-1)); } static VALUE FUNCTION(rb_gsl_vector,first)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return C_TO_VALUE(FUNCTION(gsl_vector,get)(v, 0)); } static VALUE FUNCTION(rb_gsl_vector,concat)(VALUE obj, VALUE other) { GSL_TYPE(gsl_vector) *v = NULL, *v2 = NULL, *vnew = NULL; QUALIFIED_VIEW(gsl_vector,view) vv; VALUE x; BASE beg, end; int step; size_t i, size2; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch(TYPE(other)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: vnew = FUNCTION(gsl_vector,alloc)(v->size + 1); vv = FUNCTION(gsl_vector,subvector)(vnew, 0, v->size); FUNCTION(gsl_vector,memcpy)(&vv.vector, v); FUNCTION(gsl_vector,set)(vnew, v->size, NUMCONV2(other)); break; case T_ARRAY: size2 = RARRAY_LEN(other); vnew = FUNCTION(gsl_vector,alloc)(v->size + size2); vv = FUNCTION(gsl_vector,subvector)(vnew, 0, v->size); FUNCTION(gsl_vector,memcpy)(&vv.vector, v); for (i = 0; i < size2; i++) { x = rb_ary_entry(other, i); FUNCTION(gsl_vector,set)(vnew, v->size + i, NUMCONV2(x)); } break; default: if(rb_obj_is_kind_of(other, rb_cRange)) { FUNCTION(get_range,beg_en_n)(other, &beg, &end, &size2, &step); vnew = FUNCTION(gsl_vector,alloc)(v->size + size2); vv = FUNCTION(gsl_vector,subvector)(vnew, 0, v->size); FUNCTION(gsl_vector,memcpy)(&vv.vector, v); for (i = 0; i < size2; i++) { FUNCTION(gsl_vector,set)(vnew, v->size + i, beg); beg += step; } } else if (rb_obj_is_kind_of(other, GSL_TYPE(cgsl_vector))) { Data_Get_Struct(other, GSL_TYPE(gsl_vector), v2); size2 = v2->size; vnew = FUNCTION(gsl_vector,alloc)(v->size + size2); vv = FUNCTION(gsl_vector,subvector)(vnew, 0, v->size); FUNCTION(gsl_vector,memcpy)(&vv.vector, v); vv = FUNCTION(gsl_vector,subvector)(vnew, v->size, size2); FUNCTION(gsl_vector,memcpy)(&vv.vector, v2); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array, Numeric, Range, or %s expected)", rb_class2name(CLASS_OF(other)), rb_class2name(GSL_TYPE(cgsl_vector))); } break; } return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } void FUNCTION(mygsl_vector,diff)(GSL_TYPE(gsl_vector) *vdst, GSL_TYPE(gsl_vector) *vsrc, size_t n) { BASE a, b; int coef, fac, nn, ff; size_t i, k; nn = gsl_sf_fact((unsigned int) n); if (GSL_IS_EVEN(n)) ff = 1; else ff = -1; for (i = 0; i < vsrc->size-n; i++) { fac = ff; a = 0; for (k = 0; k <= n; k++) { b = FUNCTION(gsl_vector,get)(vsrc, i+k); coef = nn/gsl_sf_fact(k)/gsl_sf_fact(n-k); a += fac*coef*b; fac *= -1; } FUNCTION(gsl_vector,set)(vdst, i, a); } } static VALUE FUNCTION(rb_gsl_vector,diff)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; size_t n; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (argc) { case 0: n = 1; break; case 1: n = FIX2INT(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } if (n <= 0) return obj; if (v->size <= n) return obj; vnew = FUNCTION(gsl_vector,alloc)(v->size - n); FUNCTION(mygsl_vector,diff)(vnew, v, n); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,test)(VALUE obj, int (*f)(const double)) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector_int *vi = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vi = gsl_vector_int_alloc(v->size); for (i = 0; i < v->size; i++) gsl_vector_int_set(vi, i, (*f)(FUNCTION(gsl_vector,get)(v, i))); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, vi); } static VALUE FUNCTION(rb_gsl_vector,test2)(VALUE obj, int (*f)(const double)) { GSL_TYPE(gsl_vector) *v = NULL; VALUE ary; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); ary = rb_ary_new2(v->size); for (i = 0; i < v->size; i++) { if ((*f)(FUNCTION(gsl_vector,get)(v, i))) rb_ary_store(ary, i, Qtrue); else rb_ary_store(ary, i, Qfalse); } return ary; } static VALUE FUNCTION(rb_gsl_vector,isnan)(VALUE obj) { return FUNCTION(rb_gsl_vector,test)(obj, gsl_isnan); } static VALUE FUNCTION(rb_gsl_vector,isinf)(VALUE obj) { return FUNCTION(rb_gsl_vector,test)(obj, gsl_isinf); } static VALUE FUNCTION(rb_gsl_vector,finite)(VALUE obj) { return FUNCTION(rb_gsl_vector,test)(obj, gsl_finite); } static VALUE FUNCTION(rb_gsl_vector,isnan2)(VALUE obj) { return FUNCTION(rb_gsl_vector,test2)(obj, gsl_isnan); } static VALUE FUNCTION(rb_gsl_vector,isinf2)(VALUE obj) { return FUNCTION(rb_gsl_vector,test2)(obj, gsl_isinf); } static VALUE FUNCTION(rb_gsl_vector,finite2)(VALUE obj) { return FUNCTION(rb_gsl_vector,test2)(obj, gsl_finite); } static VALUE FUNCTION(rb_gsl_vector,delete_at)(VALUE obj, VALUE ii) { int i2; size_t i; GSL_TYPE(gsl_vector) *v; BASE x; if (rb_obj_is_kind_of(obj,QUALIFIED_VIEW(cgsl_vector,view))) rb_raise(rb_eRuntimeError, "prohibited for %s", rb_class2name(CLASS_OF(obj))); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->stride != 1) rb_raise(rb_eRuntimeError, "vector must have stride 1"); if (v->size == 0) return Qnil; CHECK_FIXNUM(ii); i2 = FIX2INT(ii); if (i2 < 0) { i2 += v->size; } if (i2 < 0 || i2 > v->size-1) return Qnil; i = (size_t) i2; x = FUNCTION(gsl_vector,get)(v, i); memmove(v->data+i, v->data+i+1, sizeof(BASE)*(v->size-1-i)); v->size -= 1; return C_TO_VALUE(x); } static VALUE FUNCTION(rb_gsl_vector,delete_if)(VALUE obj) { GSL_TYPE(gsl_vector) *v; BASE x; VALUE val; size_t i, count = 0; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "block is not given"); if (rb_obj_is_kind_of(obj,QUALIFIED_VIEW(cgsl_vector,view))) rb_raise(rb_eRuntimeError, "prohibited for %s", rb_class2name(CLASS_OF(obj))); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->stride != 1) rb_raise(rb_eRuntimeError, "vector must have stride 1"); for (i = 0; i < v->size; i++) { x = FUNCTION(gsl_vector,get)(v, i); val = rb_yield(C_TO_VALUE(x)); if(RTEST(val)) { count++; } else if(count > 0) { FUNCTION(gsl_vector,set)(v, i-count, x); } } v->size -= count; return obj; } static VALUE FUNCTION(rb_gsl_vector,delete)(VALUE obj, VALUE yy) { GSL_TYPE(gsl_vector) *v; BASE x, y; size_t i, count = 0; y = NUMCONV(yy); if (rb_obj_is_kind_of(obj,QUALIFIED_VIEW(cgsl_vector,view))) rb_raise(rb_eRuntimeError, "prohibited for %s", rb_class2name(CLASS_OF(obj))); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->stride != 1) rb_raise(rb_eRuntimeError, "vector must have stride 1"); if (v->size == 0) return obj; for (i = 0; i < v->size; i++) { x = FUNCTION(gsl_vector,get)(v, i); if (x == y) { count++; } else if(count > 0) { FUNCTION(gsl_vector,set)(v, i-count, x); } } v->size -= count; return count ? y : Qnil; } /* singleton method */ #ifdef BASE_INT #define FORMAT_TMP "%d" #else #define FORMAT_TMP "%lf" #endif static VALUE FUNCTION(rb_gsl_vector,filescan)(VALUE klass, VALUE file) { FILE *fp = NULL; int nn, k; char buf[1024], filename[1024]; size_t n, lines, i, j, ii = 0, jj; long pos; GSL_TYPE(gsl_vector) **x; BASE val; VALUE ary; Check_Type(file, T_STRING); strcpy(filename, STR2CSTR(file)); sprintf(buf, "sed '/^#/d' %s | wc", filename); if ((fp = popen(buf, "r")) == NULL) rb_raise(rb_eIOError, "popen failed."); fgets(buf, 1024, fp); pclose(fp); sscanf(buf, "%d", &nn); lines = (size_t) nn; /* vector length */ if ((fp = fopen(filename, "r")) == NULL) rb_raise(rb_eIOError, "cannot open file %s.", filename); while (1) { fgets(buf, 1024, fp); /* read the first line to count number of columns */ if (buf[0] == '#') continue; else break; } n = count_columns(buf); /* number of vectors to be created */ x = (GSL_TYPE(gsl_vector)**) xmalloc(sizeof(GSL_TYPE(gsl_vector)*)*n); ary = rb_ary_new2(n); for (j = 0; j < n; j++) { x[j] = FUNCTION(gsl_vector,alloc)(lines); rb_ary_store(ary, j, Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), x[j])); } rewind(fp); for (i = 0, ii = 0; ii < lines; i++) { pos = ftell(fp); fgets(buf, 1024, fp); if (buf[0] == '#') continue; fseek(fp, pos, SEEK_SET); for (j = 0, jj = 0; jj < n; j++) { k = fscanf(fp, FORMAT_TMP, &val); if (k != 1) continue; FUNCTION(gsl_vector,set)(x[jj++], ii, val); } ii += 1; } fclose(fp); free(x); return ary; } #undef FORMAT_TMP static int FUNCTION(gsl_vector,eq)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x > y || x < y) ? 0 : 1; } return 0; } static int FUNCTION(gsl_vector,ne)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x > y || x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,gt)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x > y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,ge)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x >= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,lt)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,le)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x <= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,and)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x != 0 && y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,or)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = (x != 0 || y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,xor)(const GSL_TYPE(gsl_vector) *a, const GSL_TYPE(gsl_vector) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b->data[i*b->stride]; c->data[i] = ((x != 0) == (y != 0)) ? 0 : 1; } return 0; } static int FUNCTION(gsl_vector,eq2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x > y || x < y) ? 0 : 1; } return 0; } static int FUNCTION(gsl_vector,ne2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x > y || x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,gt2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x > y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,ge2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x >= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,lt2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,le2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x <= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,and2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x != 0 && y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,or2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = (x != 0 || y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_vector,xor2)(const GSL_TYPE(gsl_vector) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i*a->stride]; y = b; c->data[i] = ((x != 0) == (y != 0)) ? 0 : 1; } return 0; } static VALUE FUNCTION(rb_gsl_vector,compare)(VALUE aa, VALUE bb, int (*cmp)(const GSL_TYPE(gsl_vector)*, const GSL_TYPE(gsl_vector)*, gsl_block_uchar*), int (*cmp2)(const GSL_TYPE(gsl_vector)*, BASE, gsl_block_uchar*)) { GSL_TYPE(gsl_vector) *a, *b; /* gsl_vector_int *c;*/ gsl_block_uchar *c; //int status; Data_Get_Struct(aa, GSL_TYPE(gsl_vector), a); c = gsl_block_uchar_alloc(a->size); if (VEC_P(bb)) { Data_Get_Struct(bb, GSL_TYPE(gsl_vector), b); if (a->size != b->size) rb_raise(rb_eRuntimeError, "Vector size mismatch, %d and %d", (int) a->size, (int) b->size); /*status =*/ (*cmp)(a, b, c); } else { /*status =*/ (*cmp2)(a, NUMCONV(bb), c); } return Data_Wrap_Struct(cgsl_block_uchar, 0, gsl_block_uchar_free, c); } static VALUE FUNCTION(rb_gsl_vector,eq)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,eq), FUNCTION(gsl_vector,eq2)); } static VALUE FUNCTION(rb_gsl_vector,ne)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,ne), FUNCTION(gsl_vector,ne2)); } static VALUE FUNCTION(rb_gsl_vector,gt)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,gt), FUNCTION(gsl_vector,gt2)); } static VALUE FUNCTION(rb_gsl_vector,ge)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,ge), FUNCTION(gsl_vector,ge2)); } static VALUE FUNCTION(rb_gsl_vector,lt)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,lt), FUNCTION(gsl_vector,lt2)); } static VALUE FUNCTION(rb_gsl_vector,le)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,le), FUNCTION(gsl_vector,le2)); } static VALUE FUNCTION(rb_gsl_vector,and)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,and), FUNCTION(gsl_vector,and2)); } static VALUE FUNCTION(rb_gsl_vector,or)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,or), FUNCTION(gsl_vector,or2)); } static VALUE FUNCTION(rb_gsl_vector,xor)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_vector,compare)(aa, bb, FUNCTION(gsl_vector,xor), FUNCTION(gsl_vector,xor2)); } static VALUE FUNCTION(rb_gsl_vector,not)(VALUE obj) { GSL_TYPE(gsl_vector) *v; gsl_block_uchar *vv; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vv = gsl_block_uchar_alloc(v->size); for (i = 0; i < v->size; i++) vv->data[i] = (v->data[i*v->stride] != 0) ? 0 : 1; return Data_Wrap_Struct(cgsl_block_uchar, 0, gsl_block_uchar_free, vv); } static VALUE FUNCTION(rb_gsl_vector,any)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) { if (rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i)))) return INT2FIX(1); } return INT2FIX(0); } else { if (FUNCTION(gsl_vector,isnull)(v)) return INT2FIX(0); return INT2FIX(1); } } static VALUE FUNCTION(rb_gsl_vector,any2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) if (rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i)))) return Qtrue; return Qfalse; } else { for (i = 0; i < v->size; i++) if (v->data[i*v->stride]) return Qtrue; return Qfalse; } } static VALUE FUNCTION(rb_gsl_vector,none)(VALUE obj) { GSL_TYPE(gsl_vector) *v; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) if (rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i)))) return Qfalse; return Qtrue; } else { for (i = 0; i < v->size; i++) if (v->data[i*v->stride]) return Qfalse; return Qtrue; } } static VALUE FUNCTION(rb_gsl_vector,all)(VALUE obj) { GSL_TYPE(gsl_vector) *v; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) if (!rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i)))) return Qfalse; return Qtrue; } else { for (i = 0; i < v->size; i++) if (!v->data[i*v->stride]) return Qfalse; return Qtrue; } } static VALUE FUNCTION(rb_gsl_vector,where)(VALUE obj) { GSL_TYPE(gsl_vector) *v; gsl_index *vv; gsl_block_uchar *btmp = NULL; size_t i, j, n = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); /* count true elements */ if (rb_block_given_p()) { btmp = gsl_block_uchar_alloc(v->size); for (i = 0; i < v->size; i++) { if (rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i)))) { btmp->data[i] = 1; n++; } else { btmp->data[i] = 0; } } /* for */ } else { /* block is not given */ for (i = 0; i < v->size; i++) { if (FUNCTION(gsl_vector,get)(v, i)) n++; } } if (n == 0) { if (btmp) gsl_block_uchar_free(btmp); return Qnil; } vv = gsl_permutation_alloc(n); for (i = 0, j = 0; i < v->size; i++) { if ((!btmp && FUNCTION(gsl_vector,get)(v, i)) || (btmp && btmp->data[i])) { vv->data[j++] = i; } } if (btmp) gsl_block_uchar_free(btmp); return Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, vv); } static VALUE FUNCTION(rb_gsl_vector,where2)(VALUE obj) { GSL_TYPE(gsl_vector) *v; gsl_index *v1, *v2; gsl_block_uchar *btmp = NULL; VALUE vv1, vv2; size_t i, j, k, n = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (rb_block_given_p()) { btmp = gsl_block_uchar_alloc(v->size); for (i = 0; i < v->size; i++) { if (rb_yield(C_TO_VALUE(FUNCTION(gsl_vector,get)(v, i)))) { btmp->data[i] = 1; n++; } else { btmp->data[i] = 0; } } /* for */ } else { /* block is not given */ for (i = 0; i < v->size; i++) { if (FUNCTION(gsl_vector,get)(v, i)) n++; } } /* true and false logic. need to handle both */ if (n == 0) { v2 = gsl_permutation_calloc(v->size); /* calloc() initializes v2 */ vv1 = Qnil; vv2 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v2); } else if (v->size-n == 0) { v1 = gsl_permutation_calloc(n); /* calloc() initializes v1 */ vv1 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v1); vv2 = Qnil; } else { /* same case as 'where' */ v1 = gsl_permutation_alloc(n); v2 = gsl_permutation_alloc(v->size-n); for (i = 0, j = 0, k = 0; i < v->size; i++) { if ((!btmp && FUNCTION(gsl_vector,get)(v, i)) || (btmp && btmp->data[i])) v1->data[j++] = i; else v2->data[k++] = i; } vv1 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v1); vv2 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v2); } if (btmp) gsl_block_uchar_free(btmp); return rb_ary_new3(2, vv1, vv2); } static VALUE FUNCTION(rb_gsl_vector,op_inplace)(VALUE vv1, VALUE vv2, int (*f)(GSL_TYPE(gsl_vector)*, const GSL_TYPE(gsl_vector)*)) { GSL_TYPE(gsl_vector) *v1, *v2; Data_Get_Struct(vv1, GSL_TYPE(gsl_vector), v1); Data_Get_Struct(vv2, GSL_TYPE(gsl_vector), v2); (*f)(v1, v2); return vv1; } static VALUE FUNCTION(rb_gsl_vector,add_inplace)(VALUE vv1, VALUE vv2) { GSL_TYPE(gsl_vector) *v1; double x; if(VEC_P(vv2)) { return FUNCTION(rb_gsl_vector,op_inplace)(vv1, vv2, FUNCTION(gsl_vector,add)); } else { x = NUM2DBL(vv2); Data_Get_Struct(vv1, GSL_TYPE(gsl_vector), v1); FUNCTION(gsl_vector,add_constant)(v1, x); return vv1; } } static VALUE FUNCTION(rb_gsl_vector,sub_inplace)(VALUE vv1, VALUE vv2) { GSL_TYPE(gsl_vector) *v1; double x; if(VEC_P(vv2)) { return FUNCTION(rb_gsl_vector,op_inplace)(vv1, vv2, FUNCTION(gsl_vector,sub)); } else { x = NUM2DBL(vv2); Data_Get_Struct(vv1, GSL_TYPE(gsl_vector), v1); FUNCTION(gsl_vector,add_constant)(v1, -x); return vv1; } } static VALUE FUNCTION(rb_gsl_vector,mul_inplace)(VALUE vv1, VALUE vv2) { GSL_TYPE(gsl_vector) *v1; double x; if(VEC_P(vv2)) { return FUNCTION(rb_gsl_vector,op_inplace)(vv1, vv2, FUNCTION(gsl_vector,mul)); } else { x = NUM2DBL(vv2); Data_Get_Struct(vv1, GSL_TYPE(gsl_vector), v1); FUNCTION(gsl_vector,scale)(v1, x); return vv1; } } static VALUE FUNCTION(rb_gsl_vector,div_inplace)(VALUE vv1, VALUE vv2) { GSL_TYPE(gsl_vector) *v1; double x; if(VEC_P(vv2)) { return FUNCTION(rb_gsl_vector,op_inplace)(vv1, vv2, FUNCTION(gsl_vector,div)); } else { x = NUM2DBL(vv2); Data_Get_Struct(vv1, GSL_TYPE(gsl_vector), v1); FUNCTION(gsl_vector,scale)(v1, 1.0/x); return vv1; } } static VALUE FUNCTION(rb_gsl_vector,zip)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v0, **vp, *vnew; VALUE ary; size_t i, j; int argc2; VALUE *argv2; if (VEC_P(obj)) { Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v0); argc2 = argc; argv2 = argv; } else { if (argc < 1) rb_raise(rb_eArgError, "Too few arguments."); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v0); argc2 = argc - 1; argv2 = argv + 1; } for (i = 0; i < argc2; i++) { CHECK_VEC(argv2[i]); } vp = (GSL_TYPE(gsl_vector)**) malloc(sizeof(GSL_TYPE(gsl_vector)**)); for (i = 0; i < argc2; i++) { Data_Get_Struct(argv2[i], GSL_TYPE(gsl_vector), vp[i]); } ary = rb_ary_new2(v0->size); for (i = 0; i < v0->size; i++) { vnew = FUNCTION(gsl_vector,alloc)(argc2 + 1); FUNCTION(gsl_vector,set)(vnew, 0, FUNCTION(gsl_vector,get)(v0, i)); for (j = 0; j < argc2; j++) { if (i < vp[j]->size) { FUNCTION(gsl_vector,set)(vnew, j+1, FUNCTION(gsl_vector,get)(vp[j], i)); } else { FUNCTION(gsl_vector,set)(vnew, j+1, 0.0); } } rb_ary_store(ary, i, Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), vnew)); } free((GSL_TYPE(gsl_vector)**) vp); return ary; } static VALUE FUNCTION(rb_gsl_vector,join)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v; VALUE str, sep; char *p, buf[16]; size_t i; switch (argc) { case 0: sep = rb_str_new2(" "); break; case 1: sep = argv[0]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0 or 1)", argc); } Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); // p = (char *) malloc((10+RSTRING(sep))*v->size + 1); p = (char *) malloc((10+RSTRING_LEN(sep))*v->size + 1); str = rb_str_new2(p); for (i = 0; i < v->size; i++) { #ifdef BASE_DOUBLE sprintf(buf, "%4.3e", FUNCTION(gsl_vector,get)(v, i)); #else sprintf(buf, "%d", FUNCTION(gsl_vector,get)(v, i)); #endif rb_str_concat(str, rb_str_new2(buf)); if (i != v->size-1) rb_str_concat(str, sep); } return str; } static VALUE FUNCTION(rb_gsl_vector,cumsum)(VALUE obj) { GSL_TYPE(gsl_vector) *v, *vnew; BASE sum = 0; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { sum += FUNCTION(gsl_vector,get)(v, i); FUNCTION(gsl_vector,set)(vnew, i, sum); } return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_vector,cumprod)(VALUE obj) { GSL_TYPE(gsl_vector) *v, *vnew; BASE prod = 1; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_vector,alloc)(v->size); for (i = 0; i < v->size; i++) { prod *= FUNCTION(gsl_vector,get)(v, i); FUNCTION(gsl_vector,set)(vnew, i, prod); } return Data_Wrap_Struct(VEC_ROW_COL(obj), 0, FUNCTION(gsl_vector,free), vnew); } #ifdef GSL_1_9_LATER static VALUE FUNCTION(rb_gsl_vector,property)(VALUE obj, int (*f)(const GSL_TYPE(gsl_vector) *)) { GSL_TYPE(gsl_vector) *v; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX((*f)(v)); } static VALUE FUNCTION(rb_gsl_vector,property2)(VALUE obj, int (*f)(const GSL_TYPE(gsl_vector) *)) { GSL_TYPE(gsl_vector) *v; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if ((*f)(v)) return Qtrue; else return Qfalse; } static VALUE FUNCTION(rb_gsl_vector,ispos)(VALUE obj) { return FUNCTION(rb_gsl_vector,property)(obj, FUNCTION(gsl_vector, ispos)); } static VALUE FUNCTION(rb_gsl_vector,ispos2)(VALUE obj) { return FUNCTION(rb_gsl_vector,property2)(obj, FUNCTION(gsl_vector, ispos)); } static VALUE FUNCTION(rb_gsl_vector,isneg)(VALUE obj) { return FUNCTION(rb_gsl_vector,property)(obj, FUNCTION(gsl_vector, isneg)); } static VALUE FUNCTION(rb_gsl_vector,isneg2)(VALUE obj) { return FUNCTION(rb_gsl_vector,property2)(obj, FUNCTION(gsl_vector, isneg)); } #endif #ifdef GSL_1_10_LATER static VALUE FUNCTION(rb_gsl_vector,isnonneg)(VALUE obj) { return FUNCTION(rb_gsl_vector,property)(obj, FUNCTION(gsl_vector, isnonneg)); } static VALUE FUNCTION(rb_gsl_vector,isnonneg2)(VALUE obj) { return FUNCTION(rb_gsl_vector,property2)(obj, FUNCTION(gsl_vector, isnonneg)); } #endif void FUNCTION(Init_gsl_vector,init)(VALUE module) { /* rb_define_singleton_method(GSL_TYPE(cgsl_vector), "new", FUNCTION(rb_gsl_vector,new), -1);*/ rb_define_singleton_method(GSL_TYPE(cgsl_vector), "[]", FUNCTION(rb_gsl_vector,new), -1); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "alloc", FUNCTION(rb_gsl_vector,new), -1); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "calloc", FUNCTION(rb_gsl_vector,calloc), 1); /*****/ rb_define_method(GSL_TYPE(cgsl_vector), "get", FUNCTION(rb_gsl_vector,get), -1); rb_define_alias(GSL_TYPE(cgsl_vector), "[]", "get"); rb_define_method(GSL_TYPE(cgsl_vector), "size", FUNCTION(rb_gsl_vector,size), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "len", "size"); rb_define_alias(GSL_TYPE(cgsl_vector), "length", "size"); rb_define_method(GSL_TYPE(cgsl_vector), "stride", FUNCTION(rb_gsl_vector,stride), 0); rb_define_method(GSL_TYPE(cgsl_vector), "set_stride", FUNCTION(rb_gsl_vector,set_stride), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "stride=", "set_stride"); rb_define_method(GSL_TYPE(cgsl_vector), "owner", FUNCTION(rb_gsl_vector,owner), 0); rb_define_method(GSL_TYPE(cgsl_vector), "set", FUNCTION(rb_gsl_vector,set), -1); rb_define_alias(GSL_TYPE(cgsl_vector), "[]=", "set"); rb_define_method(GSL_TYPE(cgsl_vector), "set_all", FUNCTION(rb_gsl_vector,set_all), 1); rb_define_method(GSL_TYPE(cgsl_vector), "set_zero", FUNCTION(rb_gsl_vector,set_zero), 0); rb_define_method(GSL_TYPE(cgsl_vector), "set_basis", FUNCTION(rb_gsl_vector,set_basis), 1); rb_define_method(GSL_TYPE(cgsl_vector), "each", FUNCTION(rb_gsl_vector,each), 0); rb_define_method(GSL_TYPE(cgsl_vector), "reverse_each", FUNCTION(rb_gsl_vector,reverse_each), 0); rb_define_method(GSL_TYPE(cgsl_vector), "each_index", FUNCTION(rb_gsl_vector,each_index), 0); rb_define_method(GSL_TYPE(cgsl_vector), "reverse_each_index", FUNCTION(rb_gsl_vector,reverse_each_index), 0); rb_define_method(GSL_TYPE(cgsl_vector), "to_a", FUNCTION(rb_gsl_vector,to_a), 0); rb_define_method(GSL_TYPE(cgsl_vector), "reverse", FUNCTION(rb_gsl_vector,reverse), 0); rb_define_method(GSL_TYPE(cgsl_vector), "reverse!", FUNCTION(rb_gsl_vector,reverse_bang), 0); rb_define_method(GSL_TYPE(cgsl_vector), "max", FUNCTION(rb_gsl_vector,max), 0); rb_define_method(GSL_TYPE(cgsl_vector), "min", FUNCTION(rb_gsl_vector,min), 0); rb_define_method(GSL_TYPE(cgsl_vector), "minmax", FUNCTION(rb_gsl_vector,minmax), 0); rb_define_method(GSL_TYPE(cgsl_vector), "maxmin", FUNCTION(rb_gsl_vector,maxmin), 0); rb_define_method(GSL_TYPE(cgsl_vector), "max_index", FUNCTION(rb_gsl_vector,max_index), 0); rb_define_method(GSL_TYPE(cgsl_vector), "min_index", FUNCTION(rb_gsl_vector,min_index), 0); rb_define_method(GSL_TYPE(cgsl_vector), "minmax_index", FUNCTION(rb_gsl_vector,minmax_index), 0); rb_define_method(GSL_TYPE(cgsl_vector), "maxmin_index", FUNCTION(rb_gsl_vector,maxmin_index), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isnull", FUNCTION(rb_gsl_vector,isnull), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isnull?", FUNCTION(rb_gsl_vector,isnull2), 0); /* rb_define_alias(GSL_TYPE(cgsl_vector), "none?", "isnull?");*/ /* none? method is define below, which can have a block. */ rb_define_method(GSL_TYPE(cgsl_vector), "trans", FUNCTION(rb_gsl_vector,trans), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "transpose", "trans"); rb_define_alias(GSL_TYPE(cgsl_vector), "col", "trans"); rb_define_method(GSL_TYPE(cgsl_vector), "trans!", FUNCTION(rb_gsl_vector,trans_bang), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "transpose!", "trans!"); rb_define_alias(GSL_TYPE(cgsl_vector), "col!", "trans!"); #ifdef BASE_DOUBLE rb_define_alias(cgsl_vector_col, "row", "trans"); rb_define_alias(cgsl_vector_col, "row!", "trans!"); #elif defined(BASE_INT) rb_define_alias(cgsl_vector_int_col, "row", "trans"); rb_define_alias(cgsl_vector_int_col, "row!", "trans!"); #endif rb_define_method(GSL_TYPE(cgsl_vector), "-@", FUNCTION(rb_gsl_vector,uminus), 0); rb_define_method(GSL_TYPE(cgsl_vector), "+@", FUNCTION(rb_gsl_vector,uplus), 0); rb_define_method(GSL_TYPE(cgsl_vector), "sum", FUNCTION(rb_gsl_vector,sum), 0); #ifdef BASE_INT /* Vector#sumsq is defined in blas1.c */ rb_define_method(GSL_TYPE(cgsl_vector), "sumsq", FUNCTION(rb_gsl_vector,sumsq), 0); #endif rb_define_method(GSL_TYPE(cgsl_vector), "prod", FUNCTION(rb_gsl_vector,prod), 0); rb_define_method(GSL_TYPE(cgsl_vector), "cumsum", FUNCTION(rb_gsl_vector,cumsum), 0); rb_define_method(GSL_TYPE(cgsl_vector), "cumprod", FUNCTION(rb_gsl_vector,cumprod), 0); rb_define_method(GSL_TYPE(cgsl_vector), "connect", FUNCTION(rb_gsl_vector,connect), -1); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "connect", FUNCTION(rb_gsl_vector,connect), -1); rb_define_method(GSL_TYPE(cgsl_vector), "sgn", FUNCTION(rb_gsl_vector,sgn), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "signum", "sgn"); rb_define_method(GSL_TYPE(cgsl_vector), "abs", FUNCTION(rb_gsl_vector,abs), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "fabs", "abs"); rb_define_method(GSL_TYPE(cgsl_vector), "square", FUNCTION(rb_gsl_vector,square), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "abs2", "square"); rb_define_method(GSL_TYPE(cgsl_vector), "sqrt", FUNCTION(rb_gsl_vector,sqrt), 0); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "memcpy", FUNCTION(rb_gsl_vector,memcpy), 2); rb_define_method(GSL_TYPE(cgsl_vector), "clone", FUNCTION(rb_gsl_vector,clone), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "duplicate", "clone"); rb_define_alias(GSL_TYPE(cgsl_vector), "dup", "clone"); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "swap", FUNCTION(rb_gsl_vector,swap), 2); rb_define_method(GSL_TYPE(cgsl_vector), "swap_elements", FUNCTION(rb_gsl_vector,swap_elements), 2); rb_define_method(GSL_TYPE(cgsl_vector), "fwrite", FUNCTION(rb_gsl_vector,fwrite), 1); rb_define_method(GSL_TYPE(cgsl_vector), "fread", FUNCTION(rb_gsl_vector,fread), 1); rb_define_method(GSL_TYPE(cgsl_vector), "fprintf", FUNCTION(rb_gsl_vector,fprintf), -1); rb_define_method(GSL_TYPE(cgsl_vector), "printf", FUNCTION(rb_gsl_vector,printf), -1); rb_define_method(GSL_TYPE(cgsl_vector), "fscanf", FUNCTION(rb_gsl_vector,fscanf), 1); /* 2.Aug.2004 */ rb_define_singleton_method(GSL_TYPE(cgsl_vector), "inner_product", FUNCTION(rb_gsl_vector,inner_product), -1); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "dot", FUNCTION(rb_gsl_vector,inner_product), -1); rb_define_method(GSL_TYPE(cgsl_vector), "inner_product", FUNCTION(rb_gsl_vector,inner_product), -1); rb_define_alias(GSL_TYPE(cgsl_vector), "dot", "inner_product"); rb_define_method(GSL_TYPE(cgsl_vector), "equal?", FUNCTION(rb_gsl_vector,equal), -1); rb_define_alias(GSL_TYPE(cgsl_vector), "==", "equal?"); rb_define_method(GSL_TYPE(cgsl_vector), "to_poly", FUNCTION(rb_gsl_vector,to_poly), 0); /*****/ rb_define_method(GSL_TYPE(cgsl_vector), "graph", FUNCTION(rb_gsl_vector,graph), -1); rb_define_method(GSL_TYPE(cgsl_vector), "graph_step", FUNCTION(rb_gsl_vector,graph_step), -1); rb_define_method(GSL_TYPE(cgsl_vector), "plot", FUNCTION(rb_gsl_vector,plot), -1); rb_define_method(GSL_TYPE(cgsl_vector), "print", FUNCTION(rb_gsl_vector,print), 0); rb_define_method(GSL_TYPE(cgsl_vector), "inspect", FUNCTION(rb_gsl_vector,inspect), 0); rb_define_method(GSL_TYPE(cgsl_vector), "to_s", FUNCTION(rb_gsl_vector,to_s), 0); /*****/ rb_define_method(GSL_TYPE(cgsl_vector), "subvector", FUNCTION(rb_gsl_vector,subvector), -1); rb_define_alias(GSL_TYPE(cgsl_vector), "view", "subvector"); rb_define_method(GSL_TYPE(cgsl_vector), "subvector_with_stride", FUNCTION(rb_gsl_vector,subvector_with_stride), -1); rb_define_alias(GSL_TYPE(cgsl_vector), "view_with_stride", "subvector_with_stride"); rb_define_method(GSL_TYPE(cgsl_vector), "matrix_view", FUNCTION(rb_gsl_vector,matrix_view), -1); rb_define_method(GSL_TYPE(cgsl_vector), "matrix_view_with_tda", FUNCTION(rb_gsl_vector,matrix_view_with_tda), 3); #ifdef BASE_DOUBLE rb_undef_method(cgsl_vector_view_ro, "set"); rb_undef_method(cgsl_vector_view_ro, "[]="); rb_undef_method(cgsl_vector_col_view_ro, "set"); rb_undef_method(cgsl_vector_col_view_ro, "[]="); #elif defined(BASE_INT) rb_undef_method(cgsl_vector_int_view_ro, "set"); rb_undef_method(cgsl_vector_int_view_ro, "[]="); rb_undef_method(cgsl_vector_int_col_view_ro, "set"); rb_undef_method(cgsl_vector_int_col_view_ro, "[]="); #endif rb_define_method(GSL_TYPE(cgsl_vector), "scale", FUNCTION(rb_gsl_vector,scale), 1); rb_define_method(GSL_TYPE(cgsl_vector), "scale!", FUNCTION(rb_gsl_vector,scale_bang), 1); rb_define_method(GSL_TYPE(cgsl_vector), "add_constant", FUNCTION(rb_gsl_vector,add_constant), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "add_const", "add_constant"); rb_define_method(GSL_TYPE(cgsl_vector), "add_constant!", FUNCTION(rb_gsl_vector,add_constant_bang), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "add_const!", "add_constant!"); #ifdef HAVE_TENSOR_TENSOR_H rb_define_method(GSL_TYPE(cgsl_vector), "to_tensor", FUNCTION(rb_gsl_vector,to_tensor), -1); #endif rb_define_singleton_method(GSL_TYPE(cgsl_vector), "to_gplot", FUNCTION(rb_gsl_vector,to_gplot), -1); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "to_gsplot", FUNCTION(rb_gsl_vector,to_gplot), -1); rb_define_method(GSL_TYPE(cgsl_vector), "to_gplot", FUNCTION(rb_gsl_vector,to_gplot), -1); rb_define_alias(GSL_TYPE(cgsl_vector), "to_gsplot", "to_gplot"); /*****/ rb_define_method(GSL_TYPE(cgsl_vector), "collect", FUNCTION(rb_gsl_vector,collect), 0); rb_define_method(GSL_TYPE(cgsl_vector), "collect!", FUNCTION(rb_gsl_vector,collect_bang), 0); rb_define_alias(GSL_TYPE(cgsl_vector), "map", "collect"); rb_define_alias(GSL_TYPE(cgsl_vector), "map!", "collect!"); rb_define_method(GSL_TYPE(cgsl_vector), "to_m", FUNCTION(rb_gsl_vector,to_m), 2); rb_define_alias(GSL_TYPE(cgsl_vector), "to_matrix", "to_m"); rb_define_alias(GSL_TYPE(cgsl_vector), "reshape", "to_m"); rb_define_method(GSL_TYPE(cgsl_vector), "to_m_diagonal", FUNCTION(rb_gsl_vector,to_m_diagonal), 0); rb_define_method(GSL_TYPE(cgsl_vector), "block", FUNCTION(rb_gsl_vector,block), 0); rb_define_method(GSL_TYPE(cgsl_vector), "to_m_circulant", FUNCTION(rb_gsl_vector,to_m_circulant), 0); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "indgen", FUNCTION(rb_gsl_vector,indgen_singleton), -1); rb_define_method(GSL_TYPE(cgsl_vector), "indgen", FUNCTION(rb_gsl_vector,indgen), -1); rb_define_method(GSL_TYPE(cgsl_vector), "indgen!", FUNCTION(rb_gsl_vector,indgen_bang), -1); /*****/ rb_define_method(GSL_TYPE(cgsl_vector), "sort!", GSL_TYPE(rb_gsl_sort_vector), 0); rb_define_method(GSL_TYPE(cgsl_vector), "sort", GSL_TYPE(rb_gsl_sort_vector2), 0); rb_define_method(GSL_TYPE(cgsl_vector), "sort_index", FUNCTION(rb_gsl_sort_vector,index), 0); rb_define_method(GSL_TYPE(cgsl_vector), "sort_smallest", FUNCTION(rb_gsl_sort_vector,smallest), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "smallest", "sort_smallest"); rb_define_method(GSL_TYPE(cgsl_vector), "sort_largest", FUNCTION(rb_gsl_sort_vector,largest), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "largest", "sort_largest"); rb_define_method(GSL_TYPE(cgsl_vector), "sort_smallest_index", FUNCTION(rb_gsl_sort_vector,smallest_index), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "smallest_index", "sort_smallest_index"); rb_define_method(GSL_TYPE(cgsl_vector), "sort_largest_index", FUNCTION(rb_gsl_sort_vector,largest_index), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "largest_index", "sort_largest_index"); /*****/ rb_define_method(GSL_TYPE(cgsl_vector), "histogram", FUNCTION(rb_gsl_vector,histogram), -1); rb_define_method(GSL_TYPE(cgsl_vector), "last", FUNCTION(rb_gsl_vector,last), 0); rb_define_method(GSL_TYPE(cgsl_vector), "first", FUNCTION(rb_gsl_vector,first), 0); rb_define_method(GSL_TYPE(cgsl_vector), "concat", FUNCTION(rb_gsl_vector,concat), 1); rb_define_method(GSL_TYPE(cgsl_vector), "diff", FUNCTION(rb_gsl_vector,diff), -1); rb_define_method(GSL_TYPE(cgsl_vector), "isnan", FUNCTION(rb_gsl_vector,isnan), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isinf", FUNCTION(rb_gsl_vector,isinf), 0); rb_define_method(GSL_TYPE(cgsl_vector), "finite", FUNCTION(rb_gsl_vector,finite), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isnan?", FUNCTION(rb_gsl_vector,isnan2), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isinf?", FUNCTION(rb_gsl_vector,isinf2), 0); rb_define_method(GSL_TYPE(cgsl_vector), "finite?", FUNCTION(rb_gsl_vector,finite2), 0); rb_define_method(GSL_TYPE(cgsl_vector), "delete_at", FUNCTION(rb_gsl_vector,delete_at), 1); rb_define_method(GSL_TYPE(cgsl_vector), "delete_if", FUNCTION(rb_gsl_vector,delete_if), 0); rb_define_method(GSL_TYPE(cgsl_vector), "delete", FUNCTION(rb_gsl_vector,delete), 1); /***/ rb_define_singleton_method(GSL_TYPE(cgsl_vector), "filescan", FUNCTION(rb_gsl_vector,filescan), 1); /*****/ rb_define_method(GSL_TYPE(cgsl_vector), "eq", FUNCTION(rb_gsl_vector,eq), 1); rb_define_method(GSL_TYPE(cgsl_vector), "ne", FUNCTION(rb_gsl_vector,ne), 1); rb_define_method(GSL_TYPE(cgsl_vector), "gt", FUNCTION(rb_gsl_vector,gt), 1); rb_define_alias(GSL_TYPE(cgsl_vector), ">", "gt"); rb_define_method(GSL_TYPE(cgsl_vector), "ge", FUNCTION(rb_gsl_vector,ge), 1); rb_define_alias(GSL_TYPE(cgsl_vector), ">=", "ge"); rb_define_method(GSL_TYPE(cgsl_vector), "lt", FUNCTION(rb_gsl_vector,lt), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "<", "lt"); rb_define_method(GSL_TYPE(cgsl_vector), "le", FUNCTION(rb_gsl_vector,le), 1); rb_define_alias(GSL_TYPE(cgsl_vector), "<=", "le"); rb_define_method(GSL_TYPE(cgsl_vector), "and", FUNCTION(rb_gsl_vector,and), 1); rb_define_method(GSL_TYPE(cgsl_vector), "or", FUNCTION(rb_gsl_vector,or), 1); rb_define_method(GSL_TYPE(cgsl_vector), "xor", FUNCTION(rb_gsl_vector,xor), 1); rb_define_method(GSL_TYPE(cgsl_vector), "not", FUNCTION(rb_gsl_vector,not), 0); rb_define_method(GSL_TYPE(cgsl_vector), "all?", FUNCTION(rb_gsl_vector,all), 0); rb_define_method(GSL_TYPE(cgsl_vector), "none?", FUNCTION(rb_gsl_vector,none), 0); rb_define_method(GSL_TYPE(cgsl_vector), "any", FUNCTION(rb_gsl_vector,any), 0); rb_define_method(GSL_TYPE(cgsl_vector), "any?", FUNCTION(rb_gsl_vector,any2), 0); rb_define_method(GSL_TYPE(cgsl_vector), "where", FUNCTION(rb_gsl_vector,where), 0); rb_define_method(GSL_TYPE(cgsl_vector), "where2", FUNCTION(rb_gsl_vector,where2), 0); rb_define_method(GSL_TYPE(cgsl_vector), "add!", FUNCTION(rb_gsl_vector,add_inplace), 1); rb_define_method(GSL_TYPE(cgsl_vector), "sub!", FUNCTION(rb_gsl_vector,sub_inplace), 1); rb_define_method(GSL_TYPE(cgsl_vector), "mul!", FUNCTION(rb_gsl_vector,mul_inplace), 1); rb_define_method(GSL_TYPE(cgsl_vector), "div!", FUNCTION(rb_gsl_vector,div_inplace), 1); rb_define_singleton_method(GSL_TYPE(cgsl_vector), "zip", FUNCTION(rb_gsl_vector,zip), -1); rb_define_method(GSL_TYPE(cgsl_vector), "zip", FUNCTION(rb_gsl_vector,zip), -1); rb_define_method(GSL_TYPE(cgsl_vector), "join", FUNCTION(rb_gsl_vector,join), -1); #ifdef GSL_1_9_LATER rb_define_method(GSL_TYPE(cgsl_vector), "ispos", FUNCTION(rb_gsl_vector,ispos), 0); rb_define_method(GSL_TYPE(cgsl_vector), "ispos?", FUNCTION(rb_gsl_vector,ispos2), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isneg", FUNCTION(rb_gsl_vector,isneg), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isneg?", FUNCTION(rb_gsl_vector,isneg2), 0); #endif #ifdef GSL_1_10_LATER rb_define_method(GSL_TYPE(cgsl_vector), "isnonneg", FUNCTION(rb_gsl_vector,isnonneg), 0); rb_define_method(GSL_TYPE(cgsl_vector), "isnonneg?", FUNCTION(rb_gsl_vector,isnonneg2), 0); #endif } #undef NUMCONV #undef NUMCONV2 #undef PRINTF_FORMAT #undef VEC_ROW_COL #undef VEC_P #undef C_TO_VALUE #undef C_TO_VALUE2 #undef VEC_COL_P #undef VEC_ROW_P #undef CHECK_VEC #undef VEC_VIEW_P gsl-1.15.3/ext/sf_lambert.c0000644000175000017500000000307712220252463015033 0ustar boutilboutil/* sf_lambert.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_lambert_W0(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_lambert_W0, x); } static VALUE rb_gsl_sf_lambert_W0_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_lambert_W0_e, x); } static VALUE rb_gsl_sf_lambert_Wm1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_lambert_Wm1, x); } static VALUE rb_gsl_sf_lambert_Wm1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_lambert_Wm1_e, x); } void Init_gsl_sf_lambert(VALUE module) { VALUE mgsl_sf_lambert; rb_define_module_function(module, "lambert_W0", rb_gsl_sf_lambert_W0, 1); rb_define_module_function(module, "lambert_W0_e", rb_gsl_sf_lambert_W0_e, 1); rb_define_module_function(module, "lambert_Wm1", rb_gsl_sf_lambert_Wm1, 1); rb_define_module_function(module, "lambert_Wm1_e", rb_gsl_sf_lambert_Wm1_e, 1); mgsl_sf_lambert = rb_define_module_under(module, "Lambert"); rb_define_module_function(mgsl_sf_lambert, "W0", rb_gsl_sf_lambert_W0, 1); rb_define_module_function(mgsl_sf_lambert, "W0_e", rb_gsl_sf_lambert_W0_e, 1); rb_define_module_function(mgsl_sf_lambert, "Wm1", rb_gsl_sf_lambert_Wm1, 1); rb_define_module_function(mgsl_sf_lambert, "Wm1_e", rb_gsl_sf_lambert_Wm1_e, 1); } gsl-1.15.3/ext/vector_double.c0000644000175000017500000012133012220252463015542 0ustar boutilboutil/* vector.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Modified by Seiya Nishizawa 14/Apr/2004 Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_histogram.h" #include "rb_gsl_complex.h" #include "rb_gsl_poly.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif VALUE rb_gsl_vector_inner_product(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_vector_product_to_m(int argc, VALUE *argv, VALUE obj); VALUE rb_gsl_vector_int_to_f(VALUE obj); VALUE rb_ary_to_gv(VALUE klass, VALUE ary); static VALUE rb_gsl_vector_Xspace(double min, double max, int i, gsl_vector* (*f)(const double, const double, const size_t)) { gsl_vector *v = NULL; size_t n; if (i <= 0) rb_raise(rb_eArgError, "npoints must be greater than 0"); n = (size_t) i; if (n == 1 && min != max) rb_raise(rb_eArgError, "npoints is 1, but x1 != x2"); v = (*f)(min, max, n); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static gsl_vector* gsl_vector_linspace(const double min, const double max, const size_t n) { gsl_vector *v = NULL; double dx; size_t i; v = gsl_vector_alloc(n); if (n > 1) { dx = (max - min)/(n-1); gsl_vector_set(v, 0, min); for (i = 1; i < n-1; i++) gsl_vector_set(v, i, i*dx + min); gsl_vector_set(v, n-1, max); } else { gsl_vector_set(v, 0, min); } return v; } static gsl_vector* gsl_vector_logspace(const double min, const double max, const size_t n) { gsl_vector *v = NULL; double dx; size_t i; v = gsl_vector_alloc(n); if (n > 1) { dx = (max - min)/(n-1); gsl_vector_set(v, 0, pow(10.0, min)); for (i = 1; i < n-1; i++) gsl_vector_set(v, i, pow(10.0, dx*i + min)); gsl_vector_set(v, n-1, pow(10.0, max)); } else { gsl_vector_set(v, 0, pow(10.0, min)); } return v; } static VALUE rb_gsl_vector_linspace(int argc, VALUE *argv, VALUE klass) { size_t n = 10; switch (argc) { case 3: CHECK_FIXNUM(argv[2]); n = (size_t) FIX2UINT(argv[2]); break; case 2: /* do nothing */ break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } Need_Float(argv[0]); Need_Float(argv[1]); return rb_gsl_vector_Xspace(NUM2DBL(argv[0]), NUM2DBL(argv[1]), n, gsl_vector_linspace); } static VALUE rb_gsl_vector_logspace(int argc, VALUE *argv, VALUE klass) { size_t n = 10; switch (argc) { case 3: CHECK_FIXNUM(argv[2]); n = (size_t) FIX2INT(argv[2]); break; case 2: /* do nothing */ break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } Need_Float(argv[0]); Need_Float(argv[1]); return rb_gsl_vector_Xspace(NUM2DBL(argv[0]), NUM2DBL(argv[1]), n, gsl_vector_logspace); } static VALUE rb_gsl_vector_logspace2(int argc, VALUE *argv, VALUE klass) { size_t n = 10; switch (argc) { case 3: CHECK_FIXNUM(argv[2]); n = (size_t) FIX2INT(argv[2]); break; case 2: /* do nothing */ break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } Need_Float(argv[0]); Need_Float(argv[1]); return rb_gsl_vector_Xspace(log10(NUM2DBL(argv[0])), log10(NUM2DBL(argv[1])), n, gsl_vector_logspace); } /********************************************************/ VALUE rb_gsl_vector_do_something(VALUE obj, void (*func)(gsl_vector*)); /* singleton */ enum { GSL_VECTOR_ADD, GSL_VECTOR_SUB, GSL_VECTOR_MUL, GSL_VECTOR_DIV, }; static VALUE rb_gsl_vector_arithmetics(int flag, VALUE obj, VALUE bb) { gsl_vector *v = NULL, *vnew = NULL, *b = NULL; gsl_vector_complex *cvnew = NULL, *cb = NULL; gsl_complex *c = NULL; Data_Get_Struct(obj, gsl_vector, v); switch (TYPE(bb)) { case T_FLOAT: case T_FIXNUM: switch (flag) { case GSL_VECTOR_ADD: vnew = make_vector_clone(v); gsl_vector_add_constant(vnew, NUM2DBL(bb)); break; case GSL_VECTOR_SUB: vnew = make_vector_clone(v); gsl_vector_add_constant(vnew, -NUM2DBL(bb)); break; case GSL_VECTOR_MUL: vnew = make_vector_clone(v); gsl_vector_scale(vnew, NUM2DBL(bb)); break; case GSL_VECTOR_DIV: vnew = make_vector_clone(v); gsl_vector_scale(vnew, 1.0/NUM2DBL(bb)); break; } if (!VECTOR_VIEW_P(obj)) return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_vector_free, vnew); else return Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, vnew); break; default: if (VECTOR_INT_P(bb)) bb = rb_gsl_vector_int_to_f(bb); if (VECTOR_P(bb)) { Data_Get_Struct(bb, gsl_vector, b); switch (flag) { case GSL_VECTOR_ADD: vnew = make_vector_clone(v); gsl_vector_add(vnew, b); break; case GSL_VECTOR_SUB: vnew = make_vector_clone(v); gsl_vector_sub(vnew, b); break; case GSL_VECTOR_MUL: vnew = make_vector_clone(v); gsl_vector_mul(vnew, b); break; case GSL_VECTOR_DIV: vnew = make_vector_clone(v); gsl_vector_div(vnew, b); break; } if (!VECTOR_VIEW_P(obj)) return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_vector_free, vnew); else return Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, vnew); } else if (VECTOR_COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_vector_complex, cb); cvnew = vector_to_complex(v); switch (flag) { case GSL_VECTOR_ADD: gsl_vector_complex_add(cvnew, cb); break; case GSL_VECTOR_SUB: gsl_vector_complex_sub(cvnew, cb); break; case GSL_VECTOR_MUL: gsl_vector_complex_mul(cvnew, cb); break; case GSL_VECTOR_DIV: gsl_vector_complex_div(cvnew, cb); break; } if (VECTOR_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, cvnew); else return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew); } else if (COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_complex, c); cvnew = vector_to_complex(v); switch (flag) { case GSL_VECTOR_ADD: gsl_vector_complex_add_constant(cvnew, *c); break; case GSL_VECTOR_SUB: gsl_vector_complex_add_constant(cvnew, gsl_complex_negative(*c)); break; case GSL_VECTOR_MUL: gsl_vector_complex_scale(cvnew, *c); break; case GSL_VECTOR_DIV: gsl_vector_complex_scale(cvnew, gsl_complex_inverse(*c)); break; } if (VECTOR_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, cvnew); else return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew); } else { rb_raise(rb_eTypeError, "wrong type argument %s", rb_class2name(CLASS_OF(bb))); } break; } /* never reach here */ return Qnil; } VALUE rb_gsl_vector_add(VALUE obj, VALUE b) { return rb_gsl_vector_arithmetics(GSL_VECTOR_ADD, obj, b); } VALUE rb_gsl_vector_sub(VALUE obj, VALUE b) { return rb_gsl_vector_arithmetics(GSL_VECTOR_SUB, obj, b); } gsl_vector* mygsl_vector_mul_matrix(gsl_vector *v, gsl_matrix *m); VALUE rb_gsl_vector_mul(VALUE obj, VALUE b) { VALUE argv[2]; gsl_vector *v, *vnew; gsl_matrix *m; if (VECTOR_ROW_P(obj) && VECTOR_COL_P(b)) { argv[0] = obj; argv[1] = b; return rb_gsl_vector_inner_product(2, argv, CLASS_OF(obj)); } if (VECTOR_ROW_P(obj) && MATRIX_P(b)) { Data_Get_Struct(obj, gsl_vector, v); Data_Get_Struct(b, gsl_matrix, m); vnew = mygsl_vector_mul_matrix(v, m); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } if (VECTOR_COL_P(obj) && VECTOR_ROW_P(b)) { argv[0] = obj; argv[1] = b; return rb_gsl_vector_product_to_m(2, argv, CLASS_OF(obj)); } return rb_gsl_vector_arithmetics(GSL_VECTOR_MUL, obj, b); } VALUE rb_gsl_vector_div(VALUE obj, VALUE b) { return rb_gsl_vector_arithmetics(GSL_VECTOR_DIV, obj, b); } VALUE rb_ary_to_gv0(VALUE ary) { gsl_vector *v = NULL; size_t i, size; size = RARRAY_LEN(ary); v = gsl_vector_alloc(size); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); for (i = 0; i < size; i++) { gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(ary, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } VALUE rb_ary_to_gv(VALUE klass, VALUE ary) { gsl_vector *v = NULL; size_t i, size; size = RARRAY_LEN(ary); v = gsl_vector_alloc(size); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); for (i = 0; i < size; i++) { gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(ary, i))); } return Data_Wrap_Struct(klass, 0, gsl_vector_free, v); } VALUE rb_gsl_range_to_gv(VALUE obj) { int beg, en; size_t n, i; gsl_vector *v = NULL; beg = NUM2INT(rb_funcall3(obj, rb_gsl_id_beg, 0, NULL)); en = NUM2INT(rb_funcall3(obj, rb_gsl_id_end, 0, NULL)); if (RTEST(rb_funcall3(obj, rb_gsl_id_excl, 0, NULL))) n = en - beg; else n = en - beg + 1; v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, beg + (int)i); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } gsl_vector_view* gsl_vector_view_alloc() { gsl_vector_view *vv = NULL; vv = ALLOC(gsl_vector_view); if (vv == NULL) rb_raise(rb_eNoMemError, "malloc failed"); vv->vector.owner = 0; return vv; } void gsl_vector_view_free(gsl_vector_view * vv) { free((gsl_vector_view *) vv); } static VALUE rb_gsl_vector_to_complex(VALUE obj) { gsl_vector *v = NULL; gsl_vector_complex *cv = NULL; gsl_complex z; size_t i; double x; Data_Get_Struct(obj, gsl_vector, v); cv = gsl_vector_complex_alloc(v->size); for (i = 0; i < v->size; i++) { x = gsl_vector_get(v, i); z.dat[0] = x; z.dat[1] = 0; gsl_vector_complex_set(cv, i, z); } if (VECTOR_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, cv); else return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cv); } static VALUE rb_gsl_vector_to_complex2(VALUE obj) { gsl_vector *v = NULL; gsl_vector_complex *cv = NULL; gsl_complex z; size_t i; double re, im; Data_Get_Struct(obj, gsl_vector, v); cv = gsl_vector_complex_alloc(ceil((double)v->size/2)); for (i = 0; i < v->size; i += 2) { re = gsl_vector_get(v, i); if (i+1 == v->size) im = 0.0; else im = gsl_vector_get(v, i+1); z.dat[0] = re; z.dat[1] = im; gsl_vector_complex_set(cv, i/2, z); } if (VECTOR_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, cv); else return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cv); } static VALUE rb_gsl_vector_coerce(VALUE obj, VALUE other) { gsl_vector *v = NULL, *vnew = NULL; gsl_vector_complex *cv = NULL; gsl_complex *c = NULL; VALUE vv; Data_Get_Struct(obj, gsl_vector, v); switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: vnew = gsl_vector_alloc(v->size); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); gsl_vector_set_all(vnew, NUM2DBL(other)); vv = Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, vnew); return rb_ary_new3(2, vv, obj); break; default: if (COMPLEX_P(other)) { Data_Get_Struct(other, gsl_complex, c); cv = gsl_vector_complex_alloc(v->size); if (cv == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); gsl_vector_complex_set_all(cv, *c); if (VECTOR_ROW_P(obj)) vv = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cv); else vv = Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, cv); return rb_ary_new3(2, vv, obj); } else if (VECTOR_COMPLEX_P(other)) { cv = vector_to_complex(v); if (VECTOR_ROW_P(obj)) vv = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cv); else vv = Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, cv); return rb_ary_new3(2, other, vv); } else { rb_raise(rb_eTypeError, "cannot coerced"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_vector_product_to_m(int argc, VALUE *argv, VALUE obj) { gsl_vector *v = NULL, *v2 = NULL; gsl_matrix *m = NULL; size_t i, j; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); if (!VECTOR_COL_P(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Col expected)", rb_class2name(CLASS_OF(argv[0]))); if (!VECTOR_ROW_P(argv[1])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[0], gsl_vector, v); Data_Get_Struct(argv[1], gsl_vector, v2); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); if (!VECTOR_COL_P(obj)) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector::Col expected)", rb_class2name(CLASS_OF(obj))); if (!VECTOR_ROW_P(argv[0])) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(obj, gsl_vector, v); Data_Get_Struct(argv[0], gsl_vector, v2); break; } m = gsl_matrix_alloc(v->size, v2->size); for (i = 0; i < v->size; i++) { for (j = 0; j < v2->size; j++) { gsl_matrix_set(m, i, j, gsl_vector_get(v, i)*gsl_vector_get(v2, j)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m); } static VALUE rb_gsl_vector_to_f(VALUE obj) { return obj; } VALUE rb_gsl_vector_to_i(VALUE obj) { gsl_vector *v = NULL; gsl_vector_int *vi = NULL; size_t i; int val; Data_Get_Struct(obj, gsl_vector, v); vi = gsl_vector_int_alloc(v->size); for (i = 0; i < v->size; i++) { val = (int) gsl_vector_get(v, i); gsl_vector_int_set(vi, i, val); } if (VECTOR_COL_P(obj)) return Data_Wrap_Struct(cgsl_vector_int_col, 0, gsl_vector_int_free, vi); else return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, vi); } /* singleton */ #ifdef HAVE_GNU_GRAPH static void draw_hist(VALUE obj, FILE *fp); static void draw_vector(VALUE obj, FILE *fp); static void draw_vector2(VALUE xx, VALUE yy, FILE *fp); static void draw_vector_array(VALUE ary, FILE *fp); #ifdef HAVE_NARRAY_H static void draw_narray(VALUE obj, FILE *fp); #endif // HAVE_NARRAY_H #endif // HAVE_GNU_GRAPH static VALUE rb_gsl_vector_graph2(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH size_t i, iend, j, n = 0; gsl_vector *x = NULL, *y = NULL; gsl_histogram *h = NULL; VALUE vx = (VALUE) NULL; char command[1024]; int flag = 0; FILE *fp = NULL; if (argc < 1) rb_raise(rb_eArgError, "two few arguments"); if (TYPE(argv[argc-1]) == T_STRING) { sprintf(command, "graph -T X %s", STR2CSTR(argv[argc-1])); iend = argc-1; } else { strcpy(command, "graph -T X -C -g 3"); iend = argc; } if (iend == 1) { fp = popen(command, "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); if (VECTOR_P(argv[0])) { draw_vector(argv[0], fp); } else if (HISTOGRAM_P(argv[0])) { draw_hist(argv[0], fp); } else if (TYPE(argv[0]) == T_ARRAY) { draw_vector_array(argv[0], fp); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[0])) { draw_narray(argv[0], fp); #endif } else { if (fp) pclose(fp); rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); } if (fp) pclose(fp); return Qtrue; } else { fp = popen(command, "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, x); vx = argv[0]; n = x->size; flag = 0; } else if (HISTOGRAM_P(argv[0])) { Data_Get_Struct(argv[0], gsl_histogram, h); x = gsl_vector_alloc(h->n); n = x->size; for (j = 0; j < x->size; j++) gsl_vector_set(x, j, h->range[j]); flag = 1; draw_hist(argv[0], fp); fprintf(fp, "\n"); } else if (TYPE(argv[0]) == T_ARRAY) { draw_vector_array(argv[0], fp); fprintf(fp, "\n"); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[0])) { vx = argv[0]; n = NA_TOTAL(argv[0]); flag = 0; #endif } else if (NIL_P(argv[0])) { if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[1], gsl_vector, y); n = y->size; } else if (HISTOGRAM_P(argv[1])) { Data_Get_Struct(argv[1], gsl_histogram, h); n = h->n; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[1])) { n = NA_TOTAL(argv[1]); #endif } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); } x = gsl_vector_alloc(n); for (j = 0; j < n; j++) gsl_vector_set(x, j, (double) j); flag = 1; } else { if (fp) pclose(fp); rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); } if (flag == 1) vx = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, x); for (i = 1; i < iend; i++) { if (VECTOR_P(argv[i])) draw_vector2(vx, argv[i], fp); else if (HISTOGRAM_P(argv[i])) draw_hist(argv[i], fp); else if (TYPE(argv[i]) == T_ARRAY) draw_vector_array(argv[i], fp); #ifdef HAVE_NARRAY_H else if (NA_IsNArray(argv[i])) draw_vector2(vx, argv[i], fp); #endif else rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[i]))); fprintf(fp, "\n"); fflush(fp); } fclose(fp); return Qtrue; } return Qtrue; #else rb_raise(rb_eNoMethodError, "GNU plotutils required"); return Qfalse; #endif } #ifdef HAVE_GNU_GRAPH static void draw_vector(VALUE obj, FILE *fp) { gsl_vector *x = NULL; size_t j; Data_Get_Vector(obj, x); for (j = 0; j < x->size; j++) fprintf(fp, "%d %g\n", (int) j, gsl_vector_get(x, j)); fflush(fp); } static void draw_vector2(VALUE xx, VALUE yy, FILE *fp) { #ifdef HAVE_NARRAY_H struct NARRAY *nax, *nay; #endif // HAVE_NARRAY_H double *ptr1 = NULL, *ptr2 = NULL; gsl_vector *vx, *vy; size_t j, n, stridex = 1, stridey = 1; if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, vx); ptr1 = vx->data; n = vx->size; stridex = vx->stride; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(xx)) { GetNArray(xx, nax); ptr1 = (double *) nax->ptr; n = nax->total; stridex = 1; #endif // HAVE_NARRAY_H } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector expected)", rb_class2name(CLASS_OF(xx))); } if (VECTOR_P(yy)) { Data_Get_Struct(yy, gsl_vector, vy); ptr2 = vy->data; n = vy->size; stridey = vy->stride; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(yy)) { GetNArray(yy, nay); ptr2 = (double *) nay->ptr; stridey = 1; #endif // HAVE_NARRAY_H } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector expected)", rb_class2name(CLASS_OF(yy))); } for (j = 0; j < n; j++) fprintf(fp, "%g %g\n", ptr1[j*stridex], ptr2[j*stridey]); fflush(fp); } #ifdef HAVE_NARRAY_H static void draw_narray(VALUE obj, FILE *fp) { struct NARRAY *na; double *ptr; size_t j; GetNArray(obj, na); ptr = (double *) na->ptr; for (j = 0; j < na->total; j++) fprintf(fp, "%d %g\n", (int) j, ptr[j]); fflush(fp); } #endif // HAVE_NARRAY_H static void draw_hist(VALUE obj, FILE *fp) { gsl_histogram *h = NULL; size_t j; Data_Get_Struct(obj, gsl_histogram, h); for (j = 0; j < h->n; j++) { fprintf(fp, "%g %g\n%g %g\n", h->range[j], h->bin[j], h->range[j+1], h->bin[j]); } fflush(fp); } static void draw_vector_array(VALUE ary, FILE *fp) { double *ptrx = NULL, *ptry = NULL, *ptrz = NULL; VALUE vx; size_t j, n, stridex, stridey, stridez; int flag = 0; switch (RARRAY_LEN(ary)) { case 1: flag = 1; ptry = get_vector_ptr(rb_ary_entry(ary, 0), &stridey, &n); break; case 2: ptry = get_vector_ptr(rb_ary_entry(ary, 1), &stridey, &n); vx = rb_ary_entry(ary, 0); if (NIL_P(vx)) {flag = 1;} else { ptrx = get_vector_ptr(vx, &stridex, &n); } break; case 3: ptrz = get_vector_ptr(rb_ary_entry(ary, 2), &stridez, &n); ptry = get_vector_ptr(rb_ary_entry(ary, 1), &stridey, &n); vx = rb_ary_entry(ary, 0); if (NIL_P(vx)) {flag = 2;} else { ptrx = get_vector_ptr(vx, &stridex, &n); flag = 3; } break; default: rb_raise(rb_eRuntimeError, "wrong array length (%d for 1 or 2)", (int) RARRAY_LEN(ary)); break; } switch (flag) { case 0: for (j = 0; j < n; j++) fprintf(fp, "%g %g\n", ptrx[j*stridex], ptry[j*stridey]); break; case 1: for (j = 0; j < n; j++) fprintf(fp, "%d %g\n", (int) j, ptry[j*stridey]); break; case 2: for (j = 0; j < n; j++) fprintf(fp, "%d %g %g\n", (int) j, ptry[j*stridey], ptrz[j*stridez]); break; case 3: for (j = 0; j < n; j++) fprintf(fp, "%g %g %g\n", ptrx[j*stridex], ptry[j*stridey], ptrz[j*stridez]); break; default: break; } fflush(fp); } #endif // HAVE_GNU_GRAPH /* singleton */ static VALUE rb_gsl_vector_plot2(int argc, VALUE *argv, VALUE obj) { gsl_vector *x = NULL, *y = NULL, *xerr = NULL, *yerr = NULL; FILE *fp = NULL; size_t i, n; char command[1024]; fp = popen("gnuplot -persist", "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); strcpy(command, "plot '-'"); switch (argc) { case 5: if (TYPE(argv[4]) == T_STRING) sprintf(command, "%s %s", command, STR2CSTR(argv[4])); /* no break */ case 4: if (TYPE(argv[3]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[3])); } else if (VECTOR_P(argv[3])) { Data_Get_Struct(argv[3], gsl_vector, yerr); } else { rb_raise(rb_eTypeError, "argv[3] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[3]))); } /* no break */ case 3: if (TYPE(argv[2]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[2])); } else if (VECTOR_P(argv[2])) { Data_Get_Struct(argv[2], gsl_vector, xerr); } else { rb_raise(rb_eTypeError, "argv[2] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[2]))); } /* no break */ case 2: if (TYPE(argv[1]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[1])); } else if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[1], gsl_vector, y); } else { rb_raise(rb_eTypeError, "argv[1] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[1]))); } /* no break */ case 1: if (TYPE(argv[0]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[0])); } else if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, x); } else { rb_raise(rb_eTypeError, "argv[0] wrong type %s (String or Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } break; default: rb_raise(rb_eArgError, "wrong number of argumens (%d for 1 - 5)", argc); break; } if (x == NULL) rb_raise(rb_eRuntimeError, "x data is not given"); n = x->size; fprintf(fp, "%s\n", command); for (i = 0; i < n; i++) { if (y == NULL) fprintf(fp, "%d %g\n", (int) i, gsl_vector_get(x, i)); else if (yerr == NULL) fprintf(fp, "%g %g\n", gsl_vector_get(x, i), gsl_vector_get(y, i)); else if (xerr) fprintf(fp, "%g %g %g %g\n", gsl_vector_get(x, i), gsl_vector_get(y, i), gsl_vector_get(xerr, i), gsl_vector_get(yerr, i)); else fprintf(fp, "%g %g %g\n", gsl_vector_get(x, i), gsl_vector_get(y, i), gsl_vector_get(yerr, i)); } fprintf(fp, "e\n"); fflush(fp); pclose(fp); fp = NULL; return Qtrue; } static VALUE rb_gsl_vector_normalize(int argc, VALUE *argv, VALUE obj) { gsl_vector *v = NULL, *vnew = NULL; // double mean; double nrm; switch (argc) { case 0: nrm = 1.0; break; case 1: Need_Float(argv[0]); nrm = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Vector(obj, v); vnew = make_vector_clone(v); /* mean = gsl_stats_mean(v->data, v->stride, v->size); gsl_vector_add_constant(vnew, -mean); sd = gsl_stats_sd(vnew->data, vnew->stride, vnew->size); gsl_vector_scale(vnew, sqrt(nrm)/sd);*/ gsl_vector_scale(vnew, nrm/gsl_blas_dnrm2(v)); return Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, vnew); } static VALUE rb_gsl_vector_normalize_bang(int argc, VALUE *argv, VALUE obj) { gsl_vector *v = NULL; // double mean; double nrm; double factor; switch (argc) { case 0: nrm = 1.0; break; case 1: Need_Float(argv[0]); nrm = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Vector(obj, v); /* mean = gsl_stats_mean(v->data, v->stride, v->size); gsl_vector_add_constant(v, -mean); sd = gsl_stats_sd(v->data, v->stride, v->size); gsl_vector_scale(v, sqrt(nrm)/sd);*/ factor = nrm/gsl_blas_dnrm2(v); gsl_vector_scale(v, factor); return obj; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_vector_filescan_na(VALUE klass, VALUE file) { FILE *fp = NULL; int nn; char buf[1024], filename[1024], *p; size_t n, lines, i, j; double **ptr; double val; int shape[1]; VALUE ary, na; Check_Type(file, T_STRING); strcpy(filename, STR2CSTR(file)); sprintf(buf, "wc %s", filename); fp = popen(buf, "r"); fgets(buf, 1024, fp); pclose(fp); sscanf(buf, "%d", &nn); lines = (size_t) nn; /* vector length */ shape[0] = lines; fp = fopen(filename, "r"); fgets(buf, 1024, fp); n = count_columns(buf); /* number of vectors created */ ptr = (double**) xmalloc(sizeof(double**)*n); ary = rb_ary_new2(n); p = buf; for (j = 0; j < n; j++) { na = na_make_object(NA_DFLOAT, 1, shape, cNArray); rb_ary_store(ary, j, na); ptr[j] = NA_PTR_TYPE(na, double*); p = str_scan_double(p, &val); if (p) ptr[j][0] = val; else break; } for (i = 1; i < lines; i++) { fgets(buf, 1024, fp); p = buf; for (j = 0; j < n; j++) { p = str_scan_double(p, &val); if (p) ptr[j][i] = val; else break; } } fclose(fp); free(ptr); return ary; } #endif static VALUE rb_gsl_vector_decimate(VALUE obj, VALUE nn) { gsl_vector *v = NULL, *vnew = NULL; gsl_vector_view vv; size_t i, n, n2, n3; CHECK_FIXNUM(nn); Data_Get_Vector(obj, v); n = (size_t) FIX2INT(nn); if (n > v->size) rb_raise(rb_eArgError, "decimation factor must be smaller than the vector length."); if (n == 0) rb_raise(rb_eArgError, "decimation factor must be greater than 1"); n2 = (size_t) ceil((double)v->size/n); vnew = gsl_vector_alloc(n2); n3 = n - (n2*n - v->size); for (i = 0; i < n2; i++) { if (i == n2-1) vv = gsl_vector_subvector(v, i*n, n3); else vv = gsl_vector_subvector(v, i*n, n); gsl_vector_set(vnew, i, gsl_stats_mean(vv.vector.data, vv.vector.stride, vv.vector.size)); } return Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, vnew); } static VALUE rb_gsl_vector_xxx(VALUE obj, double (*f)(double)) { gsl_vector *v; gsl_vector_int *vnew; size_t i; Data_Get_Struct(obj, gsl_vector, v); vnew = gsl_vector_int_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_int_set(vnew, i, (int) (*f)(gsl_vector_get(v, i))); } return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, vnew); } static VALUE rb_gsl_vector_floor(VALUE obj) { return rb_gsl_vector_xxx(obj, floor); } static VALUE rb_gsl_vector_ceil(VALUE obj) { return rb_gsl_vector_xxx(obj, ceil); } #ifdef HAVE_ROUND double round(double x); #define rb_gsl_round_native round #else static double rb_gsl_round_native(double x) { if(!gsl_finite(x)) { return x; // nan, +inf, -inf } else if(x > 0.0) { return floor(x+0.5); } else if(x < 0.0) { return ceil(x-0.5); } return x; // +0 or -0 } #endif static VALUE rb_gsl_vector_round(VALUE obj) { return rb_gsl_vector_xxx(obj, rb_gsl_round_native); } static VALUE rb_gsl_vector_dB(VALUE obj) { gsl_vector *v, *vnew; double x; size_t i; Data_Get_Struct(obj, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { x = gsl_vector_get(v, i); if (x <= 0.0) rb_raise(rb_eRuntimeError, "negative value found.\n"); gsl_vector_set(vnew, i, 20*log(x)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } static VALUE rb_gsl_vector_sin(VALUE obj) { return rb_gsl_sf_eval1(sin, obj); } static VALUE rb_gsl_vector_cos(VALUE obj) { return rb_gsl_sf_eval1(cos, obj); } static VALUE rb_gsl_vector_tan(VALUE obj) { return rb_gsl_sf_eval1(tan, obj); } static VALUE rb_gsl_vector_exp(VALUE obj) { return rb_gsl_sf_eval1(exp, obj); } static VALUE rb_gsl_vector_log(VALUE obj) { return rb_gsl_sf_eval1(log, obj); } static VALUE rb_gsl_vector_log10(VALUE obj) { return rb_gsl_sf_eval1(log10, obj); } static VALUE rb_gsl_vector_rotate_bang(int argc, VALUE *argv, VALUE klass) { double rad; double x, y, c, s; gsl_vector *vx, *vy; VALUE v0, v1, retval; size_t i, n; switch (argc) { case 2: if (TYPE(argv[0]) == T_ARRAY) { v0 = rb_ary_entry(argv[0], 0); v1 = rb_ary_entry(argv[0], 1); if (VECTOR_P(v0) && VECTOR_P(v1)) { Data_Get_Struct(v0, gsl_vector, vx); Data_Get_Struct(v1, gsl_vector, vy); n = (size_t) GSL_MIN(vx->size, vy->size); rad = NUM2DBL(argv[1]); retval = argv[0]; } else { x = NUM2DBL(rb_ary_entry(argv[0], 0)); y = NUM2DBL(rb_ary_entry(argv[0], 1)); rad = NUM2DBL(argv[1]); c = cos(rad); s = sin(rad); return rb_ary_new3(2, rb_float_new(c*x - s*y), rb_float_new(s*x + c*y)); } } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[0]))); } break; case 3: if (VECTOR_P(argv[0]) && VECTOR_P(argv[1])) { Data_Get_Struct(argv[0], gsl_vector, vx); Data_Get_Struct(argv[1], gsl_vector, vy); n = (size_t) GSL_MIN(vx->size, vy->size); rad = NUM2DBL(argv[1]); retval = rb_ary_new3(2, argv[0], argv[1]); } else { x = NUM2DBL(argv[0]); y = NUM2DBL(argv[1]); rad = NUM2DBL(argv[2]); c = cos(rad); s = sin(rad); return rb_ary_new3(2, rb_float_new(c*x - s*y), rb_float_new(s*x + c*y)); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } c = cos(rad); s = sin(rad); for (i = 0; i < n; i++) { x = gsl_vector_get(vx, i); y = gsl_vector_get(vy, i); gsl_vector_set(vx, i, c*x - s*y); gsl_vector_set(vy, i, s*x + c*y); } return retval; } static VALUE rb_gsl_vector_rotate(int argc, VALUE *argv, VALUE klass) { double rad; double x, y, c, s; gsl_vector *vx, *vy, *vxnew, *vynew; VALUE v0, v1; size_t i, n; switch (argc) { case 2: if (TYPE(argv[0]) == T_ARRAY) { v0 = rb_ary_entry(argv[0], 0); v1 = rb_ary_entry(argv[0], 1); if (VECTOR_P(v0) && VECTOR_P(v1)) { Data_Get_Struct(v0, gsl_vector, vx); Data_Get_Struct(v1, gsl_vector, vy); rad = NUM2DBL(argv[1]); } else { x = NUM2DBL(rb_ary_entry(argv[0], 0)); y = NUM2DBL(rb_ary_entry(argv[0], 1)); rad = NUM2DBL(argv[1]); c = cos(rad); s = sin(rad); return rb_ary_new3(2, rb_float_new(c*x - s*y), rb_float_new(s*x + c*y)); } } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[0]))); } break; case 3: if (VECTOR_P(argv[0]) && VECTOR_P(argv[1])) { Data_Get_Struct(argv[0], gsl_vector, vx); Data_Get_Struct(argv[1], gsl_vector, vy); rad = NUM2DBL(argv[1]); } else { x = NUM2DBL(argv[0]); y = NUM2DBL(argv[1]); rad = NUM2DBL(argv[2]); c = cos(rad); s = sin(rad); return rb_ary_new3(2, rb_float_new(c*x - s*y), rb_float_new(s*x + c*y)); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } n = (size_t) GSL_MIN(vx->size, vy->size); vxnew = gsl_vector_alloc(n); vynew = gsl_vector_alloc(n); c = cos(rad); s = sin(rad); for (i = 0; i < n; i++) { x = gsl_vector_get(vx, i); y = gsl_vector_get(vy, i); gsl_vector_set(vxnew, i, c*x - s*y); gsl_vector_set(vynew, i, s*x + c*y); } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vxnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vynew)); } #include "gsl/gsl_fit.h" static VALUE rb_gsl_vector_linearfit(int argc, VALUE *argv, VALUE klass) { gsl_vector *x, *y, *w = NULL; double c0, c1, c00, c01, c11, sumsq; switch (argc) { case 3: CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[0], gsl_vector, x); Data_Get_Struct(argv[1], gsl_vector, w); Data_Get_Struct(argv[2], gsl_vector, y); gsl_fit_wlinear(x->data, x->stride, w->data, w->stride, y->data, y->stride, y->size, &c0, &c1, &c00, &c01, &c11, &sumsq); break; case 2: CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_vector, x); Data_Get_Struct(argv[1], gsl_vector, y); gsl_fit_linear(x->data, x->stride, y->data,y->stride, y->size, &c0, &c1, &c00, &c01, &c11, &sumsq); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 2 or 3).\n", argc); } return rb_ary_new3(6, rb_float_new(c0), rb_float_new(c1), rb_float_new(c00), rb_float_new(c01), rb_float_new(c11), rb_float_new(sumsq)); } static VALUE rb_gsl_vector_center(VALUE obj) { gsl_vector *v, *vnew; double mean; Data_Get_Struct(obj, gsl_vector, v); mean = gsl_stats_mean(v->data, v->stride, v->size); vnew = gsl_vector_alloc(v->size); gsl_vector_memcpy(vnew, v); gsl_vector_add_constant(vnew, -mean); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } static VALUE rb_gsl_vector_clip(int argc, VALUE *argv, VALUE obj) { gsl_vector *v, *vnew; double hi = 1.0, lo = 0.0; double x; size_t i; Data_Get_Struct(obj, gsl_vector, v); switch (argc) { case 0: break; case 1: if (TYPE(argv[0]) == T_ARRAY) { lo = NUM2DBL(rb_ary_entry(argv[0], 0)); hi = NUM2DBL(rb_ary_entry(argv[0], 1)); } else { hi = NUM2DBL(argv[0]); } break; case 2: lo = NUM2DBL(argv[0]); hi = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2).\n", argc); } vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { x = gsl_vector_get(v, i); if (x > hi) x = hi; else if (x < lo) x = lo; else; gsl_vector_set(vnew, i, x); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } static VALUE rb_gsl_vector_amp_phase(VALUE obj) { gsl_vector *v; gsl_vector *amp, *phase; double re, im; VALUE vamp, vphase; size_t i; Data_Get_Struct(obj, gsl_vector, v); amp = gsl_vector_alloc(v->size/2); phase = gsl_vector_alloc(v->size/2); gsl_vector_set(amp, 0, gsl_vector_get(v, 0)); gsl_vector_set(phase, 0, 0); gsl_vector_set(amp, amp->size-1, gsl_vector_get(v, v->size-1)); gsl_vector_set(phase, phase->size-1, 0); for (i = 1; i < v->size-1; i+=2) { re = gsl_vector_get(v, i); im = gsl_vector_get(v, i+1); gsl_vector_set(amp, i/2+1, sqrt(re*re + im*im)); gsl_vector_set(phase, i/2+1, atan2(im, re)); } vamp = Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, amp); vphase = Data_Wrap_Struct(VECTOR_ROW_COL(obj), 0, gsl_vector_free, phase); return rb_ary_new3(2, vamp, vphase); } static VALUE rb_gsl_vector_clean(int argc, VALUE *argv, VALUE obj) { gsl_vector *v = NULL, *vnew = NULL; double eps = 1e-10; size_t n, i; switch (argc) { case 0: /* do nothing */ break; case 1: Need_Float(argv[0]); eps = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); break; } Data_Get_Struct(obj, gsl_vector, v); vnew = make_vector_clone(v); n = v->size; for (i = 0; i < n; i++) if (fabs(vnew->data[i]) < eps) vnew->data[i] = 0.0; return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);; } static VALUE rb_gsl_vector_clean_bang(int argc, VALUE *argv, VALUE obj) { gsl_vector *v = NULL; double eps = 1e-10; size_t n, i; switch (argc) { case 0: /* do nothing */ break; case 1: Need_Float(argv[0]); eps = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); break; } Data_Get_Struct(obj, gsl_vector, v); n = v->size; for (i = 0; i < n; i++) if (fabs(v->data[i]) < eps) v->data[i] = 0.0; return obj; } VALUE rb_gsl_pow(VALUE obj, VALUE xx, VALUE nn); VALUE rb_gsl_vector_pow(VALUE obj, VALUE p) { return rb_gsl_pow(Qnil, obj, p); } VALUE rb_gsl_vector_pow_bang(VALUE obj, VALUE pp) { gsl_vector *v; double p; size_t i; Data_Get_Struct(obj, gsl_vector, v); p = NUM2DBL(pp); for (i = 0; i < v->size; i++) { gsl_vector_set(v, i, pow(gsl_vector_get(v, i), p)); } return obj; } void Init_gsl_vector(VALUE module) { rb_define_singleton_method(cgsl_vector, "linspace", rb_gsl_vector_linspace, -1); rb_define_module_function(module, "linspace", rb_gsl_vector_linspace, -1); rb_define_singleton_method(cgsl_vector, "logspace", rb_gsl_vector_logspace, -1); rb_define_module_function(module, "logspace", rb_gsl_vector_logspace, -1); rb_define_singleton_method(cgsl_vector, "logspace2", rb_gsl_vector_logspace2, -1); rb_define_module_function(module, "logspace2", rb_gsl_vector_logspace2, -1); rb_define_method(cgsl_vector, "add", rb_gsl_vector_add, 1); rb_define_alias(cgsl_vector, "+", "add"); rb_define_method(cgsl_vector, "sub", rb_gsl_vector_sub, 1); rb_define_alias(cgsl_vector, "-", "sub"); rb_define_method(cgsl_vector, "mul", rb_gsl_vector_mul, 1); rb_define_alias(cgsl_vector, "*", "mul"); rb_define_method(cgsl_vector, "div", rb_gsl_vector_div, 1); rb_define_alias(cgsl_vector, "/", "div"); rb_define_method(cgsl_vector, "to_complex", rb_gsl_vector_to_complex, 0); rb_define_method(cgsl_vector, "to_complex2", rb_gsl_vector_to_complex2, 0); /*****/ rb_define_method(cgsl_vector, "coerce", rb_gsl_vector_coerce, 1); /*****/ rb_define_method(rb_cArray, "to_gv", rb_ary_to_gv0, 0); rb_define_alias(rb_cArray, "to_gslv", "to_gv"); rb_define_alias(rb_cArray, "to_gsl_vector", "to_gv"); rb_define_method(rb_cRange, "to_gv", rb_gsl_range_to_gv, 0); rb_define_alias(rb_cRange, "to_gslv", "to_gv"); rb_define_alias(rb_cRange, "to_gsl_vector", "to_gv"); rb_define_singleton_method(cgsl_vector, "ary_to_gv", rb_ary_to_gv, 1); /*****/ rb_define_method(cgsl_vector, "to_i", rb_gsl_vector_to_i, 0); rb_define_method(cgsl_vector, "to_f", rb_gsl_vector_to_f, 0); rb_define_singleton_method(cgsl_vector, "graph", rb_gsl_vector_graph2, -1); rb_define_module_function(module, "graph", rb_gsl_vector_graph2, -1); rb_define_singleton_method(cgsl_vector, "plot", rb_gsl_vector_plot2, -1); /*****/ rb_define_method(cgsl_vector, "normalize", rb_gsl_vector_normalize, -1); rb_define_method(cgsl_vector, "normalize!", rb_gsl_vector_normalize_bang, -1); #ifdef HAVE_NARRAY_H rb_define_singleton_method(cgsl_vector, "filescan_na", rb_gsl_vector_filescan_na, 1); rb_define_singleton_method(cNArray, "filescan", rb_gsl_vector_filescan_na, 1); #endif rb_define_method(cgsl_vector, "decimate", rb_gsl_vector_decimate, 1); rb_define_method(cgsl_vector, "floor", rb_gsl_vector_floor, 0); rb_define_method(cgsl_vector, "ceil", rb_gsl_vector_ceil, 0); rb_define_method(cgsl_vector, "round", rb_gsl_vector_round, 0); rb_define_method(cgsl_vector, "dB", rb_gsl_vector_dB, 0); rb_define_method(cgsl_vector, "sin", rb_gsl_vector_sin, 0); rb_define_method(cgsl_vector, "cos", rb_gsl_vector_cos, 0); rb_define_method(cgsl_vector, "tan", rb_gsl_vector_tan, 0); rb_define_method(cgsl_vector, "exp", rb_gsl_vector_exp, 0); rb_define_method(cgsl_vector, "log", rb_gsl_vector_log, 0); rb_define_method(cgsl_vector, "log10", rb_gsl_vector_log10, 0); rb_define_singleton_method(cgsl_vector, "rotate", rb_gsl_vector_rotate, -1); rb_define_singleton_method(cgsl_vector, "rotate!", rb_gsl_vector_rotate_bang, -1); rb_define_singleton_method(cgsl_vector, "linearfit", rb_gsl_vector_linearfit, -1); rb_define_method(cgsl_vector, "center", rb_gsl_vector_center, 0); rb_define_method(cgsl_vector, "clip", rb_gsl_vector_clip, -1); rb_define_method(cgsl_vector, "amp_phase", rb_gsl_vector_amp_phase, 0); rb_define_method(cgsl_vector, "clean", rb_gsl_vector_clean, -1); rb_define_method(cgsl_vector, "clean!", rb_gsl_vector_clean_bang, -1); rb_define_method(cgsl_vector, "pow", rb_gsl_vector_pow, 1); rb_define_alias(cgsl_vector, "**", "pow"); rb_define_method(cgsl_vector, "pow!", rb_gsl_vector_pow_bang, 1); Init_gsl_vector_init(module); } gsl-1.15.3/ext/function.c0000644000175000017500000003657012220252463014546 0ustar boutilboutil/* function.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_function.h" #ifdef HAVE_NARRAY_H #include "narray.h" #endif VALUE cgsl_function; VALUE cgsl_function_fdf; void gsl_function_free(gsl_function *f); double rb_gsl_function_f(double x, void *p); ID RBGSL_ID_call, RBGSL_ID_arity; static VALUE rb_gsl_function_set_f(int argc, VALUE *argv, VALUE obj) { gsl_function *F = NULL; VALUE ary, ary2; size_t i; Data_Get_Struct(obj, gsl_function, F); if (F->params == NULL) { ary = rb_ary_new2(2); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 1, Qnil); switch (argc) { case 0: break; case 1: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); break; case 2: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); break; default: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); ary2 = rb_ary_new2(argc-1); for (i = 1; i < argc; i++) rb_ary_store(ary2, i-1, argv[i]); rb_ary_store(ary, 1, ary2); break; } if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); return obj; } void gsl_function_free(gsl_function *f) { if (f) free((gsl_function *) f); } void gsl_function_mark(gsl_function *f) { rb_gc_mark((VALUE) f->params); } /* * Create a Function object */ static VALUE rb_gsl_function_alloc(int argc, VALUE *argv, VALUE klass) { gsl_function *f = NULL; VALUE obj; f = ALLOC(gsl_function); f->function = &rb_gsl_function_f; /* (VALUE) f->params = rb_ary_new2(2);*/ f->params = (void *) rb_ary_new2(2); rb_ary_store((VALUE) f->params, 1, Qnil); obj = Data_Wrap_Struct(klass, gsl_function_mark, gsl_function_free, f); rb_gsl_function_set_f(argc, argv, obj); return obj; } double rb_gsl_function_f(double x, void *p) { VALUE result, ary, proc, params; ary = (VALUE) p; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, rb_float_new(x)); else result = rb_funcall(proc, RBGSL_ID_call, 2, rb_float_new(x), params); return NUM2DBL(result); } /* * Calculates a function at x, and returns the rusult. */ static VALUE rb_gsl_function_eval(VALUE obj, VALUE x) { gsl_function *F = NULL; VALUE ary, proc, params, result, arynew, x2; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; size_t i, j, n; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Data_Get_Struct(obj, gsl_function, F); ary = (VALUE) F->params; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); if (CLASS_OF(x) == rb_cRange) x = rb_gsl_range2ary(x); switch (TYPE(x)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x); else result = rb_funcall(proc, RBGSL_ID_call, 2, x, params); return result; break; case T_ARRAY: // n = RARRAY(x)->len; n = RARRAY_LEN(x); arynew = rb_ary_new2(n); for (i = 0; i < n; i++) { x2 = rb_ary_entry(x, i); Need_Float(x2); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); rb_ary_store(arynew, i, result); } return arynew; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(x)) { GetNArray(x, na); ptr1 = (double *) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(x)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) { x2 = rb_float_new(ptr1[i]); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); ptr2[i] = NUM2DBL(result); } return ary; } #endif if (VECTOR_P(x)) { Data_Get_Struct(x, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { x2 = rb_float_new(gsl_vector_get(v, i)); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); gsl_vector_set(vnew, i, NUM2DBL(result)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(x)) { Data_Get_Struct(x, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { x2 = rb_float_new(gsl_matrix_get(m, i, j)); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); gsl_matrix_set(mnew, i, j, NUM2DBL(result)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } /* never reach here */ return Qnil; } static VALUE rb_gsl_function_arity(VALUE obj) { gsl_function *F = NULL; VALUE proc; Data_Get_Struct(obj, gsl_function, F); proc = rb_ary_entry((VALUE) F->params, 0); return INT2FIX(rb_funcall(proc, RBGSL_ID_arity, 0)); } static VALUE rb_gsl_function_proc(VALUE obj) { gsl_function *F = NULL; Data_Get_Struct(obj, gsl_function, F); return rb_ary_entry((VALUE) F->params, 0); } static VALUE rb_gsl_function_params(VALUE obj) { gsl_function *F = NULL; Data_Get_Struct(obj, gsl_function, F); return rb_ary_entry((VALUE) F->params, 1); } static VALUE rb_gsl_function_set_params(int argc, VALUE *argv, VALUE obj) { gsl_function *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_function, F); ary = (VALUE) F->params; if (argc == 1) { rb_ary_store(ary, 1, argv[0]); } else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 1, ary2); } return obj; } static VALUE rb_gsl_function_graph(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH gsl_function *F = NULL; gsl_vector *v = NULL; double x, y; char opt[256] = "", command[1024]; size_t i, n; int flag = 0; FILE *fp = NULL; VALUE ary, params, proc; switch (argc) { case 2: Check_Type(argv[1], T_STRING); strcpy(opt, STR2CSTR(argv[1])); /* no break, do next */ case 1: if (CLASS_OF(argv[0]) == rb_cRange) argv[0] = rb_gsl_range2ary(argv[0]); if (TYPE(argv[0]) == T_ARRAY) { // n = RARRAY(argv[0])->len; n = RARRAY_LEN(argv[0]); v = gsl_vector_alloc(n); flag = 1; for (i = 0; i < n; i++) gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(argv[0], i))); } else if (rb_obj_is_kind_of(argv[0], cgsl_vector)) { Data_Get_Struct(argv[0], gsl_vector, v); n = v->size; flag = 0; } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or GSL::Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Struct(obj, gsl_function, F); ary = (VALUE) F->params; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); sprintf(command, "graph -T X -g 3 %s", opt); fp = popen(command, "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); for (i = 0; i < n; i++) { x = gsl_vector_get(v, i); if (NIL_P(params)) y = NUM2DBL(rb_funcall(proc, RBGSL_ID_call, 1, rb_float_new(x))); else y = NUM2DBL(rb_funcall(proc, RBGSL_ID_call, 2, rb_float_new(x), params)); fprintf(fp, "%e %e\n", x, y); } fflush(fp); pclose(fp); fp = NULL; if (flag == 1) gsl_vector_free(v); return Qtrue; #else rb_raise(rb_eNoMethodError, "not implemented"); return Qfalse; #endif } static double rb_gsl_function_fdf_f(double x, void *p); static void gsl_function_fdf_free(gsl_function_fdf *f); static double rb_gsl_function_fdf_f(double x, void *p); static double rb_gsl_function_fdf_df(double x, void *p); static void rb_gsl_function_fdf_fdf(double x, void *p, double *f, double *df); static void setfunc(int i, VALUE *argv, gsl_function_fdf *F); static void setfunc(int i, VALUE *argv, gsl_function_fdf *F) { VALUE ary; if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } if (rb_obj_is_kind_of(argv[i], rb_cProc)) { rb_ary_store(ary, i, argv[i]); } else if (TYPE(argv[i]) == T_ARRAY || rb_obj_is_kind_of(argv[i], cgsl_vector) || TYPE(argv[i]) == T_FIXNUM || TYPE(argv[i]) == T_FLOAT) { rb_ary_store(ary, 3, argv[i]); } else { rb_raise(rb_eArgError, "wrong type argument (Proc, Array, GSL::Vector or a number)"); } } static void gsl_function_fdf_mark(gsl_function_fdf *f); static VALUE rb_gsl_function_fdf_new(int argc, VALUE *argv, VALUE klass) { gsl_function_fdf *F = NULL; VALUE ary; size_t i; F = ALLOC(gsl_function_fdf); F->f = &rb_gsl_function_fdf_f; F->df = &rb_gsl_function_fdf_df; F->fdf = &rb_gsl_function_fdf_fdf; ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; rb_ary_store(ary, 2, Qnil); rb_ary_store(ary, 3, Qnil); for (i = 0; i < argc; i++) setfunc(i, argv, F); return Data_Wrap_Struct(klass, gsl_function_fdf_mark, gsl_function_fdf_free, F); } static void gsl_function_fdf_free(gsl_function_fdf *f) { free((gsl_function_fdf *) f); } static void gsl_function_fdf_mark(gsl_function_fdf *f) { rb_gc_mark((VALUE) f->params); } static VALUE rb_gsl_function_fdf_set(int argc, VALUE *argv, VALUE obj) { gsl_function_fdf *F = NULL; VALUE ary; size_t i; Data_Get_Struct(obj, gsl_function_fdf, F); ary = (VALUE) F->params; rb_ary_store(ary, 2, Qnil); rb_ary_store(ary, 3, Qnil); for (i = 0; i < argc; i++) setfunc(i, argv, F); return obj; } static VALUE rb_gsl_function_fdf_set_f(VALUE obj, VALUE procf) { gsl_function_fdf *F = NULL; VALUE ary; CHECK_PROC(procf); Data_Get_Struct(obj, gsl_function_fdf, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 0, procf); return obj; } static VALUE rb_gsl_function_fdf_set_df(VALUE obj, VALUE procdf) { gsl_function_fdf *F = NULL; VALUE ary; CHECK_PROC(procdf); Data_Get_Struct(obj, gsl_function_fdf, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 1, procdf); return obj; } static VALUE rb_gsl_function_fdf_set_fdf(VALUE obj, VALUE procfdf) { gsl_function_fdf *F = NULL; VALUE ary; CHECK_PROC(procfdf); Data_Get_Struct(obj, gsl_function_fdf, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 2, procfdf); return obj; } static VALUE rb_gsl_function_fdf_set_params(int argc, VALUE *argv, VALUE obj) { gsl_function_fdf *F = NULL; VALUE ary, ary2; size_t i; Data_Get_Struct(obj, gsl_function_fdf, F); ary = (VALUE) F->params; if (argc == 0) return obj; if (argc == 1) { rb_ary_store(ary, 3, argv[0]); } else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 3, ary2); } return obj; } static double rb_gsl_function_fdf_f(double x, void *p) { VALUE result, params, proc, ary; ary = (VALUE) p; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 3); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, rb_float_new(x)); else result = rb_funcall(proc, RBGSL_ID_call, 2, rb_float_new(x), params); return NUM2DBL(result); } static double rb_gsl_function_fdf_df(double x, void *p) { VALUE result, params, proc, ary; ary = (VALUE) p; proc = rb_ary_entry(ary, 1); params = rb_ary_entry(ary, 3); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, rb_float_new(x)); else result = rb_funcall(proc, RBGSL_ID_call, 2, rb_float_new(x), params); return NUM2DBL(result); } static void rb_gsl_function_fdf_fdf(double x, void *p, double *f, double *df) { VALUE result, params, proc_f, proc_df, proc_fdf, ary; ary = (VALUE) p; proc_f = rb_ary_entry(ary, 0); proc_df = rb_ary_entry(ary, 1); proc_fdf = rb_ary_entry(ary, 2); params = rb_ary_entry(ary, 3); if (NIL_P(proc_fdf)) { if (NIL_P(params)) { result = rb_funcall(proc_f, RBGSL_ID_call, 1, rb_float_new(x)); *f = NUM2DBL(result); result = rb_funcall(proc_df, RBGSL_ID_call, 1, rb_float_new(x)); *df = NUM2DBL(result); } else { result = rb_funcall(proc_f, RBGSL_ID_call, 2, rb_float_new(x), params); *f = NUM2DBL(result); result = rb_funcall(proc_df, RBGSL_ID_call, 2, rb_float_new(x), params); *df = NUM2DBL(result); } } else { if (NIL_P(params)) result = rb_funcall(proc_fdf, RBGSL_ID_call, 1, rb_float_new(x)); else result = rb_funcall(proc_fdf, RBGSL_ID_call, 2, rb_float_new(x), params); *f = NUM2DBL(rb_ary_entry(result, 0)); *df = NUM2DBL(rb_ary_entry(result, 1)); } } void Init_gsl_function(VALUE module) { RBGSL_ID_call = rb_intern("call"); RBGSL_ID_arity = rb_intern("arity"); cgsl_function = rb_define_class_under(module, "Function", cGSL_Object); cgsl_function_fdf = rb_define_class_under(module, "Function_fdf", cGSL_Object); // This Fdf class seems superfluous. Should probably be deleted? rb_define_class_under(cgsl_function_fdf, "Fdf", cgsl_function_fdf); /* rb_define_singleton_method(cgsl_function, "new", rb_gsl_function_new, -1);*/ rb_define_singleton_method(cgsl_function, "alloc", rb_gsl_function_alloc, -1); rb_define_method(cgsl_function, "eval", rb_gsl_function_eval, 1); rb_define_alias(cgsl_function, "call", "eval"); rb_define_alias(cgsl_function, "[]", "eval"); rb_define_alias(cgsl_function, "at", "eval"); rb_define_method(cgsl_function, "arity", rb_gsl_function_arity, 0); rb_define_method(cgsl_function, "proc", rb_gsl_function_proc, 0); rb_define_alias(cgsl_function, "f", "proc"); rb_define_method(cgsl_function, "params", rb_gsl_function_params, 0); rb_define_alias(cgsl_function, "param", "params"); rb_define_method(cgsl_function, "set", rb_gsl_function_set_f, -1); rb_define_method(cgsl_function, "set_params", rb_gsl_function_set_params, -1); rb_define_alias(cgsl_function, "set_param", "set_params"); rb_define_alias(cgsl_function, "params=", "set_params"); rb_define_alias(cgsl_function, "param=", "set_params"); rb_define_method(cgsl_function, "graph", rb_gsl_function_graph, -1); /*****/ rb_define_singleton_method(cgsl_function_fdf, "new", rb_gsl_function_fdf_new, -1); rb_define_singleton_method(cgsl_function_fdf, "alloc", rb_gsl_function_fdf_new, -1); rb_define_method(cgsl_function_fdf, "set", rb_gsl_function_fdf_set, -1); rb_define_method(cgsl_function_fdf, "set_f", rb_gsl_function_fdf_set_f, 1); rb_define_method(cgsl_function_fdf, "set_df", rb_gsl_function_fdf_set_df, 1); rb_define_method(cgsl_function_fdf, "set_fdf", rb_gsl_function_fdf_set_fdf, 1); rb_define_method(cgsl_function_fdf, "set_params", rb_gsl_function_fdf_set_params, -1); } gsl-1.15.3/ext/dht.c0000644000175000017500000002317012220252463013470 0ustar boutilboutil/* dht.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_array.h" #include "rb_gsl_common.h" #include #ifdef HAVE_NARRAY_H #include "narray.h" #endif static VALUE rb_gsl_dht_alloc(int argc, VALUE *argv, VALUE klass) { gsl_dht *t = NULL; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); t = gsl_dht_alloc(FIX2INT(argv[0])); break; case 3: CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); t = gsl_dht_new(FIX2INT(argv[0]), NUM2DBL(argv[1]), NUM2DBL(argv[2])); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc); break; } return Data_Wrap_Struct(klass, 0, gsl_dht_free, t); } static VALUE rb_gsl_dht_init(VALUE obj, VALUE nu, VALUE xmax) { gsl_dht *t = NULL; Need_Float(nu); Need_Float(xmax); Data_Get_Struct(obj, gsl_dht, t); gsl_dht_init(t, NUM2DBL(nu), NUM2DBL(xmax)); return obj; } static VALUE rb_gsl_dht_apply(int argc, VALUE *argv, VALUE obj) { gsl_dht *t = NULL; double *ptr1, *ptr2; gsl_vector *vin, *vout; size_t size, stride; #ifdef HAVE_NARRAY_H struct NARRAY *na; #endif VALUE ary; switch (argc) { case 2: Data_Get_Struct(obj, gsl_dht, t); ptr1 = get_vector_ptr(argv[0], &stride, &size); ptr2 = get_vector_ptr(argv[1], &stride, &size); return INT2FIX(gsl_dht_apply(t, ptr1, ptr2)); break; case 1: Data_Get_Struct(obj, gsl_dht, t); if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, vin); ptr1 = vin->data; vout = gsl_vector_alloc(vin->size); ptr2 = vout->data; ary = Data_Wrap_Struct(VECTOR_ROW_COL(argv[0]), 0, gsl_vector_free, vout); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[0])) { GetNArray(argv[0], na); ptr1 = (double*)na->ptr; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv[0])); ptr2 = NA_PTR_TYPE(ary, double*); #endif } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } gsl_dht_apply(t, ptr1, ptr2); return ary; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_dht_xk_sample(VALUE obj, VALUE n, double (*sample)(const gsl_dht*, int)) { gsl_dht *t = NULL; gsl_vector_int *vi; gsl_vector *v; size_t i, size; int nn; VALUE ary; double val; #ifdef HAVE_NARRAY_H struct NARRAY *na; int *ptr; double *ptr2; #endif Data_Get_Struct(obj, gsl_dht, t); if (CLASS_OF(n) == rb_cRange) n = rb_gsl_range2ary(n); switch (TYPE(n)) { case T_FIXNUM: return rb_float_new((*sample)(t, FIX2INT(n))); break; case T_ARRAY: // size = RARRAY(n)->len; size = RARRAY_LEN(n); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { nn = FIX2INT(rb_ary_entry(n, i)); val = (*sample)(t, nn); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: if (VECTOR_INT_P(n)) { Data_Get_Struct(n, gsl_vector_int, vi); v = gsl_vector_alloc(vi->size); for (i = 0; i < v->size; i++) { nn = gsl_vector_int_get(vi, i); val = (*sample)(t, nn); gsl_vector_set(v, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(n)) { GetNArray(n, na); ptr = (int*) na->ptr; size = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, cNArray); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < size; i++) { ptr2[i] = (*sample)(t, ptr[i]); } return ary; #endif } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector::Int expected)", rb_class2name(CLASS_OF(n))); } } return Qnil; } static VALUE rb_gsl_dht_x_sample(VALUE obj, VALUE n) { return rb_gsl_dht_xk_sample(obj, n, gsl_dht_x_sample); } static VALUE rb_gsl_dht_k_sample(VALUE obj, VALUE n) { return rb_gsl_dht_xk_sample(obj, n, gsl_dht_k_sample); } static VALUE rb_gsl_dht_j(VALUE obj) { gsl_dht *t = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_dht, t); v = rb_gsl_make_vector_view(t->j, (t->size+2), 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_dht_zero(VALUE obj) { gsl_dht *t = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_dht, t); v = rb_gsl_make_vector_view(t->j+1, (t->size+1), 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_dht_Jjj(VALUE obj) { gsl_dht *t = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_dht, t); v = rb_gsl_make_vector_view(t->Jjj, t->size*(t->size+1)/2, 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_dht_sample(int argc, VALUE *argv, VALUE obj) { gsl_dht *t = NULL; gsl_matrix *mm = NULL; size_t n, m; double val; Data_Get_Struct(obj, gsl_dht, t); switch (argc) { case 0: mm = gsl_matrix_alloc(t->size, t->size); for (n = 0; n < t->size; n++) { for (m = 0; m < t->size; m++) { val = t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax; gsl_matrix_set(mm, n, m, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mm); break; case 2: n = FIX2INT(argv[0]); m = FIX2INT(argv[1]); val = t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax; return rb_float_new(val); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 2)", argc); break; } return Qnil; } static VALUE rb_gsl_dht_num(int argc, VALUE *argv, VALUE obj) { gsl_dht *t = NULL; gsl_matrix *mm = NULL; size_t n, m; double val; Data_Get_Struct(obj, gsl_dht, t); switch (argc) { case 0: mm = gsl_matrix_alloc(t->size, t->size); for (n = 0; n < t->size; n++) { for (m = 0; m < t->size; m++) { val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax); gsl_matrix_set(mm, n, m, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mm); break; case 2: n = FIX2INT(argv[0]); m = FIX2INT(argv[1]); val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax); return rb_float_new(val); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 2)", argc); break; } return Qnil; } static VALUE rb_gsl_dht_J2(VALUE obj) { gsl_dht *t = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_dht, t); v = rb_gsl_make_vector_view(t->J2, t->size+1, 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_dht_den(VALUE obj) { gsl_dht *t = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_dht, t); v = rb_gsl_make_vector_view(t->J2+1, t->size, 1); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, free, v); } static VALUE rb_gsl_dht_size(VALUE obj) { gsl_dht *t = NULL; Data_Get_Struct(obj, gsl_dht, t); return INT2FIX(t->size); } static VALUE rb_gsl_dht_nu(VALUE obj) { gsl_dht *t = NULL; Data_Get_Struct(obj, gsl_dht, t); return rb_float_new(t->nu); } static VALUE rb_gsl_dht_xmax(VALUE obj) { gsl_dht *t = NULL; Data_Get_Struct(obj, gsl_dht, t); return rb_float_new(t->xmax); } static VALUE rb_gsl_dht_kmax(VALUE obj) { gsl_dht *t = NULL; Data_Get_Struct(obj, gsl_dht, t); return rb_float_new(t->kmax); } static VALUE rb_gsl_dht_coef(int argc, VALUE *argv, VALUE obj) { gsl_dht *t = NULL; gsl_matrix *mm = NULL; size_t n, m; double val; Data_Get_Struct(obj, gsl_dht, t); switch (argc) { case 0: mm = gsl_matrix_alloc(t->size, t->size); for (n = 0; n < t->size; n++) { for (m = 0; m < t->size; m++) { val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax); val *= (2.0/t->xmax/t->xmax)/t->J2[m+1]; gsl_matrix_set(mm, n, m, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mm); break; case 2: n = FIX2INT(argv[0]); m = FIX2INT(argv[1]); val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax); val *= (2.0/t->xmax/t->xmax)/t->J2[m+1]; return rb_float_new(val); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 2)", argc); break; } return Qnil; } void Init_gsl_dht(VALUE module) { VALUE cgsl_dht; cgsl_dht = rb_define_class_under(module, "Dht", cGSL_Object); rb_define_singleton_method(cgsl_dht, "alloc", rb_gsl_dht_alloc, -1); rb_define_method(cgsl_dht, "init", rb_gsl_dht_init, 2); rb_define_method(cgsl_dht, "apply", rb_gsl_dht_apply, -1); rb_define_method(cgsl_dht, "x_sample", rb_gsl_dht_x_sample, 1); rb_define_method(cgsl_dht, "k_sample", rb_gsl_dht_k_sample, 1); rb_define_method(cgsl_dht, "size", rb_gsl_dht_size, 0); rb_define_method(cgsl_dht, "nu", rb_gsl_dht_nu, 0); rb_define_method(cgsl_dht, "xmax", rb_gsl_dht_xmax, 0); rb_define_method(cgsl_dht, "kmax", rb_gsl_dht_kmax, 0); rb_define_method(cgsl_dht, "j", rb_gsl_dht_j, 0); rb_define_method(cgsl_dht, "Jjj", rb_gsl_dht_Jjj, 0); rb_define_method(cgsl_dht, "J2", rb_gsl_dht_J2, 0); rb_define_method(cgsl_dht, "zero", rb_gsl_dht_zero, 0); rb_define_alias(cgsl_dht, "zeros", "zero"); rb_define_method(cgsl_dht, "sample", rb_gsl_dht_sample, -1); rb_define_method(cgsl_dht, "num", rb_gsl_dht_num, -1); rb_define_method(cgsl_dht, "den", rb_gsl_dht_den, 0); rb_define_method(cgsl_dht, "coef", rb_gsl_dht_coef, -1); } gsl-1.15.3/ext/rng.c0000644000175000017500000006327412220252463013510 0ustar boutilboutil/* rng.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ /* Document-class: GSL::Rng Random number generator */ #include "rb_gsl_config.h" #include "rb_gsl_rng.h" #ifdef HAVE_RNGEXTRA_RNGEXTRA_H #include "rngextra/rngextra.h" #endif /* Global, since used in other source files */ VALUE cgsl_rng; enum rb_gsl_rng_generator { GSL_RNG_DEFAULT, GSL_RNG_MT19937, GSL_RNG_MT19937_1999, GSL_RNG_MT19937_1998, GSL_RNG_RANLXS0, GSL_RNG_RANLXS1, GSL_RNG_RANLXS2, GSL_RNG_RANLXD1, GSL_RNG_RANLXD2, GSL_RNG_RANLUX, GSL_RNG_RANLUX389, GSL_RNG_CMRG, GSL_RNG_MRG, GSL_RNG_TAUS, GSL_RNG_TAUS2, GSL_RNG_TAUS113, GSL_RNG_GFSR4, GSL_RNG_RAND, GSL_RNG_RANDOM_BSD, GSL_RNG_RANDOM_GLIBC2, GSL_RNG_RANDOM8_GLIBC2, GSL_RNG_RANDOM32_GLIBC2, GSL_RNG_RANDOM64_GLIBC2, GSL_RNG_RANDOM128_GLIBC2, GSL_RNG_RANDOM256_GLIBC2, GSL_RNG_RANDOM8_BSD, GSL_RNG_RANDOM32_BSD, GSL_RNG_RANDOM64_BSD, GSL_RNG_RANDOM128_BSD, GSL_RNG_RANDOM256_BSD, GSL_RNG_RANDOM_LIBC5, GSL_RNG_RANDOM8_LIBC5, GSL_RNG_RANDOM32_LIBC5, GSL_RNG_RANDOM64_LIBC5, GSL_RNG_RANDOM128_LIBC5, GSL_RNG_RANDOM256_LIBC5, GSL_RNG_RAND48, GSL_RNG_RAN0, GSL_RNG_RAN1, GSL_RNG_RAN2, GSL_RNG_RAN3, GSL_RNG_RANF, GSL_RNG_RANMAR, GSL_RNG_R250, GSL_RNG_TT800, GSL_RNG_VAX, GSL_RNG_TRANSPUTER, GSL_RNG_RANDU, GSL_RNG_MINSTD, GSL_RNG_UNI, GSL_RNG_UNI32, GSL_RNG_SLATEC, GSL_RNG_ZUF, /* from gsl-1.1 */ GSL_RNG_BOROSH13, GSL_RNG_COVEYOU, GSL_RNG_FISHMAN18, GSL_RNG_FISHMAN20, GSL_RNG_FISHMAN2X, GSL_RNG_KNUTHRAN, GSL_RNG_KNUTHRAN2, GSL_RNG_LECUYER21, GSL_RNG_WATERMAN14, /* For the rngextra package */ /* Tue Oct 19 22:55:56 JST 2004 by Y.Tsunesada */ GSL_RNGEXTRA_RNG1, GSL_RNGEXTRA_RNG2, /* GSL-1.9 */ GSL_RNG_KNUTHRAN2002, }; static const gsl_rng_type* get_gsl_rng_type(VALUE t); /* Document-method: GSL::Rng.alloc Constructor. */ static VALUE rb_gsl_rng_alloc(int argc, VALUE *argv, VALUE klass) { gsl_rng *r = NULL; const gsl_rng_type *T; unsigned long seed; int itype; gsl_rng_env_setup(); if (argc == 0) { T = gsl_rng_default; seed = gsl_rng_default_seed; } else { T = get_gsl_rng_type(argv[0]); if (argc == 1) { seed = gsl_rng_default_seed; } else if (argc == 2) { itype = TYPE(argv[1]); if (itype == T_FIXNUM || itype == T_BIGNUM) { seed = FIX2INT(argv[1]); } else { rb_raise(rb_eArgError, "bad argument 2, seed must be an integer."); } } else { rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); } } r = gsl_rng_alloc(T); gsl_rng_set(r, seed); return Data_Wrap_Struct(klass, 0, gsl_rng_free, r); } static const gsl_rng_type* get_gsl_rng_type_int(int itype); static const gsl_rng_type* get_gsl_rng_type_name(char *name); static const gsl_rng_type* get_gsl_rng_type(VALUE t) { switch (TYPE(t)) { case T_STRING: return get_gsl_rng_type_name(STR2CSTR(t)); break; case T_FIXNUM: return get_gsl_rng_type_int(FIX2INT(t)); break; default: rb_raise(rb_eTypeError, "String or Fixnum expected"); } } static const gsl_rng_type* get_gsl_rng_type_name(char *name) { if (str_tail_grep(name, "default") == 0) return gsl_rng_default; else if (str_tail_grep(name, "mt19937") == 0) return gsl_rng_mt19937; #ifdef GSL_1_1_LATER else if (str_tail_grep(name, "borosh13") == 0) return gsl_rng_borosh13; else if (str_tail_grep(name, "coveyou") == 0) return gsl_rng_coveyou; else if (str_tail_grep(name, "fishman18") == 0) return gsl_rng_fishman18; else if (str_tail_grep(name, "fishman20") == 0) return gsl_rng_fishman20; else if (str_tail_grep(name, "fishman2x") == 0) return gsl_rng_fishman2x; else if (str_tail_grep(name, "lecuyer21") == 0) return gsl_rng_lecuyer21; else if (str_tail_grep(name, "waterman14") == 0) return gsl_rng_waterman14; else if (str_tail_grep(name, "knuthran") == 0) return gsl_rng_knuthran; else if (str_tail_grep(name, "knuthran2") == 0) return gsl_rng_knuthran2; #endif #ifdef GSL_1_2_LATER else if (str_tail_grep(name, "mt19937_1999") == 0) return gsl_rng_mt19937_1999; else if (str_tail_grep(name, "mt19937-1999") == 0) return gsl_rng_mt19937_1999; else if (str_tail_grep(name, "mt19937_1998") == 0) return gsl_rng_mt19937_1998; else if (str_tail_grep(name, "mt19937-1998") == 0) return gsl_rng_mt19937_1998; else if (str_tail_grep(name, "taus113") == 0) return gsl_rng_taus113; else if (str_tail_grep(name, "taus2") == 0) return gsl_rng_taus2; #endif else if (str_tail_grep(name, "mt19937") == 0) return gsl_rng_mt19937; else if (str_tail_grep(name, "ranlxs0") == 0) return gsl_rng_ranlxs0; else if (str_tail_grep(name, "ranlxs1") == 0) return gsl_rng_ranlxs1; else if (str_tail_grep(name, "ranlxs2") == 0) return gsl_rng_ranlxs2; else if (str_tail_grep(name, "ranlxd1") == 0) return gsl_rng_ranlxd1; else if (str_tail_grep(name, "ranlxd2") == 0) return gsl_rng_ranlxd2; else if (str_tail_grep(name, "ranlux") == 0) return gsl_rng_ranlux; else if (str_tail_grep(name, "ranlux389") == 0) return gsl_rng_ranlux389; else if (str_tail_grep(name, "cmrg") == 0) return gsl_rng_cmrg; else if (str_tail_grep(name, "mrg") == 0) return gsl_rng_mrg; else if (str_tail_grep(name, "taus") == 0) return gsl_rng_taus; else if (str_tail_grep(name, "gfsr4") == 0) return gsl_rng_gfsr4; else if (str_tail_grep(name, "rand") == 0) return gsl_rng_rand; else if (str_tail_grep(name, "random_libc5") == 0) return gsl_rng_random_libc5; else if (str_tail_grep(name, "random8_libc5") == 0) return gsl_rng_random8_libc5; else if (str_tail_grep(name, "random32_libc5") == 0) return gsl_rng_random32_libc5; else if (str_tail_grep(name, "random64_libc5") == 0) return gsl_rng_random64_libc5; else if (str_tail_grep(name, "random128_libc5") == 0) return gsl_rng_random128_libc5; else if (str_tail_grep(name, "random256_libc5") == 0) return gsl_rng_random256_libc5; else if (str_tail_grep(name, "random-libc5") == 0) return gsl_rng_random_libc5; else if (str_tail_grep(name, "random8-libc5") == 0) return gsl_rng_random8_libc5; else if (str_tail_grep(name, "random32-libc5") == 0) return gsl_rng_random32_libc5; else if (str_tail_grep(name, "random64-libc5") == 0) return gsl_rng_random64_libc5; else if (str_tail_grep(name, "random128-libc5") == 0) return gsl_rng_random128_libc5; else if (str_tail_grep(name, "random256-libc5") == 0) return gsl_rng_random256_libc5; else if (str_tail_grep(name, "random_glibc2") == 0) return gsl_rng_random_glibc2; else if (str_tail_grep(name, "random8_glibc2") == 0) return gsl_rng_random8_glibc2; else if (str_tail_grep(name, "random32_glibc2") == 0) return gsl_rng_random32_glibc2; else if (str_tail_grep(name, "random64_glibc2") == 0) return gsl_rng_random64_glibc2; else if (str_tail_grep(name, "random128_glibc2") == 0) return gsl_rng_random128_glibc2; else if (str_tail_grep(name, "random256_glibc2") == 0) return gsl_rng_random256_glibc2; else if (str_tail_grep(name, "random-glibc2") == 0) return gsl_rng_random_glibc2; else if (str_tail_grep(name, "random8-glibc2") == 0) return gsl_rng_random8_glibc2; else if (str_tail_grep(name, "random32-glibc2") == 0) return gsl_rng_random32_glibc2; else if (str_tail_grep(name, "random64-glibc2") == 0) return gsl_rng_random64_glibc2; else if (str_tail_grep(name, "random128-glibc2") == 0) return gsl_rng_random128_glibc2; else if (str_tail_grep(name, "random256-glibc2") == 0) return gsl_rng_random256_glibc2; else if (str_tail_grep(name, "random_bsd") == 0) return gsl_rng_random_bsd; else if (str_tail_grep(name, "random8_bsd") == 0) return gsl_rng_random8_bsd; else if (str_tail_grep(name, "random32_bsd") == 0) return gsl_rng_random32_bsd; else if (str_tail_grep(name, "random64_bsd") == 0) return gsl_rng_random64_bsd; else if (str_tail_grep(name, "random128_bsd") == 0) return gsl_rng_random128_bsd; else if (str_tail_grep(name, "random256_bsd") == 0) return gsl_rng_random256_bsd; else if (str_tail_grep(name, "random-bsd") == 0) return gsl_rng_random_bsd; else if (str_tail_grep(name, "random8-bsd") == 0) return gsl_rng_random8_bsd; else if (str_tail_grep(name, "random32-bsd") == 0) return gsl_rng_random32_bsd; else if (str_tail_grep(name, "random64-bsd") == 0) return gsl_rng_random64_bsd; else if (str_tail_grep(name, "random128-bsd") == 0) return gsl_rng_random128_bsd; else if (str_tail_grep(name, "random256-bsd") == 0) return gsl_rng_random256_bsd; else if (str_tail_grep(name, "rand48") == 0) return gsl_rng_rand48; else if (str_tail_grep(name, "ran0") == 0) return gsl_rng_ran0; else if (str_tail_grep(name, "ran1") == 0) return gsl_rng_ran1; else if (str_tail_grep(name, "ran2") == 0) return gsl_rng_ran2; else if (str_tail_grep(name, "ran3") == 0) return gsl_rng_ran3; else if (str_tail_grep(name, "ranf") == 0) return gsl_rng_ranf; else if (str_tail_grep(name, "ranmar") == 0) return gsl_rng_ranmar; else if (str_tail_grep(name, "r250") == 0) return gsl_rng_r250; else if (str_tail_grep(name, "tt800") == 0) return gsl_rng_tt800; else if (str_tail_grep(name, "vax") == 0) return gsl_rng_vax; else if (str_tail_grep(name, "transputer") == 0) return gsl_rng_transputer; else if (str_tail_grep(name, "randu") == 0) return gsl_rng_randu; else if (str_tail_grep(name, "minstd") == 0) return gsl_rng_minstd; else if (str_tail_grep(name, "uni") == 0) return gsl_rng_uni; else if (str_tail_grep(name, "uni32") == 0) return gsl_rng_uni32; else if (str_tail_grep(name, "slatec") == 0) return gsl_rng_slatec; else if (str_tail_grep(name, "zuf") == 0) return gsl_rng_zuf; #ifdef HAVE_RNGEXTRA_RNGEXTRA_H else if (str_tail_grep(name, "rngextra_rng1") == 0) return rngextra_rng1; else if (str_tail_grep(name, "rngextra_rng2") == 0) return rngextra_rng2; else if (str_tail_grep(name, "rngextra-rng1") == 0) return rngextra_rng1; else if (str_tail_grep(name, "rngextra-rng2") == 0) return rngextra_rng2; #else else if (str_tail_grep(name, "rngextra_rng1")*str_tail_grep(name, "rngextra_rng2") == 0) rb_raise(rb_eNotImpError, "Install the rngextra package found at ."); else if (str_tail_grep(name, "rngextra_rng2")*str_tail_grep(name, "rngextra_rng2") == 0) rb_raise(rb_eNotImpError, "Install the rngextra package found at ."); else if (str_tail_grep(name, "rngextra-rng1")*str_tail_grep(name, "rngextra_rng2") == 0) rb_raise(rb_eNotImpError, "Install the rngextra package found at ."); else if (str_tail_grep(name, "rngextra-rng2")*str_tail_grep(name, "rngextra_rng2") == 0) rb_raise(rb_eNotImpError, "Install the rngextra package found at ."); #endif #ifdef GSL_1_9_LATER else if (str_tail_grep(name, "knuthran2002") == 0) return gsl_rng_knuthran2002; #endif else rb_raise(rb_eArgError, "unknown generator type \"%s\"", name); } static const gsl_rng_type* get_gsl_rng_type_int(int itype) { const gsl_rng_type *T; switch (itype) { case GSL_RNG_DEFAULT: T = gsl_rng_default; break; case GSL_RNG_MT19937: T = gsl_rng_mt19937; break; /* default */ #ifdef GSL_1_2_LATER case GSL_RNG_MT19937_1999: T = gsl_rng_mt19937_1999; break; case GSL_RNG_MT19937_1998: T = gsl_rng_mt19937_1998; break; case GSL_RNG_TAUS113: T = gsl_rng_taus113; break; case GSL_RNG_TAUS2: T = gsl_rng_taus2; break; #endif case GSL_RNG_RANLXS0: T = gsl_rng_ranlxs0; break; case GSL_RNG_RANLXS1: T = gsl_rng_ranlxs1; break; case GSL_RNG_RANLXS2: T = gsl_rng_ranlxs2; break; case GSL_RNG_RANLXD1: T = gsl_rng_ranlxd1; break; case GSL_RNG_RANLXD2: T = gsl_rng_ranlxd2; break; case GSL_RNG_RANLUX: T = gsl_rng_ranlux; break; case GSL_RNG_RANLUX389: T = gsl_rng_ranlux389; break; case GSL_RNG_CMRG: T = gsl_rng_cmrg; break; case GSL_RNG_MRG: T = gsl_rng_mrg; break; case GSL_RNG_TAUS: T = gsl_rng_taus; break; case GSL_RNG_GFSR4: T = gsl_rng_gfsr4; break; case GSL_RNG_RAND: T = gsl_rng_rand; break; case GSL_RNG_RANDOM_LIBC5: T = gsl_rng_random_libc5; break; case GSL_RNG_RANDOM8_LIBC5: T = gsl_rng_random8_libc5; break; case GSL_RNG_RANDOM32_LIBC5: T = gsl_rng_random32_libc5; break; case GSL_RNG_RANDOM64_LIBC5: T = gsl_rng_random64_libc5; break; case GSL_RNG_RANDOM128_LIBC5: T = gsl_rng_random128_libc5; break; case GSL_RNG_RANDOM256_LIBC5: T = gsl_rng_random256_libc5; break; case GSL_RNG_RANDOM_GLIBC2: T = gsl_rng_random_glibc2; break; case GSL_RNG_RANDOM8_GLIBC2: T = gsl_rng_random8_glibc2; break; case GSL_RNG_RANDOM32_GLIBC2: T = gsl_rng_random32_glibc2; break; case GSL_RNG_RANDOM64_GLIBC2: T = gsl_rng_random64_glibc2; break; case GSL_RNG_RANDOM128_GLIBC2: T = gsl_rng_random128_glibc2; break; case GSL_RNG_RANDOM256_GLIBC2: T = gsl_rng_random256_glibc2; break; case GSL_RNG_RANDOM_BSD: T = gsl_rng_random_bsd; break; case GSL_RNG_RANDOM8_BSD: T = gsl_rng_random8_bsd; break; case GSL_RNG_RANDOM32_BSD: T = gsl_rng_random32_bsd; break; case GSL_RNG_RANDOM64_BSD: T = gsl_rng_random64_bsd; break; case GSL_RNG_RANDOM128_BSD: T = gsl_rng_random128_bsd; break; case GSL_RNG_RANDOM256_BSD: T = gsl_rng_random256_bsd; break; case GSL_RNG_RAND48: T = gsl_rng_rand48; break; case GSL_RNG_RAN0: T = gsl_rng_ran0; break; case GSL_RNG_RAN1: T = gsl_rng_ran1; break; case GSL_RNG_RAN2: T = gsl_rng_ran2; break; case GSL_RNG_RAN3: T = gsl_rng_ran3; break; case GSL_RNG_RANF: T = gsl_rng_ranf; break; case GSL_RNG_RANMAR: T = gsl_rng_ranmar; break; case GSL_RNG_R250: T = gsl_rng_r250; break; case GSL_RNG_TT800: T = gsl_rng_tt800; break; case GSL_RNG_VAX: T = gsl_rng_vax; break; case GSL_RNG_TRANSPUTER: T = gsl_rng_transputer; break; case GSL_RNG_RANDU: T = gsl_rng_randu; break; case GSL_RNG_MINSTD: T = gsl_rng_minstd; break; case GSL_RNG_UNI: T = gsl_rng_uni; break; case GSL_RNG_UNI32: T = gsl_rng_uni32; break; case GSL_RNG_SLATEC: T = gsl_rng_slatec; break; case GSL_RNG_ZUF: T = gsl_rng_zuf; break; #ifdef GSL_1_1_LATER case GSL_RNG_BOROSH13: T = gsl_rng_borosh13; break; case GSL_RNG_COVEYOU: T = gsl_rng_coveyou; break; case GSL_RNG_FISHMAN18: T = gsl_rng_fishman18; break; case GSL_RNG_FISHMAN20: T = gsl_rng_fishman20; break; case GSL_RNG_FISHMAN2X: T = gsl_rng_fishman2x; break; case GSL_RNG_KNUTHRAN: T = gsl_rng_knuthran; break; case GSL_RNG_KNUTHRAN2: T = gsl_rng_knuthran2; break; case GSL_RNG_LECUYER21: T = gsl_rng_lecuyer21; break; case GSL_RNG_WATERMAN14: T = gsl_rng_waterman14; break; #endif #ifdef HAVE_RNGEXTRA_RNGEXTRA_H case GSL_RNGEXTRA_RNG1: T = rngextra_rng1; break; case GSL_RNGEXTRA_RNG2: T = rngextra_rng2; break; #else case GSL_RNGEXTRA_RNG1: case GSL_RNGEXTRA_RNG2: rb_raise(rb_eNotImpError, "Install the rngextra package found at ."); break; #endif #ifdef GSL_1_9_LATER case GSL_RNG_KNUTHRAN2002: T = gsl_rng_knuthran2002; break; #endif default: rb_raise(rb_eTypeError, "wrong generator type"); } return T; } static void rb_gsl_rng_define_const_type(VALUE module) { rb_define_const(cgsl_rng, "DEFAULT", INT2FIX(GSL_RNG_DEFAULT)); rb_define_const(cgsl_rng, "MT19937", INT2FIX(GSL_RNG_MT19937)); rb_define_const(cgsl_rng, "MT19937_1999", INT2FIX(GSL_RNG_MT19937_1999)); rb_define_const(cgsl_rng, "MT19937_1998", INT2FIX(GSL_RNG_MT19937_1999)); rb_define_const(cgsl_rng, "RANLXS0", INT2FIX(GSL_RNG_RANLXS0)); rb_define_const(cgsl_rng, "RANLXS1", INT2FIX(GSL_RNG_RANLXS1)); rb_define_const(cgsl_rng, "RANLXS2", INT2FIX(GSL_RNG_RANLXS2)); rb_define_const(cgsl_rng, "RANLXD1", INT2FIX(GSL_RNG_RANLXD1)); rb_define_const(cgsl_rng, "RANLXD2", INT2FIX(GSL_RNG_RANLXD2)); rb_define_const(cgsl_rng, "RANLUX", INT2FIX(GSL_RNG_RANLUX)); rb_define_const(cgsl_rng, "RANLUX389", INT2FIX(GSL_RNG_RANLUX389)); rb_define_const(cgsl_rng, "CMRG", INT2FIX(GSL_RNG_CMRG)); rb_define_const(cgsl_rng, "MRG", INT2FIX(GSL_RNG_MRG)); rb_define_const(cgsl_rng, "TAUS", INT2FIX(GSL_RNG_TAUS)); rb_define_const(cgsl_rng, "TAUS2", INT2FIX(GSL_RNG_TAUS2)); rb_define_const(cgsl_rng, "TAUS113", INT2FIX(GSL_RNG_TAUS113)); rb_define_const(cgsl_rng, "GFSR4", INT2FIX(GSL_RNG_GFSR4)); rb_define_const(cgsl_rng, "RAND", INT2FIX(GSL_RNG_RAND)); rb_define_const(cgsl_rng, "RANDOM_LIBC5", INT2FIX(GSL_RNG_RANDOM_LIBC5)); rb_define_const(cgsl_rng, "RANDOM8_LIBC5", INT2FIX(GSL_RNG_RANDOM8_LIBC5)); rb_define_const(cgsl_rng, "RANDOM32_LIBC5", INT2FIX(GSL_RNG_RANDOM32_LIBC5)); rb_define_const(cgsl_rng, "RANDOM64_LIBC5", INT2FIX(GSL_RNG_RANDOM64_LIBC5)); rb_define_const(cgsl_rng, "RANDOM128_LIBC5", INT2FIX(GSL_RNG_RANDOM128_LIBC5)); rb_define_const(cgsl_rng, "RANDOM256_LIBC5", INT2FIX(GSL_RNG_RANDOM256_LIBC5)); rb_define_const(cgsl_rng, "RANDOM_GLIBC2", INT2FIX(GSL_RNG_RANDOM_GLIBC2)); rb_define_const(cgsl_rng, "RANDOM8_GLIBC2", INT2FIX(GSL_RNG_RANDOM8_GLIBC2)); rb_define_const(cgsl_rng, "RANDOM32_GLIBC2", INT2FIX(GSL_RNG_RANDOM32_GLIBC2)); rb_define_const(cgsl_rng, "RANDOM64_GLIBC2", INT2FIX(GSL_RNG_RANDOM64_GLIBC2)); rb_define_const(cgsl_rng, "RANDOM128_GLIBC2", INT2FIX(GSL_RNG_RANDOM128_GLIBC2)); rb_define_const(cgsl_rng, "RANDOM256_GLIBC2", INT2FIX(GSL_RNG_RANDOM256_GLIBC2)); rb_define_const(cgsl_rng, "RANDOM_BSD", INT2FIX(GSL_RNG_RANDOM_BSD)); rb_define_const(cgsl_rng, "RANDOM8_BSD", INT2FIX(GSL_RNG_RANDOM8_BSD)); rb_define_const(cgsl_rng, "RANDOM32_BSD", INT2FIX(GSL_RNG_RANDOM32_BSD)); rb_define_const(cgsl_rng, "RANDOM64_BSD", INT2FIX(GSL_RNG_RANDOM64_BSD)); rb_define_const(cgsl_rng, "RANDOM128_BSD", INT2FIX(GSL_RNG_RANDOM128_BSD)); rb_define_const(cgsl_rng, "RANDOM256_BSD", INT2FIX(GSL_RNG_RANDOM256_BSD)); rb_define_const(cgsl_rng, "RAND48", INT2FIX(GSL_RNG_RAND48)); rb_define_const(cgsl_rng, "RAN0", INT2FIX(GSL_RNG_RAN0)); rb_define_const(cgsl_rng, "RAN1", INT2FIX(GSL_RNG_RAN1)); rb_define_const(cgsl_rng, "RAN2", INT2FIX(GSL_RNG_RAN2)); rb_define_const(cgsl_rng, "RAN3", INT2FIX(GSL_RNG_RAN3)); rb_define_const(cgsl_rng, "RANF", INT2FIX(GSL_RNG_RANF)); rb_define_const(cgsl_rng, "RANMAR", INT2FIX(GSL_RNG_RANMAR)); rb_define_const(cgsl_rng, "R250", INT2FIX(GSL_RNG_R250)); rb_define_const(cgsl_rng, "TT800", INT2FIX(GSL_RNG_TT800)); rb_define_const(cgsl_rng, "VAX", INT2FIX(GSL_RNG_VAX)); rb_define_const(cgsl_rng, "TRANSPUTER", INT2FIX(GSL_RNG_TRANSPUTER)); rb_define_const(cgsl_rng, "RANDU", INT2FIX(GSL_RNG_RANDU)); rb_define_const(cgsl_rng, "MINSTD", INT2FIX(GSL_RNG_MINSTD)); rb_define_const(cgsl_rng, "UNI", INT2FIX(GSL_RNG_UNI)); rb_define_const(cgsl_rng, "UNI32", INT2FIX(GSL_RNG_UNI32)); rb_define_const(cgsl_rng, "SLATEC", INT2FIX(GSL_RNG_SLATEC)); rb_define_const(cgsl_rng, "ZUF", INT2FIX(GSL_RNG_ZUF)); /* from gsl-1.1 */ rb_define_const(cgsl_rng, "BOROSH13", INT2FIX(GSL_RNG_BOROSH13)); rb_define_const(cgsl_rng, "COVEYOU", INT2FIX(GSL_RNG_COVEYOU)); rb_define_const(cgsl_rng, "FISHMAN18", INT2FIX(GSL_RNG_FISHMAN18)); rb_define_const(cgsl_rng, "FISHMAN20", INT2FIX(GSL_RNG_FISHMAN20)); rb_define_const(cgsl_rng, "FISHMAN2X", INT2FIX(GSL_RNG_FISHMAN2X)); rb_define_const(cgsl_rng, "KNUTHRAN", INT2FIX(GSL_RNG_KNUTHRAN)); rb_define_const(cgsl_rng, "KNUTHRAN2", INT2FIX(GSL_RNG_KNUTHRAN2)); rb_define_const(cgsl_rng, "LECUYER21", INT2FIX(GSL_RNG_LECUYER21)); rb_define_const(cgsl_rng, "WATERMAN14", INT2FIX(GSL_RNG_WATERMAN14)); rb_define_const(cgsl_rng, "RNGEXTRA_RNG1", INT2FIX(GSL_RNGEXTRA_RNG1)); rb_define_const(cgsl_rng, "RNGEXTRA_RNG2", INT2FIX(GSL_RNGEXTRA_RNG2)); rb_define_const(module, "RNGEXTRA_RNG1", INT2FIX(GSL_RNGEXTRA_RNG1)); rb_define_const(module, "RNGEXTRA_RNG2", INT2FIX(GSL_RNGEXTRA_RNG2)); } /* singleton */ static VALUE rb_gsl_rng_default_seed(VALUE obj) { return UINT2NUM(gsl_rng_default_seed); } /* singleton */ static VALUE rb_gsl_rng_set_default_seed(VALUE obj, VALUE seed) { gsl_rng_default_seed = NUM2UINT(seed); return seed; } static VALUE rb_gsl_rng_set(VALUE obj, VALUE s) { gsl_rng *r = NULL; unsigned long seed; seed = NUM2UINT(s); Data_Get_Struct(obj, gsl_rng, r); gsl_rng_set(r, seed); return obj; } /* Document-method: GSL::Rng#get Returns a random integer from the generator. The minimum and maximum values depend on the algorithm used, but all integers in the range [min,max] are equally likely. The values of min and max can determined using the auxiliary methodss GSL::Rng#max and GSL::Rng#min. */ static VALUE rb_gsl_rng_get(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector_int *v; size_t n, i; Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 0: return UINT2NUM(gsl_rng_get(r)); break; case 1: n = NUM2INT(argv[0]); v = gsl_vector_int_alloc(n); for (i = 0; i < n; i++) gsl_vector_int_set(v, i, (int) gsl_rng_get(r)); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } } static VALUE rb_gsl_rng_uniform(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v; size_t n, i; Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 0: return rb_float_new(gsl_rng_uniform(r)); break; case 1: n = NUM2INT(argv[0]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, gsl_rng_uniform(r)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } } static VALUE rb_gsl_rng_uniform_pos(VALUE obj) { gsl_rng *r = NULL; Data_Get_Struct(obj, gsl_rng, r); return rb_float_new(gsl_rng_uniform_pos(r)); } static VALUE rb_gsl_rng_uniform_int(VALUE obj, VALUE n) { gsl_rng *r = NULL; unsigned long int nn; nn = NUM2UINT(n); Data_Get_Struct(obj, gsl_rng, r); return UINT2NUM(gsl_rng_uniform_int(r, nn)); } static VALUE rb_gsl_rng_name(VALUE obj) { gsl_rng *r = NULL; Data_Get_Struct(obj, gsl_rng, r); return rb_str_new2(gsl_rng_name(r)); } static VALUE rb_gsl_rng_max(VALUE obj, VALUE s) { gsl_rng *r = NULL; Data_Get_Struct(obj, gsl_rng, r); return UINT2NUM(gsl_rng_max(r)); } static VALUE rb_gsl_rng_min(VALUE obj, VALUE s) { gsl_rng *r = NULL; Data_Get_Struct(obj, gsl_rng, r); return UINT2NUM(gsl_rng_min(r)); } static VALUE rb_gsl_rng_size(VALUE obj, VALUE s) { gsl_rng *r = NULL; Data_Get_Struct(obj, gsl_rng, r); return UINT2NUM(gsl_rng_size(r)); } /* get a list of the available generator types */ /* module function */ static VALUE rb_gsl_rng_types_setup(VALUE obj) { const gsl_rng_type **t, **t0; VALUE ary; t0 = gsl_rng_types_setup(); ary = rb_ary_new(); for (t = t0; *t != 0; t++) rb_ary_push(ary, rb_str_new2((*t)->name)); return ary; } /* module function */ static VALUE rb_gsl_rng_env_setup(VALUE obj) { gsl_rng_env_setup(); return obj; } static VALUE rb_gsl_rng_clone(VALUE obj) { gsl_rng *r = NULL, *rnew = NULL; Data_Get_Struct(obj, gsl_rng, r); rnew = gsl_rng_clone(r); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_rng_free, rnew); } static VALUE rb_gsl_rng_print_state(VALUE obj) { gsl_rng *r = NULL; Data_Get_Struct(obj, gsl_rng, r); gsl_rng_print_state(r); return obj; } #ifdef GSL_1_4_LATER static VALUE rb_gsl_rng_fwrite(VALUE obj, VALUE io) { gsl_rng *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_rng, h); f = rb_gsl_open_writefile(io, &flag); status = gsl_rng_fwrite(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_rng_fread(VALUE obj, VALUE io) { gsl_rng *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_rng, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_rng_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } #endif static VALUE rb_gsl_rng_memcpy(VALUE obj, VALUE dst, VALUE org) { gsl_rng *dest, *src; CHECK_RNG(dst); CHECK_RNG(org); Data_Get_Struct(dst, gsl_rng, dest); Data_Get_Struct(org, gsl_rng, src); gsl_rng_memcpy(dest, src); return dst; } void Init_gsl_rng(VALUE module) { cgsl_rng = rb_define_class_under(module, "Rng", cGSL_Object); rb_gsl_rng_define_const_type(module); rb_define_singleton_method(cgsl_rng, "alloc", rb_gsl_rng_alloc, -1); rb_define_singleton_method(cgsl_rng, "default_seed", rb_gsl_rng_default_seed, 0); rb_define_singleton_method(cgsl_rng, "set_default_seed", rb_gsl_rng_set_default_seed, 1); rb_define_singleton_method(cgsl_rng, "default_seed=", rb_gsl_rng_set_default_seed, 1); rb_define_method(cgsl_rng, "set", rb_gsl_rng_set, 1); rb_define_alias(cgsl_rng, "set_seed", "set"); rb_define_alias(cgsl_rng, "seed=", "set"); rb_define_method(cgsl_rng, "get", rb_gsl_rng_get, -1); rb_define_alias(cgsl_rng, "gen", "get"); rb_define_method(cgsl_rng, "uniform", rb_gsl_rng_uniform, -1); rb_define_method(cgsl_rng, "uniform_pos", rb_gsl_rng_uniform_pos, 0); rb_define_method(cgsl_rng, "uniform_int", rb_gsl_rng_uniform_int, 1); rb_define_method(cgsl_rng, "name", rb_gsl_rng_name, 0); rb_define_method(cgsl_rng, "max", rb_gsl_rng_max, 0); rb_define_method(cgsl_rng, "min", rb_gsl_rng_min, 0); rb_define_method(cgsl_rng, "size", rb_gsl_rng_size, 0); rb_define_singleton_method(cgsl_rng, "types_setup", rb_gsl_rng_types_setup, 0); rb_define_singleton_method(cgsl_rng, "types", rb_gsl_rng_types_setup, 0); rb_define_singleton_method(cgsl_rng, "env_setup", rb_gsl_rng_env_setup, 0); rb_define_method(cgsl_rng, "clone", rb_gsl_rng_clone, 0); rb_define_alias(cgsl_rng, "duplicate", "clone"); rb_define_method(cgsl_rng, "print_state", rb_gsl_rng_print_state, 0); #ifdef GSL_1_4_LATER rb_define_method(cgsl_rng, "fwrite", rb_gsl_rng_fwrite, 1); rb_define_method(cgsl_rng, "fread", rb_gsl_rng_fread, 1); #endif rb_define_singleton_method(cgsl_rng, "memcpy", rb_gsl_rng_memcpy, 2); } gsl-1.15.3/ext/nmf_wrap.c0000644000175000017500000000356612220252463014531 0ustar boutilboutil/** * NMF: Non-Negative Matrix Factorization - Ruby wrapper * * Written by Roman Shterenzon * */ #include #include int gsl_matrix_nmf(gsl_matrix *v, int cols, gsl_matrix **w, gsl_matrix **h); //double difcost(gsl_matrix *a, gsl_matrix *b); double difcost(const gsl_matrix *a, const gsl_matrix *b); //VALUE mNMF; static VALUE mNMF; extern VALUE cgsl_matrix; /* * call-seq: * nmf(GSL::Matrix, columns) -> [GSL::Matrix, GSL::Matrix] * * Calculates the NMF of the given +matrix+, returns the W and H matrices */ static VALUE nmf_wrap(VALUE obj, VALUE matrix, VALUE cols) { gsl_matrix *w, *h, *m; unsigned int c; VALUE arr; if ( ! FIXNUM_P(cols) || (c=NUM2INT(cols)) <= 0 ) { rb_raise(rb_eArgError, "Number of columns should be a positive integer."); } arr = rb_ary_new2(2); Data_Get_Struct(matrix, gsl_matrix, m); /* compute the NMF */ gsl_matrix_nmf(m, c, &w, &h); rb_ary_push(arr, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, w)); rb_ary_push(arr, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, h)); return arr; } /* * call-seq: * difcost(GSL::Matrix, GSL::Matrix) -> Float * * Calculates the geometric distance between two matrices */ static VALUE difcost_wrap(VALUE obj, VALUE matrix1, VALUE matrix2) { gsl_matrix *m1, *m2; Data_Get_Struct(matrix1, gsl_matrix, m1); Data_Get_Struct(matrix2, gsl_matrix, m2); return rb_float_new(difcost(m1, m2)); } /* call-seq: * nmf(cols) -> [GSL::Matrix, GSL::Matrix] */ static VALUE matrix_nmf(VALUE obj, VALUE cols) { // nmf_wrap(cgsl_matrix, obj, cols); return nmf_wrap(cgsl_matrix, obj, cols); } void Init_gsl_matrix_nmf(void) { mNMF = rb_define_module_under(cgsl_matrix, "NMF"); rb_define_singleton_method(mNMF, "nmf", nmf_wrap, 2); rb_define_singleton_method(mNMF, "difcost", difcost_wrap, 2); rb_define_method(cgsl_matrix, "nmf", matrix_nmf, 1); } gsl-1.15.3/ext/diff.c0000644000175000017500000001165412220252463013625 0ustar boutilboutil/* diff.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_common.h" #include "rb_gsl_function.h" #include #include static int get_func(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx); static int get_func(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx) { switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_FUNCTION(argv[0]); *ff = argv[0]; *xx = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); *ff = obj; *xx = argv[0]; break; } return 0; } static VALUE rb_gsl_diff_eval(VALUE obj, VALUE xx, int (*diff)(const gsl_function *, double, double *, double *)) { gsl_function *f = NULL; double result, abserr; VALUE x, ary, aerr; gsl_vector *v = NULL, *vnew = NULL, *verr = NULL; gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL; size_t n, i, j; int status; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2, *ptr3; struct NARRAY *na; VALUE ary2, ary3; #endif Data_Get_Struct(obj, gsl_function, f); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: status = (*diff)(f, NUM2DBL(xx), &result, &abserr); return rb_ary_new3(3, rb_float_new(result), rb_float_new(abserr), INT2FIX(status)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); aerr = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); (*diff)(f, NUM2DBL(x), &result, &abserr); rb_ary_store(ary, i, rb_float_new(result)); rb_ary_store(aerr, i, rb_float_new(abserr)); } return rb_ary_new3(2, ary, aerr); break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); n = na->total; ptr1 = (double*) na->ptr; ary2 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ary3 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary2, double*); ptr3 = NA_PTR_TYPE(ary3, double*); for (i = 0; i < n; i++) { (*diff)(f, ptr1[i], &result, &abserr); ptr2[i] = result; ptr3[i] = abserr; } return rb_ary_new3(2, ary2, ary3); } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); verr = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { (*diff)(f, gsl_vector_get(v, i), &result, &abserr); gsl_vector_set(vnew, i, result); gsl_vector_set(verr, i, abserr); } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr)); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); merr = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { (*diff)(f, gsl_matrix_get(m, i, j), &result, &abserr); gsl_matrix_set(mnew, i, j, result); gsl_matrix_set(merr, i, j, abserr); } } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew), Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr)); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_diff_central(int argc, VALUE *argv, VALUE obj) { VALUE ff, xx; get_func(argc, argv, obj, &ff, &xx); return rb_gsl_diff_eval(ff, xx, gsl_diff_central); } static VALUE rb_gsl_diff_forward(int argc, VALUE *argv, VALUE obj) { VALUE ff, xx; get_func(argc, argv, obj, &ff, &xx); return rb_gsl_diff_eval(ff, xx, gsl_diff_forward); } static VALUE rb_gsl_diff_backward(int argc, VALUE *argv, VALUE obj) { VALUE ff, xx; get_func(argc, argv, obj, &ff, &xx); return rb_gsl_diff_eval(ff, xx, gsl_diff_backward); } void Init_gsl_diff(VALUE module) { VALUE mgsl_diff; mgsl_diff = rb_define_module_under(module, "Diff"); rb_define_method(cgsl_function, "diff_central", rb_gsl_diff_central, -1); rb_define_method(cgsl_function, "diff_forward", rb_gsl_diff_forward, -1); rb_define_method(cgsl_function, "diff_backward", rb_gsl_diff_backward, -1); rb_define_singleton_method(mgsl_diff, "central", rb_gsl_diff_central, -1); rb_define_singleton_method(mgsl_diff, "forward", rb_gsl_diff_forward, -1); rb_define_singleton_method(mgsl_diff, "backward", rb_gsl_diff_backward, -1); } gsl-1.15.3/ext/multimin.c0000644000175000017500000006207112220252463014552 0ustar boutilboutil/* multimin.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #include #ifndef CHECK_MULTIMIN_FUNCTION #define CHECK_MULTIMIN_FUNCTION(x) if(CLASS_OF(x)!=cgsl_multimin_function)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::MultiMin::Function expected)",\ rb_class2name(CLASS_OF(x))); #endif #ifndef CHECK_MULTIMIN_FUNCTION_FDF #define CHECK_MULTIMIN_FUNCTION_FDF(x) if(CLASS_OF(x)!=cgsl_multimin_function_fdf)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::MultiMin::Function_fdf expected)",\ rb_class2name(CLASS_OF(x))); #endif VALUE cgsl_multimin_function_fdf; /* Used also in multimin_fsdf.c */ static VALUE cgsl_multimin_function; enum { GSL_FDFMINIMIZER_CONJUGATE_FR, GSL_FDFMINIMIZER_CONJUGATE_PR, GSL_FDFMINIMIZER_VECTOR_BFGS, GSL_FDFMINIMIZER_STEEPEST_DESCENT, GSL_FMINIMIZER_NMSIMPLEX, #ifdef GSL_1_9_LATER GSL_FDFMINIMIZER_VECTOR_BFGS2, #endif #ifdef GSL_1_13_LATER GSL_FMINIMIZER_NMSIMPLEX2RAND, #endif }; static const gsl_multimin_fdfminimizer_type* get_fdfminimizer_type(VALUE t); #ifdef GSL_1_3_LATER static const gsl_multimin_fminimizer_type* get_fminimizer_type(VALUE t); #endif static void define_const(); static void gsl_multimin_function_free(gsl_multimin_function *f); static double rb_gsl_multimin_function_f(const gsl_vector *x, void *p); static void set_function(int i, VALUE *argv, gsl_multimin_function *F); static void gsl_multimin_function_fdf_free(gsl_multimin_function_fdf *f); double rb_gsl_multimin_function_fdf_f(const gsl_vector *x, void *p); void rb_gsl_multimin_function_fdf_df(const gsl_vector *x, void *p, gsl_vector *g); void rb_gsl_multimin_function_fdf_fdf(const gsl_vector *x, void *p, double *f, gsl_vector *g); static void set_function_fdf(int i, VALUE *argv, gsl_multimin_function_fdf *F); /*** multimin_funcion ***/ static void gsl_multimin_function_mark(gsl_multimin_function *F); static void gsl_multimin_function_fdf_mark(gsl_multimin_function_fdf *F); static void gsl_multimin_function_mark(gsl_multimin_function *F) { rb_gc_mark((VALUE) F->params); } static void gsl_multimin_function_fdf_mark(gsl_multimin_function_fdf *F) { rb_gc_mark((VALUE) F->params); } static VALUE rb_gsl_multimin_function_new(int argc, VALUE *argv, VALUE klass) { gsl_multimin_function *F = NULL; VALUE ary; size_t i; F = ALLOC(gsl_multimin_function); F->f = &rb_gsl_multimin_function_f; ary = rb_ary_new2(2); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); else rb_ary_store(ary, 0, Qnil); rb_ary_store(ary, 1, Qnil); switch (argc) { case 0: break; case 1: set_function(0, argv, F); break; case 2: case 3: for (i = 0; i < argc; i++) set_function(i, argv, F); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); } return Data_Wrap_Struct(klass, gsl_multimin_function_mark, gsl_multimin_function_free, F); } static void gsl_multimin_function_free(gsl_multimin_function *f) { free((gsl_multimin_function *) f); } static VALUE rb_gsl_multimin_function_n(VALUE obj) { gsl_multimin_function *F = NULL; Data_Get_Struct(obj, gsl_multimin_function, F); return INT2FIX(F->n); } static double rb_gsl_multimin_function_f(const gsl_vector *x, void *p) { VALUE vx, vp, proc, result; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); proc = rb_ary_entry((VALUE) p, 0); vp = rb_ary_entry((VALUE) p, 1); if (NIL_P(vp)) result = rb_funcall(proc, RBGSL_ID_call, 1, vx); else result = rb_funcall(proc, RBGSL_ID_call, 2, vx, vp); return NUM2DBL(result); } static VALUE rb_gsl_multimin_function_eval(VALUE obj, VALUE vx) { gsl_multimin_function *F = NULL; VALUE vp, proc, ary, result; Data_Get_Struct(obj, gsl_multimin_function, F); ary = (VALUE) F->params; proc = rb_ary_entry(ary, 0); vp = rb_ary_entry(ary, 1); if (NIL_P(vp)) result = rb_funcall(proc, RBGSL_ID_call, 1, vx); else result = rb_funcall(proc, RBGSL_ID_call, 2, vx, vp); return result; } static void set_function(int i, VALUE *argv, gsl_multimin_function *F) { VALUE ary; ary = (VALUE) F->params; if (TYPE(argv[i]) == T_FIXNUM) F->n = FIX2INT(argv[i]); else if (rb_obj_is_kind_of(argv[i], rb_cProc)) rb_ary_store(ary, 0, argv[i]); else if (TYPE(argv[i]) == T_ARRAY || rb_obj_is_kind_of(argv[i], cgsl_vector) || TYPE(argv[i]) == T_FIXNUM || TYPE(argv[i]) == T_FLOAT) { rb_ary_store(ary, 1, argv[i]); } else { rb_raise(rb_eTypeError, "wrong type of argument %d (Fixnum or Proc)", i); } } static VALUE rb_gsl_multimin_function_set_f(int argc, VALUE *argv, VALUE obj) { gsl_multimin_function *F = NULL; VALUE ary; size_t i; Data_Get_Struct(obj, gsl_multimin_function, F); ary = (VALUE) F->params; if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); switch (argc) { case 1: set_function(0, argv, F); break; case 2: case 3: for (i = 0; i < argc; i++) set_function(i, argv, F); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); } return obj; } static VALUE rb_gsl_multimin_function_set_params(int argc, VALUE *argv, VALUE obj) { gsl_multimin_function *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_multimin_function, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } if (argc == 1) rb_ary_store(ary, 1, argv[0]); else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 1, ary2); } return obj; } static VALUE rb_gsl_multimin_function_params(VALUE obj) { gsl_multimin_function *F = NULL; Data_Get_Struct(obj, gsl_multimin_function, F); return rb_ary_entry((VALUE) F->params, 1); } /*** multimin_function_fdf ***/ static void set_function_fdf(int argc, VALUE *argv, gsl_multimin_function_fdf *F); static VALUE rb_gsl_multimin_function_fdf_new(int argc, VALUE *argv, VALUE klass) { gsl_multimin_function_fdf *F = NULL; VALUE ary; F = ALLOC(gsl_multimin_function_fdf); F->f = &rb_gsl_multimin_function_fdf_f; F->df = &rb_gsl_multimin_function_fdf_df; F->fdf = &rb_gsl_multimin_function_fdf_fdf; ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; rb_ary_store(ary, 2, Qnil); rb_ary_store(ary, 3, Qnil); set_function_fdf(argc, argv, F); return Data_Wrap_Struct(klass, gsl_multimin_function_fdf_mark, gsl_multimin_function_fdf_free, F); } static void gsl_multimin_function_fdf_free(gsl_multimin_function_fdf *f) { free((gsl_multimin_function_fdf *) f); } static VALUE rb_gsl_multimin_function_fdf_n(VALUE obj) { gsl_multimin_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multimin_function_fdf, F); return INT2FIX(F->n); } static void set_function_fdf(int argc, VALUE *argv, gsl_multimin_function_fdf *F) { VALUE ary; if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } switch (argc) { case 1: if (TYPE(argv[0]) != T_FIXNUM) rb_raise(rb_eTypeError, "Fixnum expected"); F->n = FIX2INT(argv[0]); break; case 2: rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); rb_ary_store(ary, 2, Qnil); break; case 3: rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); if (TYPE(argv[2]) == T_FIXNUM) { F->n = FIX2INT(argv[2]); rb_ary_store(ary, 2, Qnil); } else { rb_ary_store(ary, 2, argv[2]); } break; case 4: case 5: if (TYPE(argv[0]) == T_FIXNUM) { F->n = FIX2INT(argv[0]); rb_ary_store(ary, 0, argv[1]); rb_ary_store(ary, 1, argv[2]); rb_ary_store(ary, 2, argv[3]); } else { rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); rb_ary_store(ary, 2, argv[2]); F->n = FIX2INT(argv[3]); } if (argc == 5) rb_ary_store(ary, 3, argv[4]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (1, 3, or 4)"); } } static VALUE rb_gsl_multimin_function_fdf_set_procs(int argc, VALUE *argv, VALUE obj) { VALUE ary; gsl_multimin_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multimin_function_fdf, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } switch (argc) { case 2: rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); rb_ary_store(ary, 2, Qnil); break; case 3: rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); if (TYPE(argv[2]) == T_FIXNUM) { F->n = FIX2INT(argv[2]); rb_ary_store(ary, 2, Qnil); } else { rb_ary_store(ary, 2, argv[2]); } break; case 4: case 5: if (TYPE(argv[0]) == T_FIXNUM) { F->n = FIX2INT(argv[0]); rb_ary_store(ary, 0, argv[1]); rb_ary_store(ary, 1, argv[2]); rb_ary_store(ary, 2, argv[3]); } else { rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); rb_ary_store(ary, 2, argv[2]); F->n = FIX2INT(argv[3]); } if (argc == 5) rb_ary_store(ary, 3, argv[4]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (2, 3, or 4)"); } return obj; } static VALUE rb_gsl_multimin_function_fdf_set_params(int argc, VALUE *argv, VALUE obj) { gsl_multimin_function_fdf *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_multimin_function_fdf, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } if (argc == 1) { rb_ary_store(ary, 3, argv[0]); } else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 3, ary2); } return obj; } static VALUE rb_gsl_multimin_function_fdf_set(int argc, VALUE *argv, VALUE obj) { gsl_multimin_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multimin_function_fdf, F); set_function_fdf(argc, argv, F); return obj; } double rb_gsl_multimin_function_fdf_f(const gsl_vector *x, void *p) { VALUE vx, proc, vp, result, ary; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); ary = (VALUE) p; proc = rb_ary_entry(ary, 0); vp = rb_ary_entry(ary, RARRAY_LEN(ary)-1); if (NIL_P(vp)) result = rb_funcall(proc, RBGSL_ID_call, 1, vx); else result = rb_funcall(proc, RBGSL_ID_call, 2, vx, vp); return NUM2DBL(result); } void rb_gsl_multimin_function_fdf_df(const gsl_vector *x, void *p, gsl_vector *g) { VALUE vx, vg, proc, vp, ary; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vg = Data_Wrap_Struct(cgsl_vector, 0, NULL, g); ary = (VALUE) p; proc = rb_ary_entry(ary, 1); vp = rb_ary_entry(ary, RARRAY_LEN(ary)-1); if (NIL_P(vp)) { rb_funcall(proc, RBGSL_ID_call, 2, vx, vg); } else { rb_funcall(proc, RBGSL_ID_call, 3, vx, vp, vg); } } void rb_gsl_multimin_function_fdf_fdf(const gsl_vector *x, void *p, double *f, gsl_vector *g) { VALUE vx, vg, proc_f, proc_df, vp, ary, result; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vg = Data_Wrap_Struct(cgsl_vector, 0, NULL, g); ary = (VALUE) p; proc_f = rb_ary_entry(ary, 0); proc_df = rb_ary_entry(ary, 1); vp = rb_ary_entry(ary, RARRAY_LEN(ary)-1); if (NIL_P(vp)) { result = rb_funcall(proc_f, RBGSL_ID_call, 1, vx); rb_funcall(proc_df, RBGSL_ID_call, 2, vx, vg); } else { result = rb_funcall(proc_f, RBGSL_ID_call, 2, vx, vp); rb_funcall(proc_df, RBGSL_ID_call, 3, vx, vp, vg); } *f = NUM2DBL(result); } static VALUE rb_gsl_multimin_function_fdf_params(VALUE obj) { gsl_multimin_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multimin_function_fdf, F); return rb_ary_entry((VALUE) F->params, 3); } /****************/ static void define_const(VALUE klass1, VALUE klass2) { rb_define_const(klass1, "CONJUGATE_FR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_FR)); rb_define_const(klass1, "CONJUGATE_PR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_PR)); rb_define_const(klass1, "VECTOR_BFGS", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS)); rb_define_const(klass1, "STEEPEST_DESCENT", INT2FIX(GSL_FDFMINIMIZER_STEEPEST_DESCENT)); #ifdef GSL_1_3_LATER rb_define_const(klass2, "NMSIMPLEX", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX)); #endif #ifdef GSL_1_9_LATER rb_define_const(klass1, "VECTOR_BFGS2", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS2)); #endif #ifdef GSL_1_13_LATER rb_define_const(klass2, "NMSIMPLEX2RAND", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX2RAND)); #endif } static const gsl_multimin_fdfminimizer_type* get_fdfminimizer_type(VALUE t) { char name[64]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (str_tail_grep(name, "conjugate_fr") == 0) return gsl_multimin_fdfminimizer_conjugate_fr; else if (str_tail_grep(name, "conjugate_pr") == 0) return gsl_multimin_fdfminimizer_conjugate_pr; else if (str_tail_grep(name, "vector_bfgs") == 0) return gsl_multimin_fdfminimizer_vector_bfgs; else if (str_tail_grep(name, "steepest_descent") == 0) return gsl_multimin_fdfminimizer_steepest_descent; #ifdef GSL_1_9_LATER else if (str_tail_grep(name, "vector_bfgs2") == 0) return gsl_multimin_fdfminimizer_vector_bfgs2; #endif else rb_raise(rb_eTypeError, "%s: unknown minimizer type", name); break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_FDFMINIMIZER_CONJUGATE_FR: return gsl_multimin_fdfminimizer_conjugate_fr; break; case GSL_FDFMINIMIZER_CONJUGATE_PR: return gsl_multimin_fdfminimizer_conjugate_pr; break; case GSL_FDFMINIMIZER_VECTOR_BFGS: return gsl_multimin_fdfminimizer_vector_bfgs; break; case GSL_FDFMINIMIZER_STEEPEST_DESCENT: return gsl_multimin_fdfminimizer_steepest_descent; break; #ifdef GSL_1_9_LATER case GSL_FDFMINIMIZER_VECTOR_BFGS2: return gsl_multimin_fdfminimizer_vector_bfgs2; break; #endif default: rb_raise(rb_eTypeError, "%d: unknown type", FIX2INT(t)); break; } break; default: rb_raise(rb_eTypeError, "type is given by a String or a Fixnum"); break; } } static VALUE rb_gsl_fdfminimizer_new(VALUE klass, VALUE t, VALUE n) { gsl_multimin_fdfminimizer *gmf = NULL; const gsl_multimin_fdfminimizer_type *T; T = get_fdfminimizer_type(t); gmf = gsl_multimin_fdfminimizer_alloc(T, FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_multimin_fdfminimizer_free, gmf); } static VALUE rb_gsl_fdfminimizer_set(VALUE obj, VALUE ff, VALUE xx, VALUE ss, VALUE tt) { gsl_multimin_fdfminimizer *gmf = NULL; gsl_multimin_function_fdf *F = NULL; gsl_vector *x; double stepsize, tol; int status; CHECK_MULTIMIN_FUNCTION_FDF(ff); Need_Float(ss); Need_Float(tt); Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); Data_Get_Struct(ff, gsl_multimin_function_fdf, F); Data_Get_Vector(xx, x); stepsize = NUM2DBL(ss); tol = NUM2DBL(tt); status = gsl_multimin_fdfminimizer_set(gmf, F, x, stepsize, tol); return INT2FIX(status); } static VALUE rb_gsl_fdfminimizer_name(VALUE obj) { gsl_multimin_fdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); return rb_str_new2(gsl_multimin_fdfminimizer_name(gmf)); } static VALUE rb_gsl_fdfminimizer_iterate(VALUE obj) { gsl_multimin_fdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); return INT2FIX(gsl_multimin_fdfminimizer_iterate(gmf)); } static VALUE rb_gsl_fdfminimizer_x(VALUE obj) { gsl_multimin_fdfminimizer *gmf = NULL; gsl_vector *x = NULL; Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); x = gsl_multimin_fdfminimizer_x(gmf); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, x); } static VALUE rb_gsl_fdfminimizer_gradient(VALUE obj) { gsl_multimin_fdfminimizer *gmf = NULL; gsl_vector *gradient = NULL; Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); gradient = gsl_multimin_fdfminimizer_gradient(gmf); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, gradient); } static VALUE rb_gsl_fdfminimizer_minimum(VALUE obj) { gsl_multimin_fdfminimizer *gmf = NULL; double min; Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); min = gsl_multimin_fdfminimizer_minimum(gmf); return rb_float_new(min); } static VALUE rb_gsl_fdfminimizer_f(VALUE obj) { gsl_multimin_fdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); return rb_float_new(gmf->f); } static VALUE rb_gsl_fdfminimizer_restart(VALUE obj) { gsl_multimin_fdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); return INT2FIX(gsl_multimin_fdfminimizer_restart(gmf)); } static VALUE rb_gsl_fdfminimizer_test_gradient(VALUE obj, VALUE ea) { gsl_multimin_fdfminimizer *gmf = NULL; gsl_vector *g = NULL; Need_Float(ea); Data_Get_Struct(obj, gsl_multimin_fdfminimizer, gmf); g = gsl_multimin_fdfminimizer_gradient(gmf); return INT2FIX(gsl_multimin_test_gradient(g, NUM2DBL(ea))); } static VALUE rb_gsl_multimin_test_gradient(VALUE obj, VALUE gg, VALUE ea) { gsl_vector *g = NULL; Need_Float(ea); Data_Get_Vector(gg, g); return INT2FIX(gsl_multimin_test_gradient(g, NUM2DBL(ea))); } /*****/ #ifdef GSL_1_3_LATER static const gsl_multimin_fminimizer_type* get_fminimizer_type(VALUE t) { char name[64]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (str_tail_grep(name, "nmsimplex") == 0) return gsl_multimin_fminimizer_nmsimplex; #ifdef GSL_1_13_LATER if (str_tail_grep(name, "nmsimplex2rand") == 0) return gsl_multimin_fminimizer_nmsimplex2rand; #endif else rb_raise(rb_eTypeError, "unknown type %s (nmsimplex and nmsimplex2rand supported)", name); break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_FMINIMIZER_NMSIMPLEX: return gsl_multimin_fminimizer_nmsimplex; break; #ifdef GSL_1_13_LATER case GSL_FMINIMIZER_NMSIMPLEX2RAND: return gsl_multimin_fminimizer_nmsimplex2rand; break; #endif default: rb_raise(rb_eTypeError, "%d: unknown type (not supported)", FIX2INT(t)); break; } break; default: rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)", rb_class2name(CLASS_OF(t))); break; } } static VALUE rb_gsl_fminimizer_new(VALUE klass, VALUE t, VALUE n) { gsl_multimin_fminimizer *gmf = NULL; const gsl_multimin_fminimizer_type *T; CHECK_FIXNUM(n); T = get_fminimizer_type(t); gmf = gsl_multimin_fminimizer_alloc(T, FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_multimin_fminimizer_free, gmf); } static VALUE rb_gsl_fminimizer_set(VALUE obj, VALUE ff, VALUE xx, VALUE ss) { gsl_multimin_fminimizer *gmf = NULL; gsl_multimin_function *F = NULL; gsl_vector *x = NULL, *s = NULL; CHECK_MULTIMIN_FUNCTION(ff); Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); Data_Get_Struct(ff, gsl_multimin_function, F); Data_Get_Vector(xx, x); Data_Get_Vector(ss, s); return INT2FIX(gsl_multimin_fminimizer_set(gmf, F, x, s)); } static VALUE rb_gsl_fminimizer_name(VALUE obj) { gsl_multimin_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); return rb_str_new2(gsl_multimin_fminimizer_name(gmf)); } static VALUE rb_gsl_fminimizer_iterate(VALUE obj) { gsl_multimin_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); return INT2FIX(gsl_multimin_fminimizer_iterate(gmf)); } static VALUE rb_gsl_fminimizer_x(VALUE obj) { gsl_multimin_fminimizer *gmf = NULL; gsl_vector *x = NULL; Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); x = gsl_multimin_fminimizer_x(gmf); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, x); } static VALUE rb_gsl_fminimizer_minimum(VALUE obj) { gsl_multimin_fminimizer *gmf = NULL; double min; Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); min = gsl_multimin_fminimizer_minimum(gmf); return rb_float_new(min); } static VALUE rb_gsl_fminimizer_size(VALUE obj) { gsl_multimin_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); return rb_float_new(gsl_multimin_fminimizer_size(gmf)); } static VALUE rb_gsl_fminimizer_fval(VALUE obj) { gsl_multimin_fminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); return rb_float_new(gmf->fval); } static VALUE rb_gsl_fminimizer_test_size(VALUE obj, VALUE ea) { gsl_multimin_fminimizer *gmf = NULL; Need_Float(ea); Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf); return INT2FIX(gsl_multimin_test_size(gmf->size, NUM2DBL(ea))); } static VALUE rb_gsl_multimin_test_size(VALUE obj, VALUE ss, VALUE ea) { Need_Float(ss); Need_Float(ea); return INT2FIX(gsl_multimin_test_size(NUM2DBL(ss), NUM2DBL(ea))); } #endif #ifdef HAVE_GSL_GSL_MULTIMIN_FSDF_H void Init_multimin_fsdf(VALUE module); #endif /*****/ void Init_gsl_multimin(VALUE module) { VALUE mgsl_multimin; VALUE cgsl_multimin_fdfminimizer; VALUE cgsl_multimin_fminimizer; mgsl_multimin = rb_define_module_under(module, "MultiMin"); rb_define_singleton_method(mgsl_multimin, "test_gradient", rb_gsl_multimin_test_gradient, 2); #ifdef GSL_1_3_LATER rb_define_singleton_method(mgsl_multimin, "test_size", rb_gsl_multimin_test_size, 2); #endif cgsl_multimin_fdfminimizer = rb_define_class_under(mgsl_multimin, "FdfMinimizer", cGSL_Object); cgsl_multimin_fminimizer = rb_define_class_under(mgsl_multimin, "FMinimizer", cGSL_Object); define_const(cgsl_multimin_fdfminimizer, cgsl_multimin_fminimizer); cgsl_multimin_function = rb_define_class_under(mgsl_multimin, "Function", cgsl_function); rb_define_singleton_method(cgsl_multimin_function, "alloc", rb_gsl_multimin_function_new, -1); rb_define_method(cgsl_multimin_function, "eval", rb_gsl_multimin_function_eval, 1); rb_define_alias(cgsl_multimin_function, "call", "eval"); rb_define_method(cgsl_multimin_function, "set_proc", rb_gsl_multimin_function_set_f, -1); rb_define_alias(cgsl_multimin_function, "set_f", "set_proc"); rb_define_method(cgsl_multimin_function, "set_params", rb_gsl_multimin_function_set_params, -1); rb_define_method(cgsl_multimin_function, "params", rb_gsl_multimin_function_params, 0); rb_define_method(cgsl_multimin_function, "n", rb_gsl_multimin_function_n, 0); cgsl_multimin_function_fdf = rb_define_class_under(mgsl_multimin, "Function_fdf", cGSL_Object); rb_define_singleton_method(cgsl_multimin_function_fdf, "alloc", rb_gsl_multimin_function_fdf_new, -1); rb_define_method(cgsl_multimin_function_fdf, "set", rb_gsl_multimin_function_fdf_set, -1); rb_define_method(cgsl_multimin_function_fdf, "set_params", rb_gsl_multimin_function_fdf_set_params, -1); rb_define_method(cgsl_multimin_function_fdf, "set_procs", rb_gsl_multimin_function_fdf_set_procs, -1); rb_define_method(cgsl_multimin_function_fdf, "params", rb_gsl_multimin_function_fdf_params, 0); rb_define_method(cgsl_multimin_function_fdf, "n", rb_gsl_multimin_function_fdf_n, 0); rb_define_singleton_method(cgsl_multimin_fdfminimizer, "alloc", rb_gsl_fdfminimizer_new, 2); rb_define_method(cgsl_multimin_fdfminimizer, "set", rb_gsl_fdfminimizer_set, 4); rb_define_method(cgsl_multimin_fdfminimizer, "name", rb_gsl_fdfminimizer_name, 0); rb_define_method(cgsl_multimin_fdfminimizer, "iterate", rb_gsl_fdfminimizer_iterate, 0); rb_define_method(cgsl_multimin_fdfminimizer, "x", rb_gsl_fdfminimizer_x, 0); rb_define_method(cgsl_multimin_fdfminimizer, "f", rb_gsl_fdfminimizer_f, 0); rb_define_method(cgsl_multimin_fdfminimizer, "gradient", rb_gsl_fdfminimizer_gradient, 0); rb_define_method(cgsl_multimin_fdfminimizer, "minimum", rb_gsl_fdfminimizer_minimum, 0); rb_define_method(cgsl_multimin_fdfminimizer, "restart", rb_gsl_fdfminimizer_restart, 0); rb_define_method(cgsl_multimin_fdfminimizer, "test_gradient", rb_gsl_fdfminimizer_test_gradient, 1); /*****/ #ifdef GSL_1_3_LATER rb_define_singleton_method(cgsl_multimin_fminimizer, "alloc", rb_gsl_fminimizer_new, 2); rb_define_method(cgsl_multimin_fminimizer, "set", rb_gsl_fminimizer_set, 3); rb_define_method(cgsl_multimin_fminimizer, "name", rb_gsl_fminimizer_name, 0); rb_define_method(cgsl_multimin_fminimizer, "iterate", rb_gsl_fminimizer_iterate, 0); rb_define_method(cgsl_multimin_fminimizer, "x", rb_gsl_fminimizer_x, 0); rb_define_method(cgsl_multimin_fminimizer, "fval", rb_gsl_fminimizer_fval, 0); rb_define_method(cgsl_multimin_fminimizer, "minimum", rb_gsl_fminimizer_minimum, 0); rb_define_method(cgsl_multimin_fminimizer, "size", rb_gsl_fminimizer_size, 0); rb_define_method(cgsl_multimin_fminimizer, "test_size", rb_gsl_fminimizer_test_size, 1); #endif #ifdef HAVE_GSL_GSL_MULTIMIN_FSDF_H Init_multimin_fsdf(mgsl_multimin); #endif } #ifdef CHECK_MULTIMIN_FUNCTION #undef CHECK_MULTIMIN_FUNCTION #endif #ifdef CHECK_MULTIMIN_FUNCTION_FDF #undef CHECK_MULTIMIN_FUNCTION_FDF #endif gsl-1.15.3/ext/cheb.c0000644000175000017500000004066612220252463013623 0ustar boutilboutil/* cheb.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_common.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #include #include #ifdef HAVE_NARRAY_H #include "narray.h" #endif static VALUE cgsl_cheb; static VALUE rb_gsl_cheb_new(VALUE klass, VALUE nn) { gsl_cheb_series *p = NULL; CHECK_FIXNUM(nn); p = gsl_cheb_alloc(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, gsl_cheb_free, p); } static VALUE rb_gsl_cheb_order(VALUE obj) { gsl_cheb_series *p = NULL; Data_Get_Struct(obj, gsl_cheb_series, p); return INT2FIX(p->order); } static VALUE rb_gsl_cheb_a(VALUE obj) { gsl_cheb_series *p = NULL; Data_Get_Struct(obj, gsl_cheb_series, p); return rb_float_new(p->a); } static VALUE rb_gsl_cheb_b(VALUE obj) { gsl_cheb_series *p = NULL; Data_Get_Struct(obj, gsl_cheb_series, p); return rb_float_new(p->b); } static VALUE rb_gsl_cheb_coef(VALUE obj) { gsl_cheb_series *p = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_cheb_series, p); v = gsl_vector_view_alloc(); v->vector.data = p->c; v->vector.size = p->order + 1; v->vector.stride = 1; v->vector.owner = 0; return Data_Wrap_Struct(cgsl_vector_view_ro, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_cheb_f(VALUE obj) { gsl_cheb_series *p = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_cheb_series, p); v = gsl_vector_view_alloc(); v->vector.data = p->f; v->vector.size = p->order + 1; v->vector.stride = 1; v->vector.owner = 0; return Data_Wrap_Struct(cgsl_vector_view_ro, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_cheb_init(VALUE obj, VALUE ff, VALUE aa, VALUE bb) { gsl_cheb_series *p = NULL; gsl_function *fff = NULL; double a, b; CHECK_FUNCTION(ff); Need_Float(aa); Need_Float(bb); Data_Get_Struct(obj, gsl_cheb_series, p); Data_Get_Struct(ff, gsl_function, fff); a = NUM2DBL(aa); b = NUM2DBL(bb); gsl_cheb_init(p, fff, a, b); return obj; } static VALUE rb_gsl_cheb_eval(VALUE obj, VALUE xx) { gsl_cheb_series *p = NULL; VALUE x, ary; size_t i, j, n; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif Data_Get_Struct(obj, gsl_cheb_series, p); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(gsl_cheb_eval(p, NUM2DBL(xx))); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(xx); rb_ary_store(ary, i, rb_float_new(gsl_cheb_eval(p, NUM2DBL(x)))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); for (i = 0; i < n; i++) ptr2[i] = gsl_cheb_eval(p, ptr1[i]); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, gsl_cheb_eval(p, gsl_vector_get(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, gsl_cheb_eval(p, gsl_matrix_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_cheb_eval_err(VALUE obj, VALUE xx) { gsl_cheb_series *p = NULL; double result, err; VALUE x, ary, aerr; size_t n, i, j; gsl_vector *v = NULL, *vnew = NULL, *verr = NULL; gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2, *ptr3; #endif Data_Get_Struct(obj, gsl_cheb_series, p); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: gsl_cheb_eval_err(p, NUM2DBL(xx), &result, &err); return rb_ary_new3(2, rb_float_new(result), rb_float_new(err)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); aerr = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(xx); gsl_cheb_eval_err(p, NUM2DBL(x), &result, &err); rb_ary_store(ary, i, rb_float_new(result)); rb_ary_store(aerr, i, rb_float_new(err)); } return rb_ary_new3(2, ary, aerr); break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); aerr = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); ptr3 = NA_PTR_TYPE(aerr,double*); for (i = 0; i < n; i++) { gsl_cheb_eval_err(p, ptr1[i], &result, &err); ptr2[i] = result; ptr3[i] = err; } return rb_ary_new3(2, ary, aerr); } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); verr = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_cheb_eval_err(p, gsl_vector_get(v, i), &result, &err); gsl_vector_set(vnew, i, result); gsl_vector_set(verr, i, err); } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr)); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); merr = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_cheb_eval_err(p, gsl_matrix_get(m, i, j), &result, &err); gsl_matrix_set(mnew, i, j, result); gsl_matrix_set(merr, i, j, err); } } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew), Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr)); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_cheb_eval_n(VALUE obj, VALUE nn, VALUE xx) { gsl_cheb_series *p = NULL; VALUE x, ary; size_t n, order, i, j; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif CHECK_FIXNUM(nn); order = FIX2INT(nn); Data_Get_Struct(obj, gsl_cheb_series, p); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(gsl_cheb_eval_n(p, order, NUM2DBL(xx))); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(xx); rb_ary_store(ary, i, rb_float_new(gsl_cheb_eval_n(p, order, NUM2DBL(x)))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); for (i = 0; i < n; i++) ptr2[i] = gsl_cheb_eval_n(p, order, ptr1[i]); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, gsl_cheb_eval_n(p, order, gsl_vector_get(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, gsl_cheb_eval_n(p, order, gsl_matrix_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_cheb_eval_n_err(VALUE obj, VALUE nn, VALUE xx) { gsl_cheb_series *p = NULL; double result, err; VALUE x, ary, aerr; size_t n, order, i, j; gsl_vector *v, *vnew, *verr; gsl_matrix *m, *mnew, *merr; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2, *ptr3; #endif CHECK_FIXNUM(nn); order = FIX2INT(nn); Data_Get_Struct(obj, gsl_cheb_series, p); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: gsl_cheb_eval_n_err(p, order, NUM2DBL(xx), &result, &err); return rb_ary_new3(2, rb_float_new(result), rb_float_new(err)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); aerr = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(xx); gsl_cheb_eval_n_err(p, order, NUM2DBL(x), &result, &err); rb_ary_store(ary, i, rb_float_new(result)); rb_ary_store(aerr, i, rb_float_new(err)); } return rb_ary_new3(2, ary, aerr); break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); aerr = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); ptr3 = NA_PTR_TYPE(aerr,double*); for (i = 0; i < n; i++) { gsl_cheb_eval_n_err(p, order, ptr1[i], &result, &err); ptr2[i] = result; ptr3[i] = err; } return rb_ary_new3(2, ary, aerr); } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); verr = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_cheb_eval_n_err(p, order, gsl_vector_get(v, i), &result, &err); gsl_vector_set(vnew, i, result); gsl_vector_set(verr, i, err); } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr)); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); merr = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_cheb_eval_n_err(p, order, gsl_matrix_get(m, i, j), &result, &err); gsl_matrix_set(mnew, i, j, result); gsl_matrix_set(merr, i, j, err); } } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew), Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr)); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_cheb_calc_deriv(int argc, VALUE *argv, VALUE obj) { gsl_cheb_series *deriv = NULL, *cs = NULL; VALUE retval; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: if (!rb_obj_is_kind_of(argv[0], cgsl_cheb)) rb_raise(rb_eTypeError, "wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_cheb_series, cs); deriv = gsl_cheb_alloc(cs->order); retval = Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_cheb_free, deriv); break; case 2: if (!rb_obj_is_kind_of(argv[0], cgsl_cheb)) rb_raise(rb_eTypeError, "argv[0] wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[0]))); if (!rb_obj_is_kind_of(argv[1], cgsl_cheb)) rb_raise(rb_eTypeError, "argv[1] wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[0], gsl_cheb_series, deriv); Data_Get_Struct(argv[1], gsl_cheb_series, cs); retval = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: Data_Get_Struct(obj, gsl_cheb_series, cs); switch (argc) { case 0: deriv = gsl_cheb_alloc(cs->order); retval = Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_cheb_free, deriv); break; case 1: if (!rb_obj_is_kind_of(argv[0], cgsl_cheb)) rb_raise(rb_eTypeError, "argv[0] wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_cheb_series, deriv); retval = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } break; } gsl_cheb_calc_deriv(deriv, cs); return retval; } static VALUE rb_gsl_cheb_calc_integ(int argc, VALUE *argv, VALUE obj) { gsl_cheb_series *deriv = NULL, *cs = NULL; VALUE retval; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: if (!rb_obj_is_kind_of(argv[0], cgsl_cheb)) rb_raise(rb_eTypeError, "wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_cheb_series, cs); deriv = gsl_cheb_alloc(cs->order); retval = Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_cheb_free, deriv); break; case 2: if (!rb_obj_is_kind_of(argv[0], cgsl_cheb)) rb_raise(rb_eTypeError, "argv[0] wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[0]))); if (!rb_obj_is_kind_of(argv[1], cgsl_cheb)) rb_raise(rb_eTypeError, "argv[1] wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[1]))); Data_Get_Struct(argv[0], gsl_cheb_series, deriv); Data_Get_Struct(argv[1], gsl_cheb_series, cs); retval = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: Data_Get_Struct(obj, gsl_cheb_series, cs); switch (argc) { case 0: deriv = gsl_cheb_alloc(cs->order); retval = Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_cheb_free, deriv); break; case 1: if (!rb_obj_is_kind_of(argv[0], cgsl_cheb)) rb_raise(rb_eTypeError, "argv[0] wrong argument type %s (Cheb expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_cheb_series, deriv); retval = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } break; } gsl_cheb_calc_integ(deriv, cs); return retval; } void Init_gsl_cheb(VALUE module) { cgsl_cheb = rb_define_class_under(module, "Cheb", cGSL_Object); rb_define_singleton_method(cgsl_cheb, "new", rb_gsl_cheb_new, 1); rb_define_singleton_method(cgsl_cheb, "alloc", rb_gsl_cheb_new, 1); rb_define_method(cgsl_cheb, "order", rb_gsl_cheb_order, 0); rb_define_method(cgsl_cheb, "a", rb_gsl_cheb_a, 0); rb_define_method(cgsl_cheb, "b", rb_gsl_cheb_b, 0); rb_define_method(cgsl_cheb, "coef", rb_gsl_cheb_coef, 0); rb_define_alias(cgsl_cheb, "c", "coef"); rb_define_method(cgsl_cheb, "f", rb_gsl_cheb_f, 0); rb_define_method(cgsl_cheb, "init", rb_gsl_cheb_init, 3); rb_define_method(cgsl_cheb, "eval", rb_gsl_cheb_eval, 1); rb_define_method(cgsl_cheb, "eval_err", rb_gsl_cheb_eval_err, 1); rb_define_method(cgsl_cheb, "eval_n", rb_gsl_cheb_eval_n, 2); rb_define_method(cgsl_cheb, "eval_n_err", rb_gsl_cheb_eval_n_err, 2); rb_define_method(cgsl_cheb, "calc_deriv", rb_gsl_cheb_calc_deriv, -1); rb_define_alias(cgsl_cheb, "deriv", "calc_deriv"); rb_define_method(cgsl_cheb, "calc_integ", rb_gsl_cheb_calc_integ, -1); rb_define_alias(cgsl_cheb, "integ", "calc_integ"); rb_define_singleton_method(cgsl_cheb, "calc_deriv", rb_gsl_cheb_calc_deriv, -1); rb_define_singleton_method(cgsl_cheb, "calc_integ", rb_gsl_cheb_calc_integ, -1); } gsl-1.15.3/ext/fit.c0000644000175000017500000001453612220252463013501 0ustar boutilboutil/* fit.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_fit.h" /* linear fit without weights: y = c0 + c1 x */ /* This returns 7 elements array */ static VALUE rb_gsl_fit_linear(int argc, VALUE *argv, VALUE obj) { double *ptrx, *ptry; double c0, c1, cov00, cov01, cov11, sumsq; int status; size_t n, stridex, stridey; switch (argc) { case 2: ptrx = get_vector_ptr(argv[0], &stridex, &n); ptry = get_vector_ptr(argv[1], &stridey, &n); break; case 3: CHECK_FIXNUM(argv[2]); ptrx = get_vector_ptr(argv[0], &stridex, &n); ptry = get_vector_ptr(argv[1], &stridey, &n); n = FIX2INT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } status = gsl_fit_linear(ptrx, stridex, ptry, stridey, n, &c0, &c1, &cov00, &cov01, &cov11, &sumsq); return rb_ary_new3(7, rb_float_new(c0), rb_float_new(c1), rb_float_new(cov00), rb_float_new(cov01), rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status)); } /* linear fit with weights: y = c0 + c1 x */ static VALUE rb_gsl_fit_wlinear(int argc, VALUE *argv, VALUE obj) { double *ptrx, *ptry, *ptrw; double c0, c1, cov00, cov01, cov11, sumsq; int status; size_t n, stridex, stridey, stridew; switch (argc) { case 3: ptrx = get_vector_ptr(argv[0], &stridex, &n); ptrw = get_vector_ptr(argv[1], &stridew, &n); ptry = get_vector_ptr(argv[2], &stridey, &n); break; case 4: CHECK_FIXNUM(argv[3]); ptrx = get_vector_ptr(argv[0], &stridex, &n); ptrw = get_vector_ptr(argv[1], &stridew, &n); ptry = get_vector_ptr(argv[2], &stridey, &n); n = FIX2INT(argv[3]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } status = gsl_fit_wlinear(ptrx, stridex, ptrw, stridew, ptry, stridey, n, &c0, &c1, &cov00, &cov01, &cov11, &sumsq); return rb_ary_new3(7, rb_float_new(c0), rb_float_new(c1), rb_float_new(cov00), rb_float_new(cov01), rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status)); } static VALUE rb_gsl_fit_linear_est(int argc, VALUE *argv, VALUE obj) { double y, yerr, x, c0, c1, c00, c01, c11; int status; size_t i; switch (argc) { case 2: x = NUM2DBL(argv[0]); if (TYPE(argv[1]) == T_ARRAY) { c0 = NUM2DBL(rb_ary_entry(argv[1], 0)); c1 = NUM2DBL(rb_ary_entry(argv[1], 1)); c00 = NUM2DBL(rb_ary_entry(argv[1], 2)); c01 = NUM2DBL(rb_ary_entry(argv[1], 3)); c11 = NUM2DBL(rb_ary_entry(argv[1], 4)); } else { rb_raise(rb_eTypeError, "argv[1] Array expected"); } break; case 6: for (i = 0; i < 6; i++) Need_Float(argv[i]); x = NUM2DBL(argv[0]); c0 = NUM2DBL(argv[1]); c1 = NUM2DBL(argv[2]); c00 = NUM2DBL(argv[3]); c01 = NUM2DBL(argv[4]); c11 = NUM2DBL(argv[5]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 6)", argc); } status = gsl_fit_linear_est(x, c0, c1, c00, c01, c11, &y, &yerr); return rb_ary_new3(3, rb_float_new(y), rb_float_new(yerr), INT2FIX(status)); } static VALUE rb_gsl_fit_mul(int argc, VALUE *argv, VALUE obj) { double *ptrx, *ptry; double c1, cov11, sumsq; int status; size_t n, stridex, stridey; switch (argc) { case 2: ptrx = get_vector_ptr(argv[0], &stridex, &n); ptry = get_vector_ptr(argv[1], &stridey, &n); break; case 3: CHECK_FIXNUM(argv[2]); ptrx = get_vector_ptr(argv[0], &stridex, &n); ptry = get_vector_ptr(argv[1], &stridey, &n); n = FIX2INT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } status = gsl_fit_mul(ptrx, stridex, ptry, stridey, n, &c1, &cov11, &sumsq); return rb_ary_new3(4, rb_float_new(c1), rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status)); } static VALUE rb_gsl_fit_wmul(int argc, VALUE *argv, VALUE obj) { double *ptrx, *ptry, *ptrw; double c1, cov11, sumsq; int status; size_t n, stridex, stridey, stridew; switch (argc) { case 3: ptrx = get_vector_ptr(argv[0], &stridex, &n); ptrw = get_vector_ptr(argv[1], &stridew, &n); ptry = get_vector_ptr(argv[2], &stridey, &n); break; case 4: CHECK_FIXNUM(argv[3]); ptrx = get_vector_ptr(argv[0], &stridex, &n); ptrw = get_vector_ptr(argv[1], &stridew, &n); ptry = get_vector_ptr(argv[2], &stridey, &n); n = FIX2INT(argv[3]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } status = gsl_fit_wmul(ptrx, stridex, ptrw, stridew, ptry, stridey, n, &c1, &cov11, &sumsq); return rb_ary_new3(4, rb_float_new(c1), rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status)); } static VALUE rb_gsl_fit_mul_est(int argc, VALUE *argv, VALUE obj) { double y, yerr, x, c1, c11; int status; switch (argc) { case 2: Need_Float(argv[0]); if (TYPE(argv[1]) == T_ARRAY) { c1 = NUM2DBL(rb_ary_entry(argv[1], 0)); c11 = NUM2DBL(rb_ary_entry(argv[1], 1)); } else { rb_raise(rb_eTypeError, "argv[1]: Array expected"); } x = NUM2DBL(argv[0]); break; case 3: Need_Float(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); x = NUM2DBL(argv[0]); c1 = NUM2DBL(argv[1]); c11 = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } status = gsl_fit_mul_est(x, c1, c11, &y, &yerr); return rb_ary_new3(3, rb_float_new(y), rb_float_new(yerr), INT2FIX(status)); } void Init_gsl_fit(VALUE module) { VALUE mgsl_fit; mgsl_fit = rb_define_module_under(module, "Fit"); rb_define_module_function(mgsl_fit, "linear", rb_gsl_fit_linear, -1); rb_define_module_function(mgsl_fit, "wlinear", rb_gsl_fit_wlinear, -1); rb_define_module_function(mgsl_fit, "linear_est", rb_gsl_fit_linear_est, -1); rb_define_module_function(mgsl_fit, "mul", rb_gsl_fit_mul, -1); rb_define_module_function(mgsl_fit, "wmul", rb_gsl_fit_wmul, -1); rb_define_module_function(mgsl_fit, "mul_est", rb_gsl_fit_mul_est, -1); } gsl-1.15.3/ext/histogram3d.c0000644000175000017500000006664712220252463015155 0ustar boutilboutil/* histogram3d.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_histogram.h" #include "rb_gsl_common.h" #include "rb_gsl_array.h" static VALUE cgsl_histogram3d; static VALUE cgsl_histogram3d_view; static VALUE rb_gsl_histogram3d_new(int argc, VALUE *argv, VALUE klass) { mygsl_histogram3d *h = NULL; gsl_vector *xrange, *yrange, *zrange; double xmin, xmax, ymin, ymax, zmin, zmax; size_t nx, ny, nz; switch (argc) { case 3: if (TYPE(argv[0]) == T_FIXNUM && TYPE(argv[1]) == T_FIXNUM && TYPE(argv[2]) == T_FIXNUM) { h = mygsl_histogram3d_alloc(FIX2INT(argv[0]), FIX2INT(argv[1]), FIX2INT(argv[2])); } else if (VECTOR_P(argv[0]) && VECTOR_P(argv[1]) && VECTOR_P(argv[2])) { Data_Get_Struct(argv[0], gsl_vector, xrange); Data_Get_Struct(argv[1], gsl_vector, yrange); Data_Get_Struct(argv[2], gsl_vector, zrange); h = mygsl_histogram3d_alloc(xrange->size-1, yrange->size-1, zrange->size-1); mygsl_histogram3d_set_ranges(h, xrange->data, xrange->size, yrange->data, yrange->size, zrange->data, zrange->size); } else if (TYPE(argv[0]) == T_ARRAY && TYPE(argv[1]) == T_ARRAY && TYPE(argv[2]) == T_ARRAY) { xrange = make_cvector_from_rarray(argv[0]); yrange = make_cvector_from_rarray(argv[1]); zrange = make_cvector_from_rarray(argv[2]); h = mygsl_histogram3d_alloc(xrange->size-1, yrange->size-1, zrange->size-1); mygsl_histogram3d_set_ranges(h, xrange->data, xrange->size, yrange->data, yrange->size, zrange->data, zrange->size); gsl_vector_free(zrange); gsl_vector_free(yrange); gsl_vector_free(xrange); } else { rb_raise(rb_eTypeError, "wrong argument types"); } break; case 6: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[2]); CHECK_FIXNUM(argv[4]); Check_Type(argv[1], T_ARRAY); Check_Type(argv[3], T_ARRAY); Check_Type(argv[5], T_ARRAY); nx = FIX2INT(argv[0]); ny = FIX2INT(argv[2]); nz = FIX2INT(argv[4]); xmin = NUM2DBL(rb_ary_entry(argv[1], 0)); xmax = NUM2DBL(rb_ary_entry(argv[1], 1)); ymin = NUM2DBL(rb_ary_entry(argv[3], 0)); ymax = NUM2DBL(rb_ary_entry(argv[3], 1)); zmin = NUM2DBL(rb_ary_entry(argv[5], 0)); zmax = NUM2DBL(rb_ary_entry(argv[5], 1)); h = mygsl_histogram3d_calloc_uniform(nx, ny, nz, xmin, xmax, ymin, ymax, zmin, zmax); break; case 9: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[3]); CHECK_FIXNUM(argv[6]); nx = FIX2INT(argv[0]); ny = FIX2INT(argv[3]); nz = FIX2INT(argv[6]); xmin = NUM2DBL(argv[1]); xmax = NUM2DBL(argv[2]); ymin = NUM2DBL(argv[4]); ymax = NUM2DBL(argv[5]); zmin = NUM2DBL(argv[7]); zmax = NUM2DBL(argv[8]); h = mygsl_histogram3d_calloc_uniform(nx, ny, nz, xmin, xmax, ymin, ymax, zmin, zmax); break; default: break; } return Data_Wrap_Struct(cgsl_histogram3d, 0, mygsl_histogram3d_free, h); } static VALUE rb_gsl_histogram3d_nx(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return INT2FIX(h->nx); } static VALUE rb_gsl_histogram3d_ny(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return INT2FIX(h->ny); } static VALUE rb_gsl_histogram3d_nz(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return INT2FIX(h->nz); } static VALUE rb_gsl_histogram3d_size(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return INT2NUM(h->nx*h->ny*h->nz); } static VALUE rb_gsl_histogram3d_shape(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_ary_new3(3, INT2FIX(h->nx), INT2FIX(h->ny), INT2FIX(h->nz)); } static VALUE rb_gsl_histogram3d_xrange(VALUE obj) { mygsl_histogram3d *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, mygsl_histogram3d, h); v = gsl_vector_view_alloc(h->nx); v->vector.data = h->xrange; v->vector.size = h->nx + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_range, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram3d_yrange(VALUE obj) { mygsl_histogram3d *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, mygsl_histogram3d, h); v = gsl_vector_view_alloc(h->ny); v->vector.data = h->yrange; v->vector.size = h->ny + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_range, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram3d_zrange(VALUE obj) { mygsl_histogram3d *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, mygsl_histogram3d, h); v = gsl_vector_view_alloc(h->nz); v->vector.data = h->zrange; v->vector.size = h->nz + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_range, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram3d_bin(VALUE obj) { mygsl_histogram3d *h = NULL; size_t n = h->nx*h->ny*h->nz; gsl_vector_view *v = NULL; Data_Get_Struct(obj, mygsl_histogram3d, h); v = gsl_vector_view_alloc(n); v->vector.data = h->bin; v->vector.size = n; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram3d_get(int argc, VALUE *argv, VALUE obj) { mygsl_histogram3d *h = NULL; mygsl_histogram3d_view *h2 = NULL; mygsl_histogram2d_view *h1 = NULL; size_t i, j, k; Data_Get_Struct(obj, mygsl_histogram3d, h); switch (argc) { case 1: switch (TYPE(argv[0])) { case T_FIXNUM: i = FIX2INT(argv[0]); h2 = ALLOC(mygsl_histogram3d_view); h2->h.nx = h->ny; h2->h.ny = h->nz; h2->h.xrange = h->yrange; h2->h.yrange = h->zrange; h2->h.bin = h->bin + i*h->ny*h->nz; return Data_Wrap_Struct(cgsl_histogram3d_view, 0, free, h2); break; case T_ARRAY: // switch (RARRAY(argv[0])->len) { switch (RARRAY_LEN(argv[0])) { case 1: i = FIX2INT(rb_ary_entry(argv[0], 0)); h2 = ALLOC(mygsl_histogram3d_view); h2->h.nx = h->ny; h2->h.ny = h->nz; h2->h.xrange = h->yrange; h2->h.yrange = h->zrange; h2->h.bin = h->bin + i*h->ny*h->nz; return Data_Wrap_Struct(cgsl_histogram3d_view, 0, free, h2); break; case 2: i = FIX2INT(rb_ary_entry(argv[0], 0)); j = FIX2INT(rb_ary_entry(argv[0], 1)); h1 = ALLOC(mygsl_histogram2d_view); h1->h.n = h->nz; h1->h.range = h->zrange; h1->h.bin = h->bin + i*h->ny*h->nz + j*h->nz; return Data_Wrap_Struct(cgsl_histogram2d_view, 0, free, h1); break; case 3: i = FIX2INT(rb_ary_entry(argv[0], 0)); j = FIX2INT(rb_ary_entry(argv[0], 1)); k = FIX2INT(rb_ary_entry(argv[0], 2)); /* do the last line of this function */ break; default: rb_raise(rb_eRuntimeError, "wrong array size"); } break; default: rb_raise(rb_eTypeError, "wrong argument type %s (Fixnum or Array expected)", rb_class2name(CLASS_OF(argv[0]))); break; } break; case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); i = FIX2INT(argv[0]); j = FIX2INT(argv[1]); h1 = ALLOC(mygsl_histogram2d_view); h1->h.n = h->nz; h1->h.range = h->zrange; h1->h.bin = h->bin + i*h->ny*h->nz + j*h->nz; return Data_Wrap_Struct(cgsl_histogram2d_view, 0, free, h1); break; case 3: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); i = FIX2INT(argv[0]); j = FIX2INT(argv[1]); k = FIX2INT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arugments"); break; } return rb_float_new(mygsl_histogram3d_get(h, i, j, k)); } static VALUE rb_gsl_histogram3d_increment(int argc, VALUE *argv, VALUE obj) { mygsl_histogram3d *h = NULL; double x, y, z, weight = 1; switch (argc) { case 4: Need_Float(argv[3]); weight = NUM2DBL(argv[3]); /* no break */ case 3: Need_Float(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); x = NUM2DBL(argv[0]); y = NUM2DBL(argv[1]); z = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arugments (%d for 3 or 4", argc); break; } Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_accumulate(h, x, y, z, weight); return obj; } static VALUE rb_gsl_histogram3d_increment2(int argc, VALUE *argv, VALUE obj) { mygsl_histogram3d *h = NULL; double x, y, z, weight = 1; switch (argc) { case 4: Need_Float(argv[3]); weight = NUM2DBL(argv[3]); /* no break */ case 3: Need_Float(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); x = NUM2DBL(argv[0]); y = NUM2DBL(argv[1]); z = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arugments (%d for 3 or 4", argc); break; } Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_accumulate2(h, x, y, z, weight); return obj; } static VALUE rb_gsl_histogram3d_get_xrange(VALUE obj, VALUE ii) { mygsl_histogram3d *h = NULL; size_t i; double xlower, xupper; CHECK_FIXNUM(ii); Data_Get_Struct(obj, mygsl_histogram3d, h); i = (size_t) FIX2INT(ii); mygsl_histogram3d_get_xrange(h, i, &xlower, &xupper); return rb_ary_new3(2, rb_float_new(xlower), rb_float_new(xupper)); } static VALUE rb_gsl_histogram3d_get_yrange(VALUE obj, VALUE jj) { mygsl_histogram3d *h = NULL; size_t j; double ylower, yupper; CHECK_FIXNUM(jj); Data_Get_Struct(obj, mygsl_histogram3d, h); j = (size_t) FIX2INT(jj); mygsl_histogram3d_get_yrange(h, j, &ylower, &yupper); return rb_ary_new3(2, rb_float_new(ylower), rb_float_new(yupper)); } static VALUE rb_gsl_histogram3d_get_zrange(VALUE obj, VALUE kk) { mygsl_histogram3d *h = NULL; size_t k; double zlower, zupper; CHECK_FIXNUM(kk); Data_Get_Struct(obj, mygsl_histogram3d, h); k = (size_t) FIX2INT(kk); mygsl_histogram3d_get_zrange(h, k, &zlower, &zupper); return rb_ary_new3(2, rb_float_new(zlower), rb_float_new(zupper)); } static VALUE rb_gsl_histogram3d_find(VALUE obj, VALUE x, VALUE y, VALUE z) { mygsl_histogram3d *h = NULL; size_t i, j, k; Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_find(h, NUM2DBL(x), NUM2DBL(y), NUM2DBL(z), &i, &j, &k); return rb_ary_new3(3, INT2FIX(i), INT2FIX(j), INT2FIX(k)); } static VALUE rb_gsl_histogram3d_set_ranges(VALUE obj, VALUE xx, VALUE yy, VALUE zz) { mygsl_histogram3d *h = NULL; gsl_vector *xrange, *yrange, *zrange; int flagx = 0, flagy = 0, flagz = 0; Data_Get_Struct(obj, mygsl_histogram3d, h); if (TYPE(xx) == T_ARRAY) { xrange = make_cvector_from_rarray(xx); flagx = 1; } else if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, xrange); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector expected)", rb_class2name(CLASS_OF(xx))); } if (xrange->size != h->nx+1) rb_raise(rb_eIndexError, "xrange length is different"); if (TYPE(yy) == T_ARRAY) { yrange = make_cvector_from_rarray(yy); flagy = 1; } else if (VECTOR_P(yy)) { Data_Get_Struct(yy, gsl_vector, yrange); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector expected)", rb_class2name(CLASS_OF(yy))); } if (yrange->size != h->ny+1) rb_raise(rb_eIndexError, "yrange length is different"); if (TYPE(zz) == T_ARRAY) { zrange = make_cvector_from_rarray(zz); flagz = 1; } else if (VECTOR_P(zz)) { Data_Get_Struct(zz, gsl_vector, zrange); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector expected)", rb_class2name(CLASS_OF(zz))); } if (zrange->size != h->nz+1) rb_raise(rb_eIndexError, "zrange length is different"); mygsl_histogram3d_set_ranges(h, xrange->data, xrange->size, yrange->data, yrange->size, zrange->data, zrange->size); if (flagz == 1) gsl_vector_free(zrange); if (flagy == 1) gsl_vector_free(yrange); if (flagx == 1) gsl_vector_free(xrange); return obj; } static VALUE rb_gsl_histogram3d_set_ranges_uniform(int argc, VALUE *argv, VALUE obj) { mygsl_histogram3d *h = NULL; double xmin, xmax, ymin, ymax, zmin, zmax; switch (argc) { case 3: Check_Type(argv[0], T_ARRAY); Check_Type(argv[1], T_ARRAY); Check_Type(argv[2], T_ARRAY); xmin = NUM2DBL(rb_ary_entry(argv[0], 0)); xmax = NUM2DBL(rb_ary_entry(argv[0], 1)); ymin = NUM2DBL(rb_ary_entry(argv[1], 0)); ymax = NUM2DBL(rb_ary_entry(argv[1], 1)); zmin = NUM2DBL(rb_ary_entry(argv[2], 0)); zmax = NUM2DBL(rb_ary_entry(argv[2], 1)); break; case 6: xmin = NUM2DBL(argv[0]); xmax = NUM2DBL(argv[1]); ymin = NUM2DBL(argv[2]); ymax = NUM2DBL(argv[3]); zmin = NUM2DBL(argv[4]); zmax = NUM2DBL(argv[5]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 6)", argc); break; } Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_set_ranges_uniform(h, xmin, xmax, ymin, ymax, zmin, zmax); return obj; } static VALUE rb_gsl_histogram3d_memcpy(VALUE obj, VALUE a, VALUE b) { mygsl_histogram3d *dst, *src; Data_Get_Struct(a, mygsl_histogram3d, dst); Data_Get_Struct(b, mygsl_histogram3d, src); mygsl_histogram3d_memcpy(dst, src); return a; } static VALUE rb_gsl_histogram3d_clone(VALUE obj) { mygsl_histogram3d *h, *hnew; Data_Get_Struct(obj, mygsl_histogram3d, h); hnew = mygsl_histogram3d_clone(h); return Data_Wrap_Struct(cgsl_histogram3d, 0, mygsl_histogram3d_free, hnew); } static VALUE rb_gsl_histogram3d_xyproject(int argc, VALUE *argv, VALUE obj) { mygsl_histogram3d *h3; gsl_histogram2d *h2; size_t kstart = 0, kend; Data_Get_Struct(obj, mygsl_histogram3d, h3); switch (argc) { case 2: kstart = (size_t) FIX2INT(argv[0]); kend = (size_t) FIX2INT(argv[1]); break; case 1: kstart = (size_t) FIX2INT(argv[0]); kend = h3->nz; break; case 0: kend = h3->nz; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } h2 = mygsl_histogram3d_xyproject(h3, kstart, kend); return Data_Wrap_Struct(cgsl_histogram2d, 0, gsl_histogram2d_free, h2); } static VALUE rb_gsl_histogram3d_xzproject(int argc, VALUE *argv, VALUE obj) { mygsl_histogram3d *h3; gsl_histogram2d *h2; size_t jstart = 0, jend; Data_Get_Struct(obj, mygsl_histogram3d, h3); switch (argc) { case 2: jstart = (size_t) FIX2INT(argv[0]); jend = (size_t) FIX2INT(argv[1]); break; case 1: jstart = (size_t) FIX2INT(argv[0]); jend = h3->ny; break; case 0: jend = h3->ny; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } h2 = mygsl_histogram3d_xzproject(h3, jstart, jend); return Data_Wrap_Struct(cgsl_histogram2d, 0, gsl_histogram2d_free, h2); } static VALUE rb_gsl_histogram3d_yzproject(int argc, VALUE *argv, VALUE obj) { mygsl_histogram3d *h3; gsl_histogram2d *h2; size_t istart = 0, iend; Data_Get_Struct(obj, mygsl_histogram3d, h3); switch (argc) { case 2: istart = (size_t) FIX2INT(argv[0]); iend = (size_t) FIX2INT(argv[1]); break; case 1: istart = (size_t) FIX2INT(argv[0]); iend = h3->nx; break; case 0: iend = h3->nx; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } h2 = mygsl_histogram3d_yzproject(h3, istart, iend); return Data_Wrap_Struct(cgsl_histogram2d, 0, gsl_histogram2d_free, h2); } static VALUE rb_gsl_histogram3d_scale_bang(VALUE obj, VALUE s) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_scale(h, NUM2DBL(s)); return obj; } static VALUE rb_gsl_histogram3d_scale(VALUE obj, VALUE s) { mygsl_histogram3d *h, *hnew; Data_Get_Struct(obj, mygsl_histogram3d, h); hnew = mygsl_histogram3d_clone(h); mygsl_histogram3d_scale(hnew, NUM2DBL(s)); return Data_Wrap_Struct(cgsl_histogram3d, 0, mygsl_histogram3d_free, hnew); } static VALUE rb_gsl_histogram3d_shift_bang(VALUE obj, VALUE s) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_shift(h, NUM2DBL(s)); return obj; } static VALUE rb_gsl_histogram3d_shift(VALUE obj, VALUE s) { mygsl_histogram3d *h, *hnew; Data_Get_Struct(obj, mygsl_histogram3d, h); hnew = mygsl_histogram3d_clone(h); mygsl_histogram3d_shift(hnew, NUM2DBL(s)); return Data_Wrap_Struct(cgsl_histogram3d, 0, mygsl_histogram3d_free, hnew); } static VALUE rb_gsl_histogram3d_xmax(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_xmax(h)); } static VALUE rb_gsl_histogram3d_xmin(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_xmin(h)); } static VALUE rb_gsl_histogram3d_ymax(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_ymax(h)); } static VALUE rb_gsl_histogram3d_ymin(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_ymin(h)); } static VALUE rb_gsl_histogram3d_zmax(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_zmax(h)); } static VALUE rb_gsl_histogram3d_zmin(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_zmin(h)); } static VALUE rb_gsl_histogram3d_fwrite(VALUE obj, VALUE io) { mygsl_histogram3d *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, mygsl_histogram3d, h); f = rb_gsl_open_writefile(io, &flag); status = mygsl_histogram3d_fwrite(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram3d_fread(VALUE obj, VALUE io) { mygsl_histogram3d *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, mygsl_histogram3d, h); f = rb_gsl_open_readfile(io, &flag); status = mygsl_histogram3d_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram3d_max_val(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_max_val(h)); } static VALUE rb_gsl_histogram3d_min_val(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_min_val(h)); } static VALUE rb_gsl_histogram3d_max_bin(VALUE obj) { mygsl_histogram3d *h; size_t i, j, k; Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_max_bin(h, &i, &j, &k); return rb_ary_new3(3, INT2FIX(i), INT2FIX(j), INT2FIX(k)); } static VALUE rb_gsl_histogram3d_min_bin(VALUE obj) { mygsl_histogram3d *h; size_t i, j, k; Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_min_bin(h, &i, &j, &k); return rb_ary_new3(3, INT2FIX(i), INT2FIX(j), INT2FIX(k)); } static VALUE rb_gsl_histogram3d_sum(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_sum(h)); } static VALUE rb_gsl_histogram3d_xmean(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_xmean(h)); } static VALUE rb_gsl_histogram3d_ymean(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_ymean(h)); } static VALUE rb_gsl_histogram3d_zmean(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_zmean(h)); } static VALUE rb_gsl_histogram3d_xsigma(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_xsigma(h)); } static VALUE rb_gsl_histogram3d_ysigma(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_ysigma(h)); } static VALUE rb_gsl_histogram3d_zsigma(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); return rb_float_new(mygsl_histogram3d_zsigma(h)); } static VALUE rb_gsl_histogram3d_reset(VALUE obj) { mygsl_histogram3d *h; Data_Get_Struct(obj, mygsl_histogram3d, h); mygsl_histogram3d_reset(h); return obj; } static VALUE rb_gsl_histogram3d_oper(VALUE obj, VALUE hh, int (*func)(mygsl_histogram3d *, const mygsl_histogram3d*)) { mygsl_histogram3d *h1, *h2, *hnew; CHECK_HISTOGRAM3D(hh); Data_Get_Struct(obj, mygsl_histogram3d, h1); Data_Get_Struct(hh, mygsl_histogram3d, h2); hnew = mygsl_histogram3d_clone(h1); (*func)(hnew, h2); return Data_Wrap_Struct(cgsl_histogram, 0, mygsl_histogram3d_free, hnew); } static VALUE rb_gsl_histogram3d_add(VALUE obj, VALUE hh) { return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_add); } static VALUE rb_gsl_histogram3d_sub(VALUE obj, VALUE hh) { return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_sub); } static VALUE rb_gsl_histogram3d_mul(VALUE obj, VALUE hh) { return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_mul); } static VALUE rb_gsl_histogram3d_div(VALUE obj, VALUE hh) { return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_div); } static VALUE rb_gsl_histogram3d_add_shift(VALUE obj, VALUE hh) { switch (TYPE(hh)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_gsl_histogram3d_shift(obj, hh); break; default: CHECK_HISTOGRAM3D(hh); return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_add); break; } } static VALUE rb_gsl_histogram3d_sub_shift(VALUE obj, VALUE hh) { switch (TYPE(hh)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_gsl_histogram3d_shift(obj, rb_float_new(-NUM2DBL(hh))); break; default: CHECK_HISTOGRAM3D(hh); return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_sub); break; } } static VALUE rb_gsl_histogram3d_mul_scale(VALUE obj, VALUE hh) { switch (TYPE(hh)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_gsl_histogram3d_scale(obj, hh); break; default: CHECK_HISTOGRAM3D(hh); return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_mul); break; } } static VALUE rb_gsl_histogram3d_div_scale(VALUE obj, VALUE hh) { switch (TYPE(hh)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_gsl_histogram3d_scale(obj, rb_float_new(1.0/NUM2DBL(hh))); break; default: CHECK_HISTOGRAM3D(hh); return rb_gsl_histogram3d_oper(obj, hh, mygsl_histogram3d_div); break; } } void Init_gsl_histogram3d(VALUE module) { cgsl_histogram3d = rb_define_class_under(module, "Histogram3d", cGSL_Object); cgsl_histogram3d_view = rb_define_class_under(cgsl_histogram3d, "View", cgsl_histogram2d); /* rb_define_singleton_method(cgsl_histogram3d, "new", rb_gsl_histogram3d_new, -1);*/ rb_define_singleton_method(cgsl_histogram3d, "alloc", rb_gsl_histogram3d_new, -1); rb_define_singleton_method(cgsl_histogram3d, "memcpy", rb_gsl_histogram3d_memcpy, 2); /******/ rb_define_method(cgsl_histogram3d, "set_ranges", rb_gsl_histogram3d_set_ranges, 3); rb_define_method(cgsl_histogram3d, "set_ranges_uniform", rb_gsl_histogram3d_set_ranges_uniform, -1); rb_define_method(cgsl_histogram3d, "nx", rb_gsl_histogram3d_nx, 0); rb_define_method(cgsl_histogram3d, "ny", rb_gsl_histogram3d_ny, 0); rb_define_method(cgsl_histogram3d, "nz", rb_gsl_histogram3d_nz, 0); rb_define_method(cgsl_histogram3d, "size", rb_gsl_histogram3d_size, 0); rb_define_method(cgsl_histogram3d, "shape", rb_gsl_histogram3d_shape, 0); rb_define_method(cgsl_histogram3d, "xrange", rb_gsl_histogram3d_xrange, 0); rb_define_method(cgsl_histogram3d, "yrange", rb_gsl_histogram3d_yrange, 0); rb_define_method(cgsl_histogram3d, "zrange", rb_gsl_histogram3d_zrange, 0); rb_define_method(cgsl_histogram3d, "bin", rb_gsl_histogram3d_bin, 0); rb_define_method(cgsl_histogram3d, "get", rb_gsl_histogram3d_get, -1); rb_define_alias(cgsl_histogram3d, "[]", "get"); rb_define_method(cgsl_histogram3d, "increment", rb_gsl_histogram3d_increment, -1); rb_define_alias(cgsl_histogram3d, "fill", "increment"); rb_define_alias(cgsl_histogram3d, "accumulate", "increment"); rb_define_method(cgsl_histogram3d, "increment2", rb_gsl_histogram3d_increment2, -1); rb_define_alias(cgsl_histogram3d, "fill2", "increment2"); rb_define_alias(cgsl_histogram3d, "accumulate2", "increment2"); rb_define_method(cgsl_histogram3d, "get_xrange", rb_gsl_histogram3d_get_xrange, 1); rb_define_method(cgsl_histogram3d, "get_yrange", rb_gsl_histogram3d_get_yrange, 1); rb_define_method(cgsl_histogram3d, "get_zrange", rb_gsl_histogram3d_get_zrange, 1); rb_define_method(cgsl_histogram3d, "find", rb_gsl_histogram3d_find, 3); rb_define_method(cgsl_histogram3d, "clone", rb_gsl_histogram3d_clone, 0); rb_define_alias(cgsl_histogram3d, "duplicate", "clone"); rb_define_method(cgsl_histogram3d, "reset", rb_gsl_histogram3d_reset, 0); /*****/ rb_define_method(cgsl_histogram3d, "xyproject", rb_gsl_histogram3d_xyproject, -1); rb_define_method(cgsl_histogram3d, "xzproject", rb_gsl_histogram3d_xzproject, -1); rb_define_method(cgsl_histogram3d, "yzproject", rb_gsl_histogram3d_yzproject, -1); rb_define_method(cgsl_histogram3d, "scale", rb_gsl_histogram3d_scale, 1); rb_define_method(cgsl_histogram3d, "scale!", rb_gsl_histogram3d_scale_bang, 1); rb_define_method(cgsl_histogram3d, "shift", rb_gsl_histogram3d_shift, 1); rb_define_method(cgsl_histogram3d, "shift!", rb_gsl_histogram3d_shift_bang, 1); rb_define_method(cgsl_histogram3d, "xmax", rb_gsl_histogram3d_xmax, 0); rb_define_method(cgsl_histogram3d, "xmin", rb_gsl_histogram3d_xmin, 0); rb_define_method(cgsl_histogram3d, "ymax", rb_gsl_histogram3d_ymax, 0); rb_define_method(cgsl_histogram3d, "ymin", rb_gsl_histogram3d_ymin, 0); rb_define_method(cgsl_histogram3d, "zmax", rb_gsl_histogram3d_zmax, 0); rb_define_method(cgsl_histogram3d, "zmin", rb_gsl_histogram3d_zmin, 0); /*****/ rb_define_method(cgsl_histogram3d, "fwrite", rb_gsl_histogram3d_fwrite, 1); rb_define_method(cgsl_histogram3d, "fread", rb_gsl_histogram3d_fread, 1); rb_define_method(cgsl_histogram3d, "max_val", rb_gsl_histogram3d_max_val, 0); rb_define_method(cgsl_histogram3d, "min_val", rb_gsl_histogram3d_min_val, 0); rb_define_method(cgsl_histogram3d, "max_bin", rb_gsl_histogram3d_max_bin, 0); rb_define_method(cgsl_histogram3d, "min_bin", rb_gsl_histogram3d_min_bin, 0); rb_define_method(cgsl_histogram3d, "sum", rb_gsl_histogram3d_sum, 0); rb_define_alias(cgsl_histogram3d, "integral", "sum"); rb_define_method(cgsl_histogram3d, "xmean", rb_gsl_histogram3d_xmean, 0); rb_define_method(cgsl_histogram3d, "ymean", rb_gsl_histogram3d_ymean, 0); rb_define_method(cgsl_histogram3d, "zmean", rb_gsl_histogram3d_zmean, 0); rb_define_method(cgsl_histogram3d, "xsigma", rb_gsl_histogram3d_xsigma, 0); rb_define_method(cgsl_histogram3d, "ysigma", rb_gsl_histogram3d_ysigma, 0); rb_define_method(cgsl_histogram3d, "zsigma", rb_gsl_histogram3d_zsigma, 0); /*****/ rb_define_method(cgsl_histogram3d, "add", rb_gsl_histogram3d_add, 1); rb_define_method(cgsl_histogram3d, "sub", rb_gsl_histogram3d_sub, 1); rb_define_method(cgsl_histogram3d, "mul", rb_gsl_histogram3d_mul, 1); rb_define_method(cgsl_histogram3d, "div", rb_gsl_histogram3d_div, 1); rb_define_method(cgsl_histogram3d, "+", rb_gsl_histogram3d_add_shift, 1); rb_define_method(cgsl_histogram3d, "-", rb_gsl_histogram3d_sub_shift, 1); rb_define_method(cgsl_histogram3d, "*", rb_gsl_histogram3d_mul_scale, 1); rb_define_method(cgsl_histogram3d, "/", rb_gsl_histogram3d_div_scale, 1); } gsl-1.15.3/ext/alf.c0000644000175000017500000001511112220252463013447 0ustar boutilboutil/* * Ruby interface for ALF, a library to calculate associated Legendre functions by Patrick Alken * Based on ALF-0.1 */ #ifdef HAVE_ALF_ALF_H #include "rb_gsl.h" static VALUE cWspace; static VALUE rb_alf_alloc(VALUE klass, VALUE lmax) { alf_workspace *w = NULL; w = alf_alloc(FIX2INT(lmax)); return Data_Wrap_Struct(cWspace, 0, alf_free, w); } static VALUE rb_alf_params(VALUE obj, VALUE csphase, VALUE cnorm, VALUE norm) { alf_workspace *w; int ret; Data_Get_Struct(obj, alf_workspace, w); ret = alf_params(FIX2INT(csphase), FIX2INT(cnorm), (alf_norm_t) FIX2INT(norm), w); return INT2FIX(ret); } static void define_constants(VALUE klass) { rb_define_const(klass, "NORM_NONE", INT2FIX((int) ALF_NORM_NONE)); rb_define_const(klass, "NORM_SPHARM", INT2FIX((int) ALF_NORM_SPHARM)); rb_define_const(klass, "NORM_ORTHO", INT2FIX((int) ALF_NORM_ORTHO)); rb_define_const(klass, "NORM_SCHMIDT", INT2FIX((int) ALF_NORM_SCHMIDT)); } /** * arguments: * - Plm_array(x) : lmax = w->lmax, A new vector is created * - Plm_array(x, result) : lmax = w->lmax, the given vector is used * - Plm_array(lmax, x) : A new vector is created * - Plm_array(lmax, x, result) : Same as C Plm_array() * - Plm_array(x, result, deriv) : lmax = w->lmax, calcurate Plm_deriv_array(lmax, x, result, deriv) * - Plm_array(lmax, x, result, deriv) : Same as C alf_Plm_deriv_array */ static VALUE rb_alf_Plm_array(int argc, VALUE *argv, VALUE obj) { alf_workspace *w = NULL; gsl_vector *res = NULL, *deriv = NULL; int lmax; double x; VALUE ret; Data_Get_Struct(obj, alf_workspace, w); switch (argc) { case 1: x = NUM2DBL(argv[0]); lmax = w->lmax; res = gsl_vector_alloc(alf_array_size(lmax)); ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res); break; case 2: // Plm_array(x, result) or Plm_array(lmax, x) if (VECTOR_P(argv[1])) { x = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, res); lmax = w->lmax; if (res->size < alf_array_size(lmax)) { rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size, (int) alf_array_size(lmax)); } ret = argv[1]; } else { lmax = FIX2INT(argv[0]); x = NUM2DBL(argv[1]); res = gsl_vector_alloc(alf_array_size(lmax)); ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res); } break; case 3: // Plm_array(lmax, x, result) or Plm_array(x, result, deriv) if (VECTOR_P(argv[1])) { CHECK_VECTOR(argv[2]); lmax = w->lmax; x = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, res); Data_Get_Struct(argv[2], gsl_vector, deriv); ret = argv[1]; } else { lmax = FIX2INT(argv[0]); x = NUM2DBL(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, res); if (res->size < alf_array_size(lmax)) { rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size, (int) alf_array_size(lmax)); } ret = argv[2]; } break; case 4: CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[3]) lmax = FIX2INT(argv[0]); x = NUM2DBL(argv[1]); Data_Get_Struct(argv[2], gsl_vector, res); Data_Get_Struct(argv[3], gsl_vector, deriv); ret = argv[2]; break; default: rb_raise(rb_eArgError, "Wrong number of argumentso (%d for 1-3)\n", argc); } if (argc == 4 && deriv != NULL) alf_Plm_deriv_array(lmax, x, res->data, deriv->data, w); else alf_Plm_array(lmax, x, res->data, w); return ret; } /** * arguments: * - Plm_deriv_array(x) : lmax = w->lmax, two new vectors are created and returned as an array * - Plm_array(lmax, x) : Two new vectors are created and returned as an array * - Plm_array(lmax, x, result, deriv) : Same as C alf_Plm_deriv_array() */ static VALUE rb_alf_Plm_deriv_array(int argc, VALUE *argv, VALUE obj) { alf_workspace *w = NULL; gsl_vector *res = NULL, *deriv = NULL; int lmax; double x; VALUE ret1, ret2, ary; Data_Get_Struct(obj, alf_workspace, w); switch (argc) { case 1: x = NUM2DBL(argv[0]); lmax = w->lmax; res = gsl_vector_alloc(alf_array_size(lmax)); deriv = gsl_vector_alloc(alf_array_size(lmax)); ret1 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res); ret2 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, deriv); break; case 2: lmax = FIX2INT(argv[1]); x = NUM2DBL(argv[1]); res = gsl_vector_alloc(alf_array_size(lmax)); deriv = gsl_vector_alloc(alf_array_size(lmax)); ret1 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res); ret2 = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, deriv); break; case 3: CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); ret1 = argv[1]; ret2 = argv[2]; lmax = w->lmax; x = NUM2DBL(argv[0]); break; case 4: lmax = FIX2INT(argv[0]); x = NUM2DBL(argv[1]); CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[3]); Data_Get_Struct(argv[2], gsl_vector, res); Data_Get_Struct(argv[3], gsl_vector, deriv); if (res->size < alf_array_size(lmax)) { rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size, (int) alf_array_size(lmax)); } if (deriv->size < alf_array_size(lmax)) { rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size, (int) alf_array_size(lmax)); } ret1 = argv[2]; ret2 = argv[3]; break; default: rb_raise(rb_eArgError, "Wrong number of argumentso (%d for 1-4)\n", argc); } alf_Plm_deriv_array(lmax, x, res->data, deriv->data, w); ary = rb_ary_new2(2); rb_ary_store(ary, 0, ret1); rb_ary_store(ary, 1, ret2); return ary; } static VALUE rb_alf_array_size(VALUE module, VALUE lmax) { return INT2FIX(alf_array_size(FIX2INT(lmax))); } static VALUE rb_alf_array_index(VALUE module, VALUE l, VALUE m) { return INT2FIX(alf_array_index(FIX2INT(l), FIX2INT(m))); } void Init_alf(VALUE module) { VALUE mALF; mALF = rb_define_module_under(module, "ALF"); cWspace = rb_define_class_under(mALF, "Workspace", cGSL_Object); rb_define_singleton_method(cWspace, "alloc", rb_alf_alloc, 1); rb_define_singleton_method(mALF, "alloc", rb_alf_alloc, 1); rb_define_module_function(module, "alf_alloc", rb_alf_alloc, 1); rb_define_method(cWspace, "params", rb_alf_params, 3); rb_define_method(cWspace, "Plm_array", rb_alf_Plm_array, -1); rb_define_method(cWspace, "Plm_deriv_array", rb_alf_Plm_deriv_array, -1); rb_define_module_function(mALF, "array_size", rb_alf_array_size, 1); rb_define_module_function(mALF, "array_index", rb_alf_array_index, 2); define_constants(mALF); } #endif gsl-1.15.3/ext/dirac.c0000644000175000017500000003053712220252463014000 0ustar boutilboutil#include "rb_gsl_dirac.h" static VALUE cgsl_matrix_complex_const; static VALUE cPauli; static VALUE cAlpha; static VALUE cGamma; static VALUE cLambda; static gsl_matrix_complex *Pauli[3]; static gsl_matrix_complex *Alpha[3]; static gsl_matrix_complex *Beta; static gsl_matrix_complex *Gamma[5]; static gsl_matrix_complex *Eye2, *Eye4; static gsl_matrix_complex *IEye2, *IEye4; static gsl_matrix_complex *Lambda[8]; static VALUE VPauli[3]; static VALUE VAlpha[3]; static VALUE VGamma[5]; static VALUE VEye2, VEye4, VIEye2, VIEye4; static VALUE VLambda[8]; static void Init_gsl_dirac_const(VALUE module); static void Init_gsl_dirac_common(VALUE module); static void Init_gsl_dirac_test(VALUE module); static VALUE rb_dirac_refuse_set(int argc, VALUE *argv, VALUE obj) { rb_raise(rb_eRuntimeError, "Cannot modify this object."); } static VALUE rb_dirac_commute(VALUE obj, VALUE mm1, VALUE mm2) { gsl_matrix_complex *m1, *m2; gsl_matrix_complex *mnew1, *mnew2; CHECK_MATRIX_COMPLEX(mm1); CHECK_MATRIX_COMPLEX(mm2); Data_Get_Struct(mm1, gsl_matrix_complex, m1); Data_Get_Struct(mm2, gsl_matrix_complex, m2); mnew1 = gsl_matrix_complex_alloc(m1->size1, m1->size2); mnew2 = gsl_matrix_complex_alloc(m1->size1, m1->size2); gsl_matrix_complex_mul(mnew1, m1, m2); gsl_matrix_complex_mul(mnew2, m2, m1); gsl_matrix_complex_sub(mnew1, mnew2); gsl_matrix_complex_free(mnew2); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew1); } static VALUE rb_dirac_anticommute(VALUE obj, VALUE mm1, VALUE mm2) { gsl_matrix_complex *m1, *m2; gsl_matrix_complex *mnew1, *mnew2; CHECK_MATRIX_COMPLEX(mm1); CHECK_MATRIX_COMPLEX(mm2); Data_Get_Struct(mm1, gsl_matrix_complex, m1); Data_Get_Struct(mm2, gsl_matrix_complex, m2); mnew1 = gsl_matrix_complex_alloc(m1->size1, m1->size2); mnew2 = gsl_matrix_complex_alloc(m1->size1, m1->size2); gsl_matrix_complex_mul(mnew1, m1, m2); gsl_matrix_complex_mul(mnew2, m2, m1); gsl_matrix_complex_add(mnew1, mnew2); gsl_matrix_complex_free(mnew2); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew1); } static void Init_gsl_dirac_common(VALUE module) { /* VALUE cBeta;*/ rb_define_singleton_method(module, "commute", rb_dirac_commute, 2); rb_define_singleton_method(module, "anticommute", rb_dirac_anticommute, 2); cgsl_matrix_complex_const = rb_define_class_under(module, "Const", cgsl_matrix_complex); rb_define_method(cgsl_matrix_complex_const, "set", rb_dirac_refuse_set, -1); cPauli = rb_define_class_under(module, "Pauli", cgsl_matrix_complex_const); cAlpha = rb_define_class_under(module, "Alpha", cgsl_matrix_complex_const); /* cBeta = rb_define_class_under(module, "BetaMatrix", cgsl_matrix_complex_const);*/ cGamma = rb_define_class_under(module, "Gamma", cgsl_matrix_complex_const); cLambda = rb_define_class_under(module, "Lambda", cgsl_matrix_complex_const); } static void define_eye(VALUE module) { gsl_complex z; Eye2 = gsl_matrix_complex_calloc(2, 2); VEye2 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, gsl_matrix_complex_free, Eye2); z.dat[0] = 1; z.dat[1] = 0; gsl_matrix_complex_set(Eye2, 0, 0, z); gsl_matrix_complex_set(Eye2, 1, 1, z); rb_define_const(module, "Eye2", VEye2); Eye4 = gsl_matrix_complex_calloc(4, 4); VEye4 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, gsl_matrix_complex_free, Eye4); z.dat[0] = 1; z.dat[1] = 0; gsl_matrix_complex_set(Eye4, 0, 0, z); gsl_matrix_complex_set(Eye4, 1, 1, z); gsl_matrix_complex_set(Eye4, 2, 2, z); gsl_matrix_complex_set(Eye4, 3, 3, z); rb_define_const(module, "Eye4", VEye4); IEye2 = gsl_matrix_complex_calloc(2, 2); VIEye2 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, gsl_matrix_complex_free, IEye2); z.dat[0] = 0; z.dat[1] = 1; gsl_matrix_complex_set(IEye2, 0, 0, z); gsl_matrix_complex_set(IEye2, 1, 1, z); rb_define_const(module, "IEye2", VIEye2); IEye4 = gsl_matrix_complex_calloc(4, 4); VIEye4 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, gsl_matrix_complex_free, IEye4); gsl_matrix_complex_set(IEye4, 0, 0, z); gsl_matrix_complex_set(IEye4, 1, 1, z); gsl_matrix_complex_set(IEye4, 2, 2, z); gsl_matrix_complex_set(IEye4, 3, 3, z); rb_define_const(module, "IEye4", VIEye4); } static void define_pauli(VALUE module) { gsl_complex z; Pauli[0] = gsl_matrix_complex_calloc(2, 2); VPauli[0] = Data_Wrap_Struct(cPauli, 0, gsl_matrix_complex_free, Pauli[0]); z.dat[0] = 1; z.dat[1] = 0; gsl_matrix_complex_set(Pauli[0], 0, 1, z); gsl_matrix_complex_set(Pauli[0], 1, 0, z); rb_define_const(module, "Pauli1", VPauli[0]); Pauli[1] = gsl_matrix_complex_calloc(2, 2); VPauli[1] = Data_Wrap_Struct(cPauli, 0, gsl_matrix_complex_free, Pauli[1]); z.dat[0] = 0; z.dat[1] = -1; gsl_matrix_complex_set(Pauli[1], 0, 1, z); z.dat[0] = 0; z.dat[1] = 1; gsl_matrix_complex_set(Pauli[1], 1, 0, z); rb_define_const(module, "Pauli2", VPauli[1]); Pauli[2] = gsl_matrix_complex_calloc(2, 2); VPauli[2] = Data_Wrap_Struct(cPauli, 0, gsl_matrix_complex_free, Pauli[2]); z.dat[0] = 1; z.dat[1] = 0; gsl_matrix_complex_set(Pauli[2], 0, 0, z); z.dat[0] = -1; z.dat[1] = 0; gsl_matrix_complex_set(Pauli[2], 1, 1, z); rb_define_const(module, "Pauli3", VPauli[2]); } static void define_beta(VALUE module) { gsl_complex z; Beta = gsl_matrix_complex_calloc(4, 4); VGamma[0] = Data_Wrap_Struct(cGamma, 0, gsl_matrix_complex_free, Beta); z.dat[0] = 1; z.dat[1] = 0; gsl_matrix_complex_set(Beta, 0, 0, z); gsl_matrix_complex_set(Beta, 1, 1, z); z.dat[0] = -1; z.dat[1] = 0; gsl_matrix_complex_set(Beta, 2, 2, z); gsl_matrix_complex_set(Beta, 3, 3, z); rb_define_const(module, "Beta", VGamma[0]); rb_define_const(module, "Gamma0", VGamma[0]); } static void define_alpha(VALUE module) { size_t i, j, k; char name[7]; for (i = 0; i < 3; i++) { Alpha[i] = gsl_matrix_complex_calloc(4, 4); for (j = 2; j < 4; j++) { for (k = 0; k < 2; k++) { gsl_matrix_complex_set(Alpha[i], j, k, gsl_matrix_complex_get(Pauli[i], j-2, k)); } } for (j = 0; j < 2; j++) { for (k = 2; k < 4; k++) { gsl_matrix_complex_set(Alpha[i], j, k, gsl_matrix_complex_get(Pauli[i], j, k-2)); } } VAlpha[i] = Data_Wrap_Struct(cAlpha, 0, gsl_matrix_complex_free, Alpha[i]); sprintf(name, "Alpha%d", (int) i+1); rb_define_const(module, name, VAlpha[i]); } } static void define_gamma(VALUE module) { size_t i; char name[7]; gsl_complex z; for (i = 1; i <= 3; i++) { Gamma[i] = gsl_matrix_complex_calloc(4, 4); gsl_matrix_complex_mul(Gamma[i], Beta, Alpha[i-1]); VGamma[i] = Data_Wrap_Struct(cGamma, 0, gsl_matrix_complex_free, Gamma[i]); sprintf(name, "Gamma%d", (int) i); rb_define_const(module, name, VGamma[i]); } Gamma[4] = gsl_matrix_complex_calloc(4, 4); z.dat[0] = 1.0; z.dat[1] = 0.0; gsl_matrix_complex_set(Gamma[4], 0, 2, z); gsl_matrix_complex_set(Gamma[4], 1, 3, z); gsl_matrix_complex_set(Gamma[4], 2, 0, z); gsl_matrix_complex_set(Gamma[4], 3, 1, z); VGamma[4] = Data_Wrap_Struct(cGamma, 0, gsl_matrix_complex_free, Gamma[4]); rb_define_const(module, "Gamma5", VGamma[4]); } static void define_lambda(VALUE module) { gsl_complex z1, zm1, zi, zmi; size_t i; char name[8]; double sqrt3 = sqrt(3.0); z1.dat[0] = 1; z1.dat[1] = 0; zm1.dat[0] = -1; zm1.dat[1] = 0; zi.dat[0] = 0; zi.dat[1] = 1; zmi.dat[0] = 0; zmi.dat[1] = -1; for (i = 0; i < 8; i++) { Lambda[i] = gsl_matrix_complex_calloc(3, 3); VLambda[i] = Data_Wrap_Struct(cLambda, 0, gsl_matrix_complex_free, Lambda[i]); sprintf(name, "Lambda%d", (int) i+1); rb_define_const(module, name, VLambda[i]); } gsl_matrix_complex_set(Lambda[0], 0, 1, z1); gsl_matrix_complex_set(Lambda[0], 1, 0, z1); gsl_matrix_complex_set(Lambda[1], 0, 1, zmi); gsl_matrix_complex_set(Lambda[1], 1, 0, zi); gsl_matrix_complex_set(Lambda[2], 0, 0, z1); gsl_matrix_complex_set(Lambda[2], 1, 1, zm1); gsl_matrix_complex_set(Lambda[3], 0, 2, z1); gsl_matrix_complex_set(Lambda[3], 2, 0, z1); gsl_matrix_complex_set(Lambda[4], 0, 2, zmi); gsl_matrix_complex_set(Lambda[4], 2, 0, zi); gsl_matrix_complex_set(Lambda[5], 1, 2, z1); gsl_matrix_complex_set(Lambda[5], 2, 1, z1); gsl_matrix_complex_set(Lambda[6], 1, 2, zmi); gsl_matrix_complex_set(Lambda[6], 2, 1, zi); gsl_matrix_complex_set(Lambda[7], 0, 0, gsl_complex_mul_real(z1, 1.0/sqrt3)); gsl_matrix_complex_set(Lambda[7], 1, 1, gsl_complex_mul_real(z1, 1.0/sqrt3)); gsl_matrix_complex_set(Lambda[7], 2, 2, gsl_complex_mul_real(z1, -2.0/sqrt3)); } static void Init_gsl_dirac_const(VALUE module) { define_eye(module); define_pauli(module); define_beta(module); define_alpha(module); define_gamma(module); define_lambda(module); } static int matrix_is_equal(gsl_matrix_complex *m1, gsl_matrix_complex *m2, gsl_complex *c) { gsl_complex a, b, ab, absave; double eps = 1e-6; size_t i, j; absave.dat[0] = 99999; absave.dat[1] = 99999; if (m1->size1 != m2->size1 || m1->size2 != m2->size2) return 0; for (i = 0; i < m1->size1; i++) { for (j = 0; j < m1->size2; j++) { a = gsl_matrix_complex_get(m1, i, j); b = gsl_matrix_complex_get(m2, i, j); if (!gsl_fcmp(gsl_complex_abs(b), 0.0, eps)) continue; ab = gsl_complex_div(a, b); if (!gsl_fcmp(gsl_complex_abs(ab), 0.0, eps)) continue; if ((int) absave.dat[0] == 99999) absave = ab; if (gsl_fcmp(ab.dat[0], absave.dat[0], eps)) return 0; if (gsl_fcmp(ab.dat[1], absave.dat[1], eps)) return 0; } } if ((int) absave.dat[0] == 99999) return 0; *c = ab; return 1; } static VALUE rb_Dirac_matrix_is_equal(int argc, VALUE *argv, VALUE obj) { gsl_complex ztmp, *z; gsl_matrix_complex *m1, *m2; VALUE vz; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, m1); Data_Get_Struct(argv[1], gsl_matrix_complex, m2); if (matrix_is_equal(m1, m2, &ztmp)) { vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, z); *z = ztmp; return vz; } else { return Qfalse; } break; default: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(obj, gsl_matrix_complex, m1); Data_Get_Struct(argv[0], gsl_matrix_complex, m2); if (matrix_is_equal(m1, m2, &ztmp)) { vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, z); *z = ztmp; return vz; } else { return Qfalse; } break; } } #define NUM 20 static VALUE rb_Dirac_matrix_whoami(int argc, VALUE *argv, VALUE obj) { VALUE array[NUM] = {VPauli[0], VPauli[1], VPauli[2], VGamma[0], VGamma[1], VGamma[2], VGamma[3], VGamma[4], VEye2, VEye4, VIEye2, VIEye4, VLambda[0], VLambda[1], VLambda[2], VLambda[3], VLambda[4], VLambda[5], VLambda[6], VLambda[7]}; char *name[NUM] = {"Pauli1", "Pauli2", "Pauli3", "Gamma0", "Gamma1", "Gamma2", "Gamma3", "Gamma5", "Eye2", "Eye4", "IEye2", "IEye4", "Lambda1", "Lambda2", "Lambda3", "Lambda4", "Lambda5", "Lambda6", "Lambda7", "Lambda8"}; gsl_matrix_complex *m1, *m2; VALUE vz; gsl_complex ztmp, *z; size_t i; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "matrix not given"); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m1); break; default: Data_Get_Struct(obj, gsl_matrix_complex, m1); break; } for (i = 0; i < NUM; i++) { Data_Get_Struct(array[i], gsl_matrix_complex, m2); if(matrix_is_equal(m1, m2, &ztmp)) { vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, z); *z = ztmp; return rb_ary_new3(3, array[i], rb_str_new2(name[i]), vz); } } return Qfalse; } #undef NUM static void Init_gsl_dirac_test(VALUE module) { rb_define_singleton_method(module, "is_equal?", rb_Dirac_matrix_is_equal, -1); rb_define_method(cgsl_matrix_complex, "is_equal?", rb_Dirac_matrix_is_equal, -1); rb_define_singleton_method(module, "whatisthis", rb_Dirac_matrix_whoami, -1); rb_define_method(cgsl_matrix_complex, "whoami", rb_Dirac_matrix_whoami, -1); } void Init_gsl_dirac(VALUE module) { VALUE mDirac; mDirac = rb_define_module_under(module, "Dirac"); Init_gsl_dirac_common(mDirac); Init_gsl_dirac_const(mDirac); Init_gsl_dirac_test(mDirac); } gsl-1.15.3/ext/error.c0000644000175000017500000002011412220252463014035 0ustar boutilboutil/* error.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include #include "rb_gsl_array.h" #include "rb_gsl_common.h" #include "rb_gsl_function.h" static VALUE eHandler; static VALUE cgsl_error[35]; static VALUE *pgsl_error; static void Init_rb_gsl_define_GSL_CONST(VALUE module); void rb_gsl_error_handler(const char *reason, const char *file, int line, int gsl_errno); static void rb_gsl_my_error_handler(const char *reason, const char *file, int line, int gsl_errno); void rb_gsl_error_handler(const char *reason, const char *file, int line, int gsl_errno) { const char *emessage = gsl_strerror(gsl_errno); rb_raise(pgsl_error[gsl_errno], "Ruby/GSL error code %d, %s (file %s, line %d), %s", gsl_errno, reason, file, line, emessage); } static void rb_gsl_my_error_handler(const char *reason, const char *file, int line, int gsl_errno) { VALUE vreason, vfile; VALUE vline, verrno; vreason = rb_str_new2(reason); vfile = rb_str_new2(file); vline = INT2FIX(line); verrno = INT2FIX(gsl_errno); rb_funcall(eHandler, RBGSL_ID_call, 4, vreason, vfile, vline, verrno); } static VALUE rb_gsl_set_error_handler(int argc, VALUE *argv, VALUE module) { if (rb_block_given_p()) { eHandler = RB_GSL_MAKE_PROC; gsl_set_error_handler(&rb_gsl_my_error_handler); return Qtrue; } switch (argc) { case 0: gsl_set_error_handler(&rb_gsl_error_handler); return Qtrue; break; case 1: CHECK_PROC(argv[0]); eHandler = argv[0]; gsl_set_error_handler(&rb_gsl_my_error_handler); return Qtrue; break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1 Proc)", argc); break; } } static VALUE rb_gsl_set_default_error_handler(VALUE module) { gsl_set_error_handler(&rb_gsl_error_handler); return Qtrue; } static void rb_gsl_define_exceptions(VALUE module) { VALUE mgsl_error; mgsl_error = rb_define_module_under(module, "ERROR"); pgsl_error = &cgsl_error[2]; pgsl_error[-2] = rb_define_class_under(mgsl_error, "CONTINUE", rb_cFixnum); pgsl_error[-1] = rb_define_class_under(mgsl_error, "FAILURE", rb_eRuntimeError); pgsl_error[0] = rb_define_class_under(mgsl_error, "SUCCESS", rb_cFixnum); pgsl_error[1] = rb_define_class_under(mgsl_error, "EDOM", rb_eRangeError); pgsl_error[2] = rb_define_class_under(mgsl_error, "ERANGE", rb_eRangeError); pgsl_error[3] = rb_define_class_under(mgsl_error, "EFAULT", rb_eRuntimeError); pgsl_error[4] = rb_define_class_under(mgsl_error, "EINVAL", rb_eIndexError); pgsl_error[5] = rb_define_class_under(mgsl_error, "EFAILED", rb_eRuntimeError); pgsl_error[6] = rb_define_class_under(mgsl_error, "EFACTOR", rb_eRuntimeError); pgsl_error[7] = rb_define_class_under(mgsl_error, "ESANITY", rb_eRuntimeError); pgsl_error[8] = rb_define_class_under(mgsl_error, "ENOMEM", rb_eNoMemError); pgsl_error[9] = rb_define_class_under(mgsl_error, "EBADFUNC", rb_eRuntimeError); pgsl_error[10] = rb_define_class_under(mgsl_error, "ERUNAWAY", rb_eRuntimeError); pgsl_error[11] = rb_define_class_under(mgsl_error, "EMAXITER", rb_eRuntimeError); pgsl_error[12] = rb_define_class_under(mgsl_error, "EZERODIV", rb_eZeroDivError); pgsl_error[13] = rb_define_class_under(mgsl_error, "EBADTOL", rb_eRuntimeError); pgsl_error[14] = rb_define_class_under(mgsl_error, "ETOL", rb_eRuntimeError); pgsl_error[15] = rb_define_class_under(mgsl_error, "EUNDRFLW", rb_eRangeError); pgsl_error[16] = rb_define_class_under(mgsl_error, "EOVRFLW", rb_eRangeError); pgsl_error[17] = rb_define_class_under(mgsl_error, "ELOSS", rb_eRuntimeError); pgsl_error[18] = rb_define_class_under(mgsl_error, "EROUND", rb_eRuntimeError); pgsl_error[19] = rb_define_class_under(mgsl_error, "EBADLEN", rb_eIndexError); pgsl_error[20] = rb_define_class_under(mgsl_error, "ENOTSQR", rb_eRuntimeError); pgsl_error[21] = rb_define_class_under(mgsl_error, "ESING", rb_eRuntimeError); pgsl_error[22] = rb_define_class_under(mgsl_error, "EDIVERGE", rb_eRuntimeError); pgsl_error[23] = rb_define_class_under(mgsl_error, "EUNSUP", rb_eRuntimeError); pgsl_error[24] = rb_define_class_under(mgsl_error, "EUNIMPL", rb_eNotImpError); pgsl_error[25] = rb_define_class_under(mgsl_error, "ECACHE", rb_eRuntimeError); pgsl_error[26] = rb_define_class_under(mgsl_error, "ETABLE", rb_eRuntimeError); pgsl_error[27] = rb_define_class_under(mgsl_error, "ENOPROG", rb_eRuntimeError); pgsl_error[28] = rb_define_class_under(mgsl_error, "ENOPROGJ", rb_eRuntimeError); pgsl_error[29] = rb_define_class_under(mgsl_error, "ETOLF", rb_eRuntimeError); pgsl_error[30] = rb_define_class_under(mgsl_error, "ETOLX", rb_eRuntimeError); pgsl_error[31] = rb_define_class_under(mgsl_error, "ETOLG", rb_eRuntimeError); pgsl_error[32] = rb_define_class_under(mgsl_error, "EOF", rb_eEOFError); } static void Init_rb_gsl_define_GSL_CONST(VALUE module) { rb_define_const(module, "SUCCESS", INT2FIX(GSL_SUCCESS)); rb_define_const(module, "FAILURE", INT2FIX(GSL_FAILURE)); rb_define_const(module, "CONTINUE", INT2FIX(GSL_CONTINUE)); rb_define_const(module, "EDOM", INT2FIX(GSL_EDOM)); rb_define_const(module, "ERANGE", INT2FIX(GSL_ERANGE)); rb_define_const(module, "EFAULT", INT2FIX(GSL_EFAULT)); rb_define_const(module, "EINVAL", INT2FIX(GSL_EINVAL)); rb_define_const(module, "EFAILED", INT2FIX(GSL_EFAILED)); rb_define_const(module, "EFACTOR", INT2FIX(GSL_EFACTOR)); rb_define_const(module, "ESANITY", INT2FIX(GSL_ESANITY)); rb_define_const(module, "ENOMEM", INT2FIX(GSL_ENOMEM)); rb_define_const(module, "EBADFUNC", INT2FIX(GSL_EBADFUNC)); rb_define_const(module, "ERUNAWAY", INT2FIX(GSL_ERUNAWAY)); rb_define_const(module, "EMAXITER", INT2FIX(GSL_EMAXITER)); rb_define_const(module, "EZERODIV", INT2FIX(GSL_EZERODIV)); rb_define_const(module, "EBADTOL", INT2FIX(GSL_EBADTOL)); rb_define_const(module, "ETOL", INT2FIX(GSL_ETOL)); rb_define_const(module, "EUNDRFLW", INT2FIX(GSL_EUNDRFLW)); rb_define_const(module, "EOVRFLW", INT2FIX(GSL_EOVRFLW)); rb_define_const(module, "ELOSS", INT2FIX(GSL_ELOSS)); rb_define_const(module, "EROUND", INT2FIX(GSL_EROUND)); rb_define_const(module, "EBADLEN", INT2FIX(GSL_EBADLEN)); rb_define_const(module, "ENOTSQR", INT2FIX(GSL_ENOTSQR)); rb_define_const(module, "ESING", INT2FIX(GSL_ESING)); rb_define_const(module, "EDIVERGE", INT2FIX(GSL_EDIVERGE)); rb_define_const(module, "EUNSUP", INT2FIX(GSL_EUNSUP)); rb_define_const(module, "EUNIMPL", INT2FIX(GSL_EUNIMPL)); rb_define_const(module, "ECACHE", INT2FIX(GSL_ECACHE)); rb_define_const(module, "ETABLE", INT2FIX(GSL_ETABLE)); rb_define_const(module, "ENOPROG", INT2FIX(GSL_ENOPROG)); rb_define_const(module, "ENOPROGJ", INT2FIX(GSL_ENOPROGJ)); rb_define_const(module, "ETOLF", INT2FIX(GSL_ETOLF)); rb_define_const(module, "ETOLX", INT2FIX(GSL_ETOLX)); rb_define_const(module, "ETOLG", INT2FIX(GSL_ETOLG)); rb_define_const(module, "EOF", INT2FIX(GSL_EOF)); } static VALUE rb_gsl_set_error_handler_off(VALUE module) { gsl_set_error_handler_off(); return Qtrue; } static void define_module_functions(VALUE module); static VALUE rb_gsl_strerror(VALUE obj, VALUE errn); static void define_module_functions(VALUE module) { rb_define_module_function(module, "set_error_handler_off", rb_gsl_set_error_handler_off, 0); rb_define_module_function(module, "strerror", rb_gsl_strerror, 1); rb_define_module_function(module, "set_error_handler", rb_gsl_set_error_handler, -1); rb_define_module_function(module, "set_default_error_handler", rb_gsl_set_default_error_handler, 0); } static VALUE rb_gsl_strerror(VALUE obj, VALUE errn) { int gsl_errno = FIX2INT(errn); return rb_str_new2(gsl_strerror(gsl_errno)); } void Init_gsl_error(VALUE module) { Init_rb_gsl_define_GSL_CONST(module); gsl_set_error_handler(&rb_gsl_error_handler); define_module_functions(module); rb_gsl_define_exceptions(module); } gsl-1.15.3/ext/gsl_narray.c0000644000175000017500000006323012220252463015053 0ustar boutilboutil/* narray.c Written by Yoshiki Tsunesada Dec/2001 Modified by Seiya Nishizawa 14/Apr/2004 */ #include "rb_gsl_config.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_array.h" #include "narray.h" #include "rb_gsl_with_narray.h" static VALUE rb_gsl_na_to_gsl_matrix_method(VALUE nna); static VALUE rb_gsl_na_to_gsl_matrix_int_method(VALUE nna); static VALUE rb_gsl_na_to_gsl_vector_int_method(VALUE na); static VALUE rb_gsl_vector_int_to_na(VALUE obj); static VALUE rb_gsl_na_to_gsl_vector_int(VALUE obj, VALUE na); /* GSL::Vector -> NArray */ static VALUE rb_gsl_vector_to_narray(VALUE obj, VALUE klass) { gsl_vector *v = NULL; VALUE nary; int shape[1]; Data_Get_Struct(obj, gsl_vector, v); shape[0] = v->size; nary = na_make_object(NA_DFLOAT, 1, shape, klass); if (v->stride == 1) { memcpy(NA_PTR_TYPE(nary,double*), v->data, shape[0]*sizeof(double)); } else { int i; for(i=0; i < v->size; i++) { (NA_PTR_TYPE(nary,double*))[i] = gsl_vector_get(v, i); } } return nary; } static VALUE rb_gsl_vector_complex_to_narray(VALUE obj, VALUE klass) { gsl_vector_complex *v = NULL; VALUE nary; int shape[1]; Data_Get_Struct(obj, gsl_vector_complex, v); shape[0] = v->size; nary = na_make_object(NA_DCOMPLEX, 1, shape, klass); if (v->stride == 1) { memcpy(NA_PTR_TYPE(nary,double*), v->data, shape[0]*2*sizeof(double)); } else { int i; for(i=0; i < 2*v->size; i++) { (NA_PTR_TYPE(nary,gsl_complex*))[i] = gsl_vector_complex_get(v, i); } } return nary; } static VALUE rb_gsl_vector_to_na(VALUE obj) { VALUE na = Qnil; if(VECTOR_P(obj)) na = rb_gsl_vector_to_narray(obj, cNArray); else if(VECTOR_COMPLEX_P(obj)) na = rb_gsl_vector_complex_to_narray(obj, cNArray); else rb_raise(rb_eRuntimeError, "unexpected type '%s'", rb_obj_classname(obj)); return na; } static VALUE rb_gsl_vector_complex_to_na(VALUE obj) { return rb_gsl_vector_complex_to_narray(obj, cNArray); } static VALUE rb_gsl_vector_to_nvector(VALUE obj) { return rb_gsl_vector_to_narray(obj, cNVector); } static VALUE rb_gsl_vector_complex_to_nvector(VALUE obj) { return rb_gsl_vector_complex_to_narray(obj, cNVector); } /* GSL::Vector -> NArray view */ static struct NARRAY* rb_gsl_na_view_alloc(int rank, int total, int type) { struct NARRAY *na; na = (struct NARRAY*) malloc(sizeof(struct NARRAY)); na->rank = rank; na->total = total; na->type = type; // TODO Set na->ref to a one element NArray of type NAObject that contains // the GSL::Vector being referenced. na->ref = Qtrue; /* to initialize */ na->shape = (int *) malloc(sizeof(int)*rank); return na; } static void rb_gsl_na_view_free(struct NARRAY *na) { free((int *) na->shape); free((struct NARRAY *) na); } static VALUE rb_gsl_vector_to_narray_ref(VALUE obj, VALUE klass) { gsl_vector *v = NULL; gsl_vector_complex *vc = NULL; gsl_vector_int *vi = NULL; VALUE nary; struct NARRAY *na; if (VECTOR_P(obj)) { Data_Get_Struct(obj, gsl_vector, v); if (v->stride != 1) { rb_raise(rb_eRuntimeError, "Cannot make a reference obj: stride!=1"); } na = rb_gsl_na_view_alloc(1, v->size, NA_DFLOAT); na->shape[0] = v->size; na->ptr = (char *) v->data; } else if (VECTOR_INT_P(obj)) { Data_Get_Struct(obj, gsl_vector_int, vi); if (vi->stride != 1) { rb_raise(rb_eRuntimeError, "Cannot make a reference obj: stride!=1"); } na = rb_gsl_na_view_alloc(1, vi->size, NA_LINT); na->shape[0] = vi->size; na->ptr = (char *) vi->data; } else if (VECTOR_COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_vector_complex, vc); if (vc->stride != 1) { rb_raise(rb_eRuntimeError, "Cannot make a reference obj: stride!=1"); } na = rb_gsl_na_view_alloc(1, vc->size, NA_DCOMPLEX); na->shape[0] = vc->size; na->ptr = (char *) vc->data; } else { rb_raise(rb_eRuntimeError, "cannot convert %s to NArray reference object", rb_obj_classname(obj)); } nary = Data_Wrap_Struct(klass, 0, rb_gsl_na_view_free, na); return nary; } static VALUE rb_gsl_vector_to_na_ref(VALUE obj) { return rb_gsl_vector_to_narray_ref(obj, cNArray); } static VALUE rb_gsl_vector_to_nvector_ref(VALUE obj) { return rb_gsl_vector_to_narray_ref(obj, cNVector); } static VALUE rb_gsl_vector_int_to_narray(VALUE obj, VALUE klass) { gsl_vector_int *v = NULL; VALUE nary; int shape[1]; Data_Get_Struct(obj, gsl_vector_int, v); shape[0] = v->size; nary = na_make_object(NA_LINT, 1, shape, klass); if (v->stride == 1) { memcpy(NA_PTR_TYPE(nary,int*), v->data, shape[0]*sizeof(int)); } else { int i; for(i=0; i < v->size; i++) { (NA_PTR_TYPE(nary,int*))[i] = gsl_vector_int_get(v, i); } } return nary; } static VALUE rb_gsl_vector_int_to_na(VALUE obj) { return rb_gsl_vector_int_to_narray(obj, cNArray); } static VALUE rb_gsl_vector_int_to_nvector(VALUE obj) { return rb_gsl_vector_int_to_narray(obj, cNVector); } /* singleton method */ static VALUE rb_gsl_na_to_gsl_vector(VALUE obj, VALUE na) { return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, na_to_gv(na)); } static VALUE rb_gsl_na_to_gsl_vector_view(VALUE obj, VALUE na) { return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, na_to_gv_view(na)); } static VALUE rb_gsl_na_to_gsl_vector_complex(VALUE obj, VALUE na) { return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, na_to_gv_complex(na)); } static VALUE rb_gsl_na_to_gsl_vector_complex_view(VALUE obj, VALUE na) { return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, na_to_gv_complex_view(na)); } static VALUE rb_gsl_na_to_gsl_vector_int(VALUE obj, VALUE na) { return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, na_to_gv_int(na)); } static VALUE rb_gsl_na_to_gsl_vector_int_view(VALUE obj, VALUE na) { return Data_Wrap_Struct(cgsl_vector_int_view, 0, rb_gsl_vector_int_view_free, na_to_gv_int_view(na)); } static VALUE rb_gsl_na_to_gsl_vector_method(VALUE na) { VALUE v; if(NA_TYPE(na) == NA_SCOMPLEX || NA_TYPE(na) == NA_DCOMPLEX) v = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, na_to_gv_complex(na)); else v = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, na_to_gv(na)); return v; } VALUE rb_gsl_na_to_gsl_vector_view_method(VALUE na) { VALUE v; if(NA_TYPE(na) == NA_SCOMPLEX || NA_TYPE(na) == NA_DCOMPLEX) v = Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, na_to_gv_complex_view(na)); else v = Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, na_to_gv_view(na)); return v; } static VALUE rb_gsl_na_to_gsl_vector_int_method(VALUE na) { return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, na_to_gv_int(na)); } static VALUE rb_gsl_na_to_gsl_vector_int_view_method(VALUE na) { return Data_Wrap_Struct(cgsl_vector_int_view, 0, rb_gsl_vector_int_view_free, na_to_gv_int_view(na)); } gsl_vector* na_to_gv(VALUE na) { gsl_vector *v = NULL; VALUE nary = na; v = gsl_vector_alloc(NA_TOTAL(na)); if(NA_TYPE(na) != NA_DFLOAT) { nary = na_change_type(na, NA_DFLOAT); } memcpy(v->data, NA_PTR_TYPE(nary,double*), v->size*sizeof(double)); return v; } gsl_vector_view* na_to_gv_view(VALUE na) { gsl_vector_view *v = NULL; // Raise exception if na's type is not NA_DFLOAT. if(NA_TYPE(na) != NA_DFLOAT) rb_raise(rb_eTypeError, "GSL::Vector::View requires NArray be DFLOAT"); v = gsl_vector_view_alloc(); v->vector.data = NA_PTR_TYPE(na,double*); v->vector.size = NA_TOTAL(na); v->vector.stride = 1; v->vector.owner = 0; return v; } gsl_vector_complex* na_to_gv_complex(VALUE na) { gsl_vector_complex *v = NULL; VALUE nary = na; v = gsl_vector_complex_alloc(NA_TOTAL(na)); if(NA_TYPE(na) != NA_DCOMPLEX) { nary = na_change_type(na, NA_DCOMPLEX); } memcpy(v->data, NA_PTR_TYPE(nary,gsl_complex*), v->size*sizeof(gsl_complex)); return v; } gsl_vector_complex_view* na_to_gv_complex_view(VALUE na) { gsl_vector_complex_view *v = NULL; // Raise exception if na's type is not NA_DCOMPLEX if(NA_TYPE(na) != NA_DCOMPLEX) rb_raise(rb_eTypeError, "GSL::Vector::Complex::View requires NArray be DCOMPLEX"); v = gsl_vector_complex_view_alloc(); v->vector.data = NA_PTR_TYPE(na,double*); v->vector.size = NA_TOTAL(na); v->vector.stride = 1; v->vector.owner = 0; return v; } gsl_vector_int* na_to_gv_int(VALUE na) { gsl_vector_int *v = NULL; VALUE nary = na; v = gsl_vector_int_alloc(NA_TOTAL(na)); if(NA_TYPE(na) != NA_LINT) { nary = na_change_type(na, NA_LINT); } memcpy(v->data, NA_PTR_TYPE(nary,int*), v->size*sizeof(int)); return v; } gsl_vector_int_view* na_to_gv_int_view(VALUE na) { gsl_vector_int_view *v = NULL; // Raise exception if na's type is not NA_LINT if(NA_TYPE(na) != NA_LINT) rb_raise(rb_eTypeError, "GSL::Vector::Int::View requires NArray be LINT"); v = rb_gsl_vector_int_view_alloc(NA_TOTAL(na)); v->vector.data = NA_PTR_TYPE(na,int*); v->vector.size = NA_TOTAL(na); v->vector.stride = 1; v->vector.owner = 0; return v; } static VALUE rb_gsl_matrix_to_narray(VALUE obj, VALUE klass) { gsl_matrix *m = NULL; VALUE nary; int shape[2]; size_t i; Data_Get_Struct(obj, gsl_matrix, m); shape[0] = m->size2; shape[1] = m->size1; nary = na_make_object(NA_DFLOAT, 2, shape, klass); for (i = 0; i < shape[1]; i++) { memcpy(NA_PTR_TYPE(nary,double*)+(i*shape[0]), m->data+(i*m->tda), shape[0]*sizeof(double)); } return nary; } static VALUE rb_gsl_matrix_to_na(VALUE obj, VALUE klass) { return rb_gsl_matrix_to_narray(obj, cNArray); } static VALUE rb_gsl_matrix_to_nmatrix(VALUE obj, VALUE klass) { return rb_gsl_matrix_to_narray(obj, cNMatrix); } static VALUE rb_gsl_matrix_int_to_narray(VALUE obj, VALUE klass) { gsl_matrix_int *m = NULL; VALUE nary; int shape[2]; size_t i; Data_Get_Struct(obj, gsl_matrix_int, m); shape[0] = m->size2; shape[1] = m->size1; nary = na_make_object(NA_LINT, 2, shape, klass); for (i = 0; i < shape[1]; i++) { memcpy(NA_PTR_TYPE(nary,int*)+(i*shape[0]), m->data+(i*m->tda), shape[0]*sizeof(int)); } return nary; } static VALUE rb_gsl_matrix_int_to_na(VALUE obj) { return rb_gsl_matrix_int_to_narray(obj, cNArray); } static VALUE rb_gsl_matrix_int_to_nmatrix(VALUE obj) { return rb_gsl_matrix_int_to_narray(obj, cNMatrix); } static VALUE rb_gsl_matrix_to_narray_ref(VALUE obj, VALUE klass) { gsl_matrix *m = NULL; VALUE nary; struct NARRAY *na; Data_Get_Struct(obj, gsl_matrix, m); if (m->tda != m->size2) { rb_raise(rb_eRuntimeError, "Cannot make a reference obj: non-contiguous"); } na = rb_gsl_na_view_alloc(2, m->size2 * m->size1, NA_DFLOAT); na->shape[0] = m->size2; na->shape[1] = m->size1; na->ptr = (char *) m->data; nary = Data_Wrap_Struct(klass, 0, rb_gsl_na_view_free, na); return nary; } static VALUE rb_gsl_matrix_to_na_ref(VALUE obj) { return rb_gsl_matrix_to_narray_ref(obj, cNArray); } static VALUE rb_gsl_matrix_to_nmatrix_ref(VALUE obj) { return rb_gsl_matrix_to_narray_ref(obj, cNMatrix); } static VALUE rb_gsl_matrix_int_to_narray_ref(VALUE obj, VALUE klass) { gsl_matrix_int *m = NULL; VALUE nary; struct NARRAY *na; Data_Get_Struct(obj, gsl_matrix_int, m); if (m->tda != m->size2) { rb_raise(rb_eRuntimeError, "Cannot make a reference obj: non-contiguous"); } na = rb_gsl_na_view_alloc(2, m->size2 * m->size1, NA_LINT); na->shape[0] = m->size2; na->shape[1] = m->size1; na->ptr = (char *) m->data; nary = Data_Wrap_Struct(klass, 0, rb_gsl_na_view_free, na); return nary; } static VALUE rb_gsl_matrix_int_to_na_ref(VALUE obj) { return rb_gsl_matrix_int_to_narray_ref(obj, cNArray); } static VALUE rb_gsl_matrix_int_to_nmatrix_ref(VALUE obj) { return rb_gsl_matrix_int_to_narray_ref(obj, cNMatrix); } /* NArray -> GSL::Matrix */ VALUE rb_gsl_na_to_gsl_matrix(VALUE obj, VALUE nna) { gsl_matrix *m = NULL; m = na_to_gm(nna); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m); } VALUE rb_gsl_na_to_gsl_matrix_view(VALUE obj, VALUE nna) { gsl_matrix_view *m = NULL; m = na_to_gm_view(nna); return Data_Wrap_Struct(cgsl_matrix_view, 0, gsl_matrix_view_free, m); } VALUE rb_gsl_na_to_gsl_matrix_int(VALUE obj, VALUE nna) { gsl_matrix_int *m = NULL; m = na_to_gm_int(nna); return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, m); } VALUE rb_gsl_na_to_gsl_matrix_int_view(VALUE obj, VALUE nna) { gsl_matrix_int_view *m = NULL; m = na_to_gm_int_view(nna); return Data_Wrap_Struct(cgsl_matrix_int_view, 0, rb_gsl_matrix_int_view_free, m); } static VALUE rb_gsl_na_to_gsl_matrix_method(VALUE nna) { gsl_matrix *m = NULL; m = na_to_gm(nna); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m); } static VALUE rb_gsl_na_to_gsl_matrix_view_method(VALUE nna) { gsl_matrix_view *m = NULL; m = na_to_gm_view(nna); return Data_Wrap_Struct(cgsl_matrix_view, 0, gsl_matrix_view_free, m); } static VALUE rb_gsl_na_to_gsl_matrix_int_method(VALUE nna) { gsl_matrix_int *m = NULL; m = na_to_gm_int(nna); return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, m); } static VALUE rb_gsl_na_to_gsl_matrix_int_view_method(VALUE nna) { gsl_matrix_int_view *m = NULL; m = na_to_gm_int_view(nna); return Data_Wrap_Struct(cgsl_matrix_int_view, 0, rb_gsl_matrix_int_view_free, m); } gsl_matrix* na_to_gm(VALUE nna) { gsl_matrix *m = NULL; VALUE ary2; struct NARRAY *na = NULL; GetNArray(nna, na); m = gsl_matrix_alloc(na->shape[1], na->shape[0]); ary2 = na_change_type(nna, NA_DFLOAT); memcpy(m->data, NA_PTR_TYPE(ary2,double*), m->size1*m->size2*sizeof(double)); return m; } gsl_matrix_view* na_to_gm_view(VALUE nna) { gsl_matrix_view *m = NULL; VALUE ary2; struct NARRAY *na = NULL; // Raise exception if nna's type is not NA_DFLOAT if(NA_TYPE(nna) != NA_DFLOAT) rb_raise(rb_eTypeError, "GSL::Matrix::View requires NArray be DFLOAT"); GetNArray(nna, na); m = gsl_matrix_view_alloc(); ary2 = na_change_type(nna, NA_DFLOAT); m->matrix.data = NA_PTR_TYPE(ary2,double*); m->matrix.size1 = na->shape[1]; m->matrix.size2 = na->shape[0]; m->matrix.tda = m->matrix.size2; m->matrix.owner = 0; return m; } gsl_matrix_int* na_to_gm_int(VALUE nna) { gsl_matrix_int *m = NULL; VALUE ary2; struct NARRAY *na = NULL; GetNArray(nna, na); m = gsl_matrix_int_alloc(na->shape[1], na->shape[0]); ary2 = na_change_type(nna, NA_LINT); memcpy(m->data, NA_PTR_TYPE(ary2,int*), m->size1*m->size2*sizeof(int)); return m; } gsl_matrix_int_view* na_to_gm_int_view(VALUE nna) { gsl_matrix_int_view *m = NULL; VALUE ary2; struct NARRAY *na = NULL; // Raise exception if nna's type is not NA_LINT if(NA_TYPE(nna) != NA_LINT) rb_raise(rb_eTypeError, "GSL::Matrix::Int::View requires NArray be LINT"); GetNArray(nna, na); m = rb_gsl_matrix_int_view_alloc(na->shape[1], na->shape[0]); ary2 = na_change_type(nna, NA_LINT); m->matrix.data = NA_PTR_TYPE(ary2,int*); m->matrix.size1 = na->shape[1]; m->matrix.size2 = na->shape[0]; m->matrix.tda = m->matrix.size2; m->matrix.owner = 0; return m; } #ifdef HAVE_NARRAY_H #include "narray.h" #include EXTERN VALUE cgsl_histogram; static VALUE rb_gsl_narray_histogram(int argc, VALUE *argv, VALUE obj) { double *ptr, *ptr_range; gsl_histogram *h; gsl_vector *ranges; gsl_vector_view v; double min, max; size_t i, n, size, stride; ptr = get_vector_ptr(obj, &stride, &size); v.vector.data = ptr; v.vector.size = size; v.vector.size = stride; switch (argc) { case 1: if (rb_obj_is_kind_of(argv[0], rb_cRange)) argv[0] = rb_gsl_range2ary(argv[0]); switch (TYPE(argv[0])) { case T_FIXNUM: n = NUM2INT(argv[0]); min = gsl_vector_min(&v.vector) - 4*GSL_DBL_EPSILON; max = gsl_vector_max(&v.vector) + 4*GSL_DBL_EPSILON; h = gsl_histogram_alloc(n); gsl_histogram_set_ranges_uniform(h, min, max); break; case T_ARRAY: // n = RARRAY(argv[0])->len - 1; n = RARRAY_LEN(argv[0]) - 1; h = gsl_histogram_alloc(n); for (i = 0; i <= n; i++) h->range[i] = NUM2DBL(rb_ary_entry(argv[0], i)); break; default: if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, ranges); n = ranges->size - 1; h = gsl_histogram_alloc(n); gsl_histogram_set_ranges(h, ranges->data, ranges->size); } else if (NA_IsNArray(argv[0])) { ptr_range = get_vector_ptr(argv[0], &stride, &n); h = gsl_histogram_alloc(n); gsl_histogram_set_ranges(h, ptr_range, n); } break; } break; case 2: n = NUM2INT(argv[0]); switch (TYPE(argv[1])) { case T_ARRAY: min = NUM2DBL(rb_ary_entry(argv[1], 0)); max = NUM2DBL(rb_ary_entry(argv[1], 1)); break; default: rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[1]))); break; } h = gsl_histogram_alloc(n); gsl_histogram_set_ranges_uniform(h, min, max); break; case 3: n = NUM2INT(argv[0]); min = NUM2DBL(argv[1]); max = NUM2DBL(argv[2]); h = gsl_histogram_alloc(n); gsl_histogram_set_ranges_uniform(h, min, max); break; default: rb_raise(rb_eArgError, "wrong number of arguments %d", argc); break; } for (i = 0; i < size; i++) gsl_histogram_increment(h, ptr[i*stride]); return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, h); } #endif /*void rb_gsl_with_narray_define_methods()*/ void Init_gsl_narray(VALUE module) { rb_define_method(cgsl_vector, "to_na", rb_gsl_vector_to_na, 0); rb_define_alias(cgsl_vector, "to_narray", "to_na"); rb_define_method(cgsl_vector, "to_na2", rb_gsl_vector_to_na_ref, 0); rb_define_alias(cgsl_vector, "to_narray_ref", "to_na2"); rb_define_alias(cgsl_vector, "to_na_ref", "to_na2"); rb_define_method(cgsl_vector, "to_nv", rb_gsl_vector_to_nvector, 0); rb_define_alias(cgsl_vector, "to_nvector", "to_nv"); rb_define_method(cgsl_vector, "to_nv_ref", rb_gsl_vector_to_nvector_ref, 0); rb_define_alias(cgsl_vector, "to_nvector_ref", "to_nv_ref"); rb_define_singleton_method(cgsl_vector, "to_gslv", rb_gsl_na_to_gsl_vector, 1); rb_define_singleton_method(cgsl_vector, "to_gv", rb_gsl_na_to_gsl_vector, 1); rb_define_singleton_method(cgsl_vector, "na_to_gslv", rb_gsl_na_to_gsl_vector, 1); rb_define_singleton_method(cgsl_vector, "na_to_gv", rb_gsl_na_to_gsl_vector, 1); rb_define_singleton_method(cgsl_vector, "to_gslv_view", rb_gsl_na_to_gsl_vector_view, 1); rb_define_singleton_method(cgsl_vector, "to_gv_view", rb_gsl_na_to_gsl_vector_view, 1); rb_define_singleton_method(cgsl_vector, "na_to_gslv_view", rb_gsl_na_to_gsl_vector_view, 1); rb_define_singleton_method(cgsl_vector, "na_to_gv_view", rb_gsl_na_to_gsl_vector_view, 1); rb_define_method(cNArray, "to_gv", rb_gsl_na_to_gsl_vector_method, 0); rb_define_alias(cNArray, "to_gslv", "to_gv"); rb_define_method(cNArray, "to_gv_view", rb_gsl_na_to_gsl_vector_view_method, 0); rb_define_alias(cNArray, "to_gslv_view", "to_gv_view"); rb_define_alias(cNArray, "to_gv2", "to_gv_view"); rb_define_alias(cNArray, "to_gv_ref", "to_gv_view"); /*****/ rb_define_method(cgsl_vector_complex, "to_na", rb_gsl_vector_complex_to_na, 0); rb_define_alias(cgsl_vector_complex, "to_narray", "to_na"); rb_define_method(cgsl_vector_complex, "to_na2", rb_gsl_vector_to_na_ref, 0); rb_define_alias(cgsl_vector_complex, "to_narray_ref", "to_na2"); rb_define_alias(cgsl_vector_complex, "to_na_ref", "to_na2"); rb_define_method(cgsl_vector_complex, "to_nv", rb_gsl_vector_complex_to_nvector, 0); rb_define_alias(cgsl_vector_complex, "to_nvector", "to_nv"); rb_define_method(cgsl_vector_complex, "to_nv2", rb_gsl_vector_to_nvector_ref, 0); rb_define_alias(cgsl_vector_complex, "to_nv_ref", "to_nv2"); rb_define_alias(cgsl_vector_complex, "to_nvector_ref", "to_nv2"); rb_define_singleton_method(cgsl_vector_complex, "to_gslv", rb_gsl_na_to_gsl_vector_complex, 1); rb_define_singleton_method(cgsl_vector_complex, "to_gv", rb_gsl_na_to_gsl_vector_complex, 1); rb_define_singleton_method(cgsl_vector_complex, "na_to_gslv", rb_gsl_na_to_gsl_vector_complex, 1); rb_define_singleton_method(cgsl_vector_complex, "na_to_gv", rb_gsl_na_to_gsl_vector_complex, 1); rb_define_singleton_method(cgsl_vector_complex, "to_gslv_view", rb_gsl_na_to_gsl_vector_complex_view, 1); rb_define_singleton_method(cgsl_vector_complex, "to_gv_view", rb_gsl_na_to_gsl_vector_complex_view, 1); rb_define_singleton_method(cgsl_vector_complex, "na_to_gslv_view", rb_gsl_na_to_gsl_vector_complex_view, 1); rb_define_singleton_method(cgsl_vector_complex, "na_to_gv_view", rb_gsl_na_to_gsl_vector_complex_view, 1); /*****/ rb_define_method(cgsl_vector_int, "to_na", rb_gsl_vector_int_to_na, 0); rb_define_alias(cgsl_vector_int, "to_narray", "to_na"); rb_define_method(cgsl_vector_int, "to_nv", rb_gsl_vector_int_to_nvector, 0); rb_define_alias(cgsl_vector_int, "to_nvector", "to_nv"); rb_define_method(cgsl_vector_int, "to_na2", rb_gsl_vector_to_na_ref, 0); rb_define_alias(cgsl_vector_int, "to_na_ref", "to_na2"); rb_define_alias(cgsl_vector_int, "to_narray_ref", "to_na2"); rb_define_method(cgsl_vector_int, "to_nv_ref", rb_gsl_vector_to_nvector_ref, 0); rb_define_alias(cgsl_vector_int, "to_nvector_ref", "to_nv_ref"); rb_define_singleton_method(cgsl_vector_int, "to_gslv", rb_gsl_na_to_gsl_vector_int, 1); rb_define_singleton_method(cgsl_vector_int, "to_gv", rb_gsl_na_to_gsl_vector_int, 1); rb_define_singleton_method(cgsl_vector_int, "na_to_gslv", rb_gsl_na_to_gsl_vector_int, 1); rb_define_singleton_method(cgsl_vector_int, "na_to_gv", rb_gsl_na_to_gsl_vector_int, 1); rb_define_singleton_method(cgsl_vector_int, "to_gslv_view", rb_gsl_na_to_gsl_vector_int_view, 1); rb_define_singleton_method(cgsl_vector_int, "to_gv_view", rb_gsl_na_to_gsl_vector_int_view, 1); rb_define_singleton_method(cgsl_vector_int, "na_to_gslv_view", rb_gsl_na_to_gsl_vector_int_view, 1); rb_define_singleton_method(cgsl_vector_int, "na_to_gv_view", rb_gsl_na_to_gsl_vector_int_view, 1); rb_define_method(cNArray, "to_gv_int", rb_gsl_na_to_gsl_vector_int_method, 0); rb_define_alias(cNArray, "to_gslv_int", "to_gv_int"); rb_define_method(cNArray, "to_gv_int_view", rb_gsl_na_to_gsl_vector_int_view_method, 0); rb_define_alias(cNArray, "to_gslv_int_view", "to_gv_int_view"); /*****/ rb_define_method(cgsl_matrix, "to_na", rb_gsl_matrix_to_na, 0); rb_define_alias(cgsl_matrix, "to_narray", "to_na"); rb_define_method(cgsl_matrix, "to_nm", rb_gsl_matrix_to_nmatrix, 0); rb_define_alias(cgsl_matrix, "to_nmatrix", "to_nm"); rb_define_method(cgsl_matrix, "to_na2", rb_gsl_matrix_to_na_ref, 0); rb_define_alias(cgsl_matrix, "to_na_ref", "to_na2"); rb_define_alias(cgsl_matrix, "to_narray_ref", "to_na2"); rb_define_method(cgsl_matrix, "to_nm_ref", rb_gsl_matrix_to_nmatrix_ref, 0); rb_define_alias(cgsl_matrix, "to_nmatrix_ref", "to_nm_ref"); rb_define_singleton_method(cgsl_matrix, "to_gslm", rb_gsl_na_to_gsl_matrix, 1); rb_define_singleton_method(cgsl_matrix, "to_gm", rb_gsl_na_to_gsl_matrix, 1); rb_define_singleton_method(cgsl_matrix, "na_to_gslm", rb_gsl_na_to_gsl_matrix, 1); rb_define_singleton_method(cgsl_matrix, "na_to_gm", rb_gsl_na_to_gsl_matrix, 1); rb_define_singleton_method(cgsl_matrix, "to_gslm_view", rb_gsl_na_to_gsl_matrix_view, 1); rb_define_singleton_method(cgsl_matrix, "to_gm_view", rb_gsl_na_to_gsl_matrix_view, 1); rb_define_singleton_method(cgsl_matrix, "na_to_gslm_view", rb_gsl_na_to_gsl_matrix_view, 1); rb_define_singleton_method(cgsl_matrix, "na_to_gm_view", rb_gsl_na_to_gsl_matrix_view, 1); rb_define_method(cNArray, "to_gslm", rb_gsl_na_to_gsl_matrix_method, 0); rb_define_alias(cNArray, "to_gm", "to_gslm"); rb_define_method(cNArray, "to_gslm_view", rb_gsl_na_to_gsl_matrix_view_method, 0); rb_define_alias(cNArray, "to_gm_view", "to_gslm_view"); /*****/ // TODO Complex matrix /*****/ rb_define_method(cgsl_matrix_int, "to_na", rb_gsl_matrix_int_to_na, 0); rb_define_alias(cgsl_matrix_int, "to_narray", "to_na"); rb_define_method(cgsl_matrix_int, "to_nm", rb_gsl_matrix_int_to_nmatrix, 0); rb_define_alias(cgsl_matrix_int, "to_nmatrix", "to_nm"); rb_define_method(cgsl_matrix_int, "to_na2", rb_gsl_matrix_int_to_na_ref, 0); rb_define_alias(cgsl_matrix_int, "to_na_ref", "to_na2"); rb_define_alias(cgsl_matrix_int, "to_narray_ref", "to_na2"); rb_define_method(cgsl_matrix_int, "to_nm_ref", rb_gsl_matrix_int_to_nmatrix_ref, 0); rb_define_alias(cgsl_matrix_int, "to_nmatrix_ref", "to_nm_ref"); rb_define_singleton_method(cgsl_matrix_int, "to_gslm", rb_gsl_na_to_gsl_matrix_int, 1); rb_define_singleton_method(cgsl_matrix_int, "to_gm", rb_gsl_na_to_gsl_matrix_int, 1); rb_define_singleton_method(cgsl_matrix_int, "na_to_gslm", rb_gsl_na_to_gsl_matrix_int, 1); rb_define_singleton_method(cgsl_matrix_int, "na_to_gm", rb_gsl_na_to_gsl_matrix_int, 1); rb_define_singleton_method(cgsl_matrix_int, "to_gslm_view", rb_gsl_na_to_gsl_matrix_int_view, 1); rb_define_singleton_method(cgsl_matrix_int, "to_gm_view", rb_gsl_na_to_gsl_matrix_int_view, 1); rb_define_singleton_method(cgsl_matrix_int, "na_to_gslm_view", rb_gsl_na_to_gsl_matrix_int_view, 1); rb_define_singleton_method(cgsl_matrix_int, "na_to_gm_view", rb_gsl_na_to_gsl_matrix_int_view, 1); rb_define_method(cNArray, "to_gm_int", rb_gsl_na_to_gsl_matrix_int_method, 0); rb_define_alias(cNArray, "to_gslm_int", "to_gm_int"); rb_define_method(cNArray, "to_gm_int_view", rb_gsl_na_to_gsl_matrix_int_view_method, 0); rb_define_alias(cNArray, "to_gslm_int_view", "to_gm_int_view"); rb_define_method(cNArray, "histogram", rb_gsl_narray_histogram, -1); } #endif gsl-1.15.3/ext/wavelet.c0000644000175000017500000007275612220252463014376 0ustar boutilboutil/* wavelet.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_common.h" #ifdef GSL_1_6_LATER #include #include #endif #ifdef HAVE_NARRAY_H #include "narray.h" #endif #ifndef CHECK_WAVELET #define CHECK_WAVELET(x) if(!rb_obj_is_kind_of(x,cgsl_wavelet))\ rb_raise(rb_eTypeError, "wrong argument type (Wavelet expected)"); #endif #ifndef CHECK_WORKSPACE #define CHECK_WORKSPACE(x) if(!rb_obj_is_kind_of(x,cgsl_wavelet_workspace))\ rb_raise(rb_eTypeError, "wrong argument type (Wavelet::Workspace expected)"); #endif enum RB_GSL_DWT { RB_GSL_DWT_COPY, RB_GSL_DWT_INPLACE, }; static VALUE cgsl_wavelet; enum { GSL_WAVELET_DAUBECHIES, GSL_WAVELET_DAUBECHIES_CENTERED, GSL_WAVELET_HAAR, GSL_WAVELET_HAAR_CENTERED, GSL_WAVELET_BSPLINE, GSL_WAVELET_BSPLINE_CENTERED, }; #ifdef GSL_1_6_LATER static const gsl_wavelet_type* rb_gsl_wavelet_get_type(VALUE t); static VALUE cgsl_wavelet_workspace; #endif static VALUE rb_gsl_wavelet_new(VALUE klass, VALUE t, VALUE m) { #ifdef GSL_1_6_LATER const gsl_wavelet_type *T; size_t member; gsl_wavelet *w = NULL; CHECK_FIXNUM(m); T = rb_gsl_wavelet_get_type(t); member = FIX2INT(m); w = gsl_wavelet_alloc(T, member); if (w == NULL) rb_raise(rb_eNoMemError, "gsl_wavelet_alloc failed"); return Data_Wrap_Struct(klass, 0, gsl_wavelet_free, w); #else rb_raise(rb_eNotImpError, "Wavelet transforms not supported in GSL-%s, use GSL-1.6 or later", GSL_VERSION); return Qnil; #endif } #ifdef GSL_1_6_LATER static const gsl_wavelet_type* rb_gsl_wavelet_get_type_str(char *name); static const gsl_wavelet_type* rb_gsl_wavelet_get_type_int(int t); static const gsl_wavelet_type* rb_gsl_wavelet_get_type(VALUE t) { const gsl_wavelet_type *T; switch (TYPE(t)) { case T_STRING: T = rb_gsl_wavelet_get_type_str(STR2CSTR(t)); break; case T_FIXNUM: T = rb_gsl_wavelet_get_type_int(FIX2INT(t)); break; default: rb_raise(rb_eTypeError, "wrong type of argument %s (String or Fixnum expected)", rb_class2name(CLASS_OF(t))); break; } return T; } static const gsl_wavelet_type* rb_gsl_wavelet_get_type_str(char *name) { const gsl_wavelet_type *T; if (str_tail_grep(name, "daubechies") == 0) T = gsl_wavelet_daubechies; else if (str_tail_grep(name, "daubechies_centered") == 0) T = gsl_wavelet_daubechies_centered; else if (str_tail_grep(name, "haar") == 0) T = gsl_wavelet_haar; else if (str_tail_grep(name, "haar_centered") == 0) T = gsl_wavelet_haar_centered; else if (str_tail_grep(name, "bspline") == 0) T = gsl_wavelet_bspline; else if (str_tail_grep(name, "bspline_centered") == 0) T = gsl_wavelet_bspline_centered; else rb_raise(rb_eArgError, "unknown type %s", name); return T; } static const gsl_wavelet_type* rb_gsl_wavelet_get_type_int(int t) { const gsl_wavelet_type *T; switch (t) { case GSL_WAVELET_DAUBECHIES: T = gsl_wavelet_daubechies; break; case GSL_WAVELET_DAUBECHIES_CENTERED: T = gsl_wavelet_daubechies_centered; break; case GSL_WAVELET_HAAR: T = gsl_wavelet_haar; break; case GSL_WAVELET_HAAR_CENTERED: T = gsl_wavelet_haar_centered; break; case GSL_WAVELET_BSPLINE: T = gsl_wavelet_bspline; break; case GSL_WAVELET_BSPLINE_CENTERED: T = gsl_wavelet_bspline_centered; break; default: rb_raise(rb_eArgError, "unknown type %d", t); break; } return T; } static void rb_gsl_wavelet_define_const(VALUE klass); static void rb_gsl_wavelet_define_const(VALUE klass) { rb_define_const(klass, "DAUBECHIES", INT2FIX(GSL_WAVELET_DAUBECHIES)); rb_define_const(klass, "DAUBECHIES_CENTERED", INT2FIX(GSL_WAVELET_DAUBECHIES_CENTERED)); rb_define_const(klass, "HAAR", INT2FIX(GSL_WAVELET_HAAR)); rb_define_const(klass, "HAAR_CENTERED", INT2FIX(GSL_WAVELET_HAAR_CENTERED)); rb_define_const(klass, "BSPLINE", INT2FIX(GSL_WAVELET_BSPLINE)); rb_define_const(klass, "BSPLINE_CENTERED", INT2FIX(GSL_WAVELET_BSPLINE_CENTERED)); /*****/ rb_define_const(klass, "FORWARD", INT2FIX(forward)); rb_define_const(klass, "Forward", INT2FIX(forward)); rb_define_const(klass, "BACKWARD", INT2FIX(backward)); rb_define_const(klass, "Backward", INT2FIX(backward)); } static VALUE rb_gsl_wavelet_name(VALUE ww) { gsl_wavelet *w = NULL; Data_Get_Struct(ww, gsl_wavelet, w); return rb_str_new2(gsl_wavelet_name(w)); } static VALUE rb_gsl_wavelet_workspace_new(VALUE klass, VALUE nn) { gsl_wavelet_workspace *wspace = NULL; CHECK_FIXNUM(nn); wspace = gsl_wavelet_workspace_alloc(FIX2INT(nn)); if (wspace == NULL) rb_raise(rb_eNoMemError, "gsl_wavelet_workspace_alloc failed"); return Data_Wrap_Struct(klass, 0, gsl_wavelet_workspace_free, wspace); } static VALUE rb_gsl_wavelet2d_trans(int argc, VALUE *argv, VALUE obj, int (*trans)(const gsl_wavelet *, gsl_matrix *, gsl_wavelet_workspace *), int sss); static VALUE rb_gsl_wavelet2d(int argc, VALUE *argv, VALUE obj, int (*trans)(const gsl_wavelet *, gsl_matrix *, gsl_wavelet_direction, gsl_wavelet_workspace *), int sss); static VALUE rb_gsl_wavelet_transform0(int argc, VALUE *argv, VALUE obj, int sss) { gsl_wavelet *w = NULL; gsl_vector *v = NULL, *vnew; gsl_wavelet_direction dir = forward; gsl_wavelet_workspace *work = NULL; int itmp, flag = 0; // local variable "status" declared and set, but never used //int status; double *ptr1, *ptr2; size_t n, stride; int naflag = 0; VALUE ary, ret; #ifdef HAVE_NARRAY_H struct NARRAY *na1 = NULL; #endif switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_WAVELET(argv[0]); if (MATRIX_P(argv[1])) { return rb_gsl_wavelet2d(argc, argv, obj, gsl_wavelet2d_transform_matrix, sss); } if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(argv[1], gsl_vector, v); ret = argv[1]; ptr1 = v->data; n = v->size; stride = v->stride; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[1])) { GetNArray(argv[1], na1); ret = argv[1]; ptr1 = (double*) na1->ptr; n = na1->total; naflag = 1; stride = 1; #endif } else { rb_raise(rb_eTypeError, "wrong argument type (Vector expected)"); } itmp = 2; break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); if (MATRIX_P(argv[0])) { return rb_gsl_wavelet2d(argc, argv, obj, gsl_wavelet2d_transform_matrix, sss); } if (VECTOR_P(obj)) { CHECK_WAVELET(argv[0]); Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(obj, gsl_vector, v); ret = obj; ptr1 = v->data; n = v->size; stride = v->stride; } else if (VECTOR_P(argv[0])) { CHECK_WAVELET(obj); Data_Get_Struct(obj, gsl_wavelet, w); Data_Get_Struct(argv[0], gsl_vector, v); ret = argv[0]; ptr1 = v->data; n = v->size; stride = v->stride; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(obj)) { CHECK_WAVELET(argv[0]); Data_Get_Struct(argv[0], gsl_wavelet, w); GetNArray(obj, na1); ret = obj; ptr1 = (double*) na1->ptr; n = na1->total; naflag = 1; stride = 1; } else if (NA_IsNArray(argv[0])) { CHECK_WAVELET(obj); Data_Get_Struct(obj, gsl_wavelet, w); GetNArray(argv[0], na1); ret = argv[0]; ptr1 = (double*) na1->ptr; n = na1->total; naflag = 1; stride = 1; #endif } else { rb_raise(rb_eTypeError, "wrong argument type"); } itmp = 1; break; } switch (argc - itmp) { case 2: CHECK_FIXNUM(argv[itmp]); CHECK_WORKSPACE(argv[itmp+1]); dir = FIX2INT(argv[itmp]); Data_Get_Struct(argv[itmp+1], gsl_wavelet_workspace, work); break; case 1: if (TYPE(argv[itmp]) == T_FIXNUM) { dir = FIX2INT(argv[itmp]); work = gsl_wavelet_workspace_alloc(v->size); flag = 1; } else if (rb_obj_is_kind_of(argv[itmp], cgsl_wavelet_workspace)) { Data_Get_Struct(argv[itmp], gsl_wavelet_workspace, work); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; case 0: work = gsl_wavelet_workspace_alloc(v->size); flag = 1; break; default: rb_raise(rb_eArgError, "too many arguments"); break; } if (naflag == 0) { if (sss == RB_GSL_DWT_COPY) { vnew = gsl_vector_alloc(v->size); gsl_vector_memcpy(vnew, v); ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); ptr2 = vnew->data; } else { ary = ret; ptr2 = ptr1; } } else { #ifdef HAVE_NARRAY_H if (sss == RB_GSL_DWT_COPY) { ary = na_make_object(NA_DFLOAT, na1->rank, na1->shape, cNArray); ptr2 = NA_PTR_TYPE(ary, double*); memcpy(ptr2, ptr1, sizeof(double)*n); } else { ary = ret; ptr2 = ptr1; } #endif } /*status =*/ gsl_wavelet_transform(w, ptr2, stride, n, dir, work); if (flag) gsl_wavelet_workspace_free(work); return ary; } static VALUE rb_gsl_wavelet_transform(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet_transform0(argc, argv, obj, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet_transform2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet_transform0(argc, argv, obj, RB_GSL_DWT_INPLACE); } static VALUE rb_gsl_wavelet_trans(int argc, VALUE *argv, VALUE obj, int (*trans)(const gsl_wavelet *, double *, size_t, size_t, gsl_wavelet_workspace *), int sss) { gsl_wavelet *w = NULL; gsl_vector *v = NULL, *vnew; gsl_wavelet_workspace *work = NULL; int itmp, flag = 0, naflag = 0; // local variable "status" declared and set, but never used //int status; double *ptr1 = NULL, *ptr2 = NULL; size_t n, stride; VALUE ary, ret; #ifdef HAVE_NARRAY_H struct NARRAY *na; #endif switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_WAVELET(argv[0]); if (MATRIX_P(argv[1])) { if (trans == gsl_wavelet_transform_forward) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_forward, sss); } else { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_inverse, sss); } } if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(argv[1], gsl_vector, v); ret = argv[1]; ptr1 = v->data; n = v->size; stride = v->stride; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[1])) { GetNArray(argv[1], na); ret = argv[1]; ptr1 = (double*) na->ptr; n = na->total; naflag = 1; stride = 1; #endif } else { rb_raise(rb_eTypeError, "wrong argument type (Vector expected)"); } itmp = 2; break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); if (MATRIX_P(argv[0])) { if (trans == gsl_wavelet_transform_forward) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_forward, sss); } else { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_inverse, sss); } } if (VECTOR_P(obj)) { CHECK_WAVELET(argv[0]); Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(obj, gsl_vector, v); ret = obj; ptr1 = v->data; n = v->size; stride = v->stride; } else if (VECTOR_P(argv[0])) { CHECK_WAVELET(obj); Data_Get_Struct(obj, gsl_wavelet, w); Data_Get_Struct(argv[0], gsl_vector, v); ret = argv[0]; ptr1 = v->data; n = v->size; stride = v->stride; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(obj)) { CHECK_WAVELET(argv[0]); Data_Get_Struct(argv[0], gsl_wavelet, w); GetNArray(obj, na); ret = obj; ptr1 = (double*) na->ptr; n = na->total; naflag = 1; stride = 1; } else if (NA_IsNArray(argv[0])) { CHECK_WAVELET(obj); Data_Get_Struct(obj, gsl_wavelet, w); GetNArray(argv[0], na); ret = argv[0]; ptr1 = (double*) na->ptr; n = na->total; naflag = 1; stride = 1; #endif } else { rb_raise(rb_eTypeError, "wrong argument type"); } itmp = 1; break; } switch (argc - itmp) { case 1: CHECK_WORKSPACE(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_wavelet_workspace, work); break; case 0: work = gsl_wavelet_workspace_alloc(v->size); flag = 1; break; default: rb_raise(rb_eArgError, "too many arguments"); break; } if (naflag == 0) { if (sss == RB_GSL_DWT_COPY) { vnew = gsl_vector_alloc(v->size); gsl_vector_memcpy(vnew, v); ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); ptr2 = vnew->data; } else { ptr2 = ptr1; ary = ret; } } else { #ifdef HAVA_NARRAY_H if (sss == RB_GSL_DWT_COPY) { ary = na_make_object(NA_DFLOAT, na->rank, na->shape, cNArray); ptr2 = NA_PTR_TYPE(ary, double*); memcpy(ptr2, ptr1, sizeof(double)*n); } else { ptr2 = ptr1; ary = ret; } #endif } /*status =*/ (*trans)(w, ptr2, stride, n, work); if (flag) gsl_wavelet_workspace_free(work); return ary; } static VALUE rb_gsl_wavelet_transform_forward(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet_trans(argc, argv, obj, gsl_wavelet_transform_forward, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet_transform_inverse(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet_trans(argc, argv, obj, gsl_wavelet_transform_inverse, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet_transform_forward2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet_trans(argc, argv, obj, gsl_wavelet_transform_forward, RB_GSL_DWT_INPLACE); } static VALUE rb_gsl_wavelet_transform_inverse2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet_trans(argc, argv, obj, gsl_wavelet_transform_inverse, RB_GSL_DWT_INPLACE); } static VALUE rb_gsl_wavelet2d(int argc, VALUE *argv, VALUE obj, int (*trans)(const gsl_wavelet *, gsl_matrix *, gsl_wavelet_direction, gsl_wavelet_workspace *), int sss) { gsl_wavelet *w = NULL; gsl_matrix *m = NULL, *mnew; gsl_wavelet_direction dir = forward; gsl_wavelet_workspace *work = NULL; VALUE ary, ret; int itmp, flag = 0; // local variable "status" declared and set, but never used //int status; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_WAVELET(argv[0]); CHECK_MATRIX(argv[1]); ret = argv[1]; Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(argv[1], gsl_matrix, m); itmp = 2; break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); if (MATRIX_P(obj)) { CHECK_WAVELET(argv[0]); Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(obj, gsl_matrix, m); ret = obj; } else { CHECK_MATRIX(argv[0]); Data_Get_Struct(obj, gsl_wavelet, w); Data_Get_Struct(argv[0], gsl_matrix, m); ret = argv[0]; } itmp = 1; break; } switch (argc - itmp) { case 2: CHECK_FIXNUM(argv[itmp]); CHECK_WORKSPACE(argv[itmp+1]); dir = FIX2INT(argv[itmp]); Data_Get_Struct(argv[itmp+1], gsl_wavelet_workspace, work); break; case 1: if (TYPE(argv[itmp]) == T_FIXNUM) { dir = FIX2INT(argv[itmp]); work = gsl_wavelet_workspace_alloc(m->size1); flag = 1; } else if (rb_obj_is_kind_of(argv[itmp], cgsl_wavelet_workspace)) { Data_Get_Struct(argv[itmp], gsl_wavelet_workspace, work); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; case 0: work = gsl_wavelet_workspace_alloc(m->size1); flag = 1; break; default: rb_raise(rb_eArgError, "too many arguments"); break; } if (sss == RB_GSL_DWT_COPY) { mnew = make_matrix_clone(m); ary = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { mnew = m; ary = ret; } /*status =*/ (*trans)(w, mnew, dir, work); if (flag) gsl_wavelet_workspace_free(work); return ary; } static VALUE rb_gsl_wavelet2d_transform_matrix(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d(argc, argv, obj, gsl_wavelet2d_transform_matrix, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet2d_transform_matrix2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d(argc, argv, obj, gsl_wavelet2d_transform_matrix, RB_GSL_DWT_INPLACE); } static VALUE rb_gsl_wavelet2d_trans(int argc, VALUE *argv, VALUE obj, int (*trans)(const gsl_wavelet *, gsl_matrix *, gsl_wavelet_workspace *), int sss) { gsl_wavelet *w = NULL; gsl_matrix *m = NULL, *mnew; gsl_wavelet_workspace *work = NULL; VALUE ary, ret; int itmp, flag = 0; // local variable "status" declared and set, but never used //int status; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); CHECK_WAVELET(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(argv[1], gsl_matrix, m); ret = argv[1]; itmp = 2; break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); if (MATRIX_P(obj)) { CHECK_WAVELET(argv[0]); Data_Get_Struct(argv[0], gsl_wavelet, w); Data_Get_Struct(obj, gsl_matrix, m); ret = obj; } else { CHECK_MATRIX(argv[0]); Data_Get_Struct(obj, gsl_wavelet, w); Data_Get_Struct(argv[0], gsl_matrix, m); ret = argv[0]; } itmp = 1; break; } switch (argc - itmp) { case 1: CHECK_WORKSPACE(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_wavelet_workspace, work); break; case 0: work = gsl_wavelet_workspace_alloc(m->size1); flag = 1; break; default: rb_raise(rb_eArgError, "too many arguments"); break; } if (sss == RB_GSL_DWT_COPY) { mnew = make_matrix_clone(m); ary = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { mnew = m; ary = ret; } /*status =*/ (*trans)(w, mnew, work); if (flag) gsl_wavelet_workspace_free(work); return ary; } static VALUE rb_gsl_wavelet2d_transform_matrix_forward(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_forward, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet2d_transform_matrix_forward2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_forward, RB_GSL_DWT_INPLACE); } static VALUE rb_gsl_wavelet2d_transform_matrix_inverse(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_inverse, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet2d_transform_matrix_inverse2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_transform_matrix_inverse, RB_GSL_DWT_INPLACE); } /** nstransform **/ static VALUE rb_gsl_wavelet2d_nstransform_matrix(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d(argc, argv, obj, gsl_wavelet2d_nstransform_matrix, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet2d_nstransform_matrix2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d(argc, argv, obj, gsl_wavelet2d_nstransform_matrix, RB_GSL_DWT_INPLACE); } static VALUE rb_gsl_wavelet2d_nstransform_matrix_forward(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_nstransform_matrix_forward, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet2d_nstransform_matrix_forward2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_nstransform_matrix_forward, RB_GSL_DWT_INPLACE); } static VALUE rb_gsl_wavelet2d_nstransform_matrix_inverse(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_nstransform_matrix_inverse, RB_GSL_DWT_COPY); } static VALUE rb_gsl_wavelet2d_nstransform_matrix_inverse2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_wavelet2d_trans(argc, argv, obj, gsl_wavelet2d_nstransform_matrix_inverse, RB_GSL_DWT_INPLACE); } #endif void Init_wavelet(VALUE module) { VALUE cgsl_wavelet2d; cgsl_wavelet = rb_define_class_under(module, "Wavelet", cGSL_Object); cgsl_wavelet2d = rb_define_class_under(module, "Wavelet2d", cgsl_wavelet); rb_define_singleton_method(cgsl_wavelet, "alloc", rb_gsl_wavelet_new, 2); #ifdef GSL_1_6_LATER rb_gsl_wavelet_define_const(cgsl_wavelet); rb_define_method(cgsl_wavelet, "name", rb_gsl_wavelet_name, 0); cgsl_wavelet_workspace = rb_define_class_under(cgsl_wavelet, "Workspace", cGSL_Object); rb_define_singleton_method(cgsl_wavelet_workspace, "alloc", rb_gsl_wavelet_workspace_new, 1); /*****/ rb_define_singleton_method(cgsl_wavelet, "transform", rb_gsl_wavelet_transform, -1); rb_define_method(cgsl_wavelet, "transform", rb_gsl_wavelet_transform, -1); rb_define_method(cgsl_vector, "wavelet_transform", rb_gsl_wavelet_transform, -1); rb_define_singleton_method(cgsl_wavelet, "transform!", rb_gsl_wavelet_transform2, -1); rb_define_method(cgsl_wavelet, "transform!", rb_gsl_wavelet_transform2, -1); rb_define_method(cgsl_vector, "wavelet_transform!", rb_gsl_wavelet_transform2, -1); /**/ rb_define_singleton_method(cgsl_wavelet, "transform_forward", rb_gsl_wavelet_transform_forward, -1); rb_define_method(cgsl_wavelet, "transform_forward", rb_gsl_wavelet_transform_forward, -1); rb_define_alias(cgsl_wavelet, "forward", "transform_forward"); rb_define_method(cgsl_vector, "wavelet_transform_forward", rb_gsl_wavelet_transform_forward, -1); rb_define_singleton_method(cgsl_wavelet, "transform_inverse", rb_gsl_wavelet_transform_inverse, -1); rb_define_method(cgsl_wavelet, "transform_inverse", rb_gsl_wavelet_transform_inverse, -1); rb_define_alias(cgsl_wavelet, "inverse", "transform_inverse"); rb_define_method(cgsl_vector, "wavelet_transform_inverse", rb_gsl_wavelet_transform_inverse, -1); rb_define_singleton_method(cgsl_wavelet, "transform_forward!", rb_gsl_wavelet_transform_forward2, -1); rb_define_method(cgsl_wavelet, "transform_forward!", rb_gsl_wavelet_transform_forward2, -1); rb_define_alias(cgsl_wavelet, "forward!", "transform_forward!"); rb_define_method(cgsl_vector, "wavelet_transform_forward!", rb_gsl_wavelet_transform_forward2, -1); rb_define_singleton_method(cgsl_wavelet, "transform_inverse!", rb_gsl_wavelet_transform_inverse2, -1); rb_define_method(cgsl_wavelet, "transform_inverse!", rb_gsl_wavelet_transform_inverse2, -1); rb_define_alias(cgsl_wavelet, "inverse!", "transform_inverse!"); rb_define_method(cgsl_vector, "wavelet_transform_inverse!", rb_gsl_wavelet_transform_inverse2, -1); /***** 2d *****/ rb_define_singleton_method(cgsl_wavelet, "transform_matrix", rb_gsl_wavelet2d_transform_matrix, -1); rb_define_singleton_method(cgsl_wavelet2d, "transform", rb_gsl_wavelet2d_transform_matrix, -1); rb_define_method(cgsl_wavelet, "transform_matrix", rb_gsl_wavelet2d_transform_matrix, -1); rb_define_method(cgsl_wavelet2d, "transform", rb_gsl_wavelet2d_transform_matrix, -1); rb_define_method(cgsl_matrix, "wavelet_transform", rb_gsl_wavelet2d_transform_matrix, -1); rb_define_singleton_method(cgsl_wavelet, "transform_matrix!", rb_gsl_wavelet2d_transform_matrix2, -1); rb_define_singleton_method(cgsl_wavelet2d, "transform!", rb_gsl_wavelet2d_transform_matrix2, -1); rb_define_method(cgsl_wavelet, "transform_matrix!", rb_gsl_wavelet2d_transform_matrix2, -1); rb_define_method(cgsl_wavelet2d, "transform!", rb_gsl_wavelet2d_transform_matrix2, -1); rb_define_method(cgsl_matrix, "wavelet_transform!", rb_gsl_wavelet2d_transform_matrix2, -1); /**/ rb_define_singleton_method(cgsl_wavelet, "transform_matrix_forward", rb_gsl_wavelet2d_transform_matrix_forward, -1); rb_define_singleton_method(cgsl_wavelet2d, "transform_forward", rb_gsl_wavelet2d_transform_matrix_forward, -1); rb_define_method(cgsl_wavelet, "transform_matrix_forward", rb_gsl_wavelet2d_transform_matrix_forward, -1); rb_define_method(cgsl_wavelet2d, "transform_forward", rb_gsl_wavelet2d_transform_matrix_forward, -1); rb_define_method(cgsl_matrix, "wavelet_transform_forward", rb_gsl_wavelet2d_transform_matrix_forward, -1); rb_define_singleton_method(cgsl_wavelet, "transform_matrix_forward!", rb_gsl_wavelet2d_transform_matrix_forward2, -1); rb_define_singleton_method(cgsl_wavelet2d, "transform_forward!", rb_gsl_wavelet2d_transform_matrix_forward2, -1); rb_define_method(cgsl_wavelet, "transform_matrix_forward!", rb_gsl_wavelet2d_transform_matrix_forward2, -1); rb_define_method(cgsl_wavelet2d, "transform_forward!", rb_gsl_wavelet2d_transform_matrix_forward2, -1); rb_define_method(cgsl_matrix, "wavelet_transform_forward!", rb_gsl_wavelet2d_transform_matrix_forward2, -1); rb_define_singleton_method(cgsl_wavelet, "transform_matrix_inverse", rb_gsl_wavelet2d_transform_matrix_inverse, -1); rb_define_singleton_method(cgsl_wavelet2d, "transform_inverse", rb_gsl_wavelet2d_transform_matrix_inverse, -1); rb_define_method(cgsl_wavelet, "transform_matrix_inverse", rb_gsl_wavelet2d_transform_matrix_inverse, -1); rb_define_method(cgsl_wavelet2d, "transform_inverse", rb_gsl_wavelet2d_transform_matrix_inverse, -1); rb_define_method(cgsl_matrix, "wavelet_transform_inverse", rb_gsl_wavelet2d_transform_matrix_inverse, -1); rb_define_singleton_method(cgsl_wavelet, "transform_matrix_inverse!", rb_gsl_wavelet2d_transform_matrix_inverse2, -1); rb_define_singleton_method(cgsl_wavelet2d, "transform_inverse!", rb_gsl_wavelet2d_transform_matrix_inverse2, -1); rb_define_method(cgsl_wavelet, "transform_matrix_inverse!", rb_gsl_wavelet2d_transform_matrix_inverse2, -1); rb_define_method(cgsl_wavelet2d, "transform_inverse!", rb_gsl_wavelet2d_transform_matrix_inverse2, -1); rb_define_method(cgsl_matrix, "wavelet_transform_inverse!", rb_gsl_wavelet2d_transform_matrix_inverse2, -1); /** nstransform **/ rb_define_singleton_method(cgsl_wavelet, "nstransform_matrix", rb_gsl_wavelet2d_nstransform_matrix, -1); rb_define_singleton_method(cgsl_wavelet2d, "nstransform", rb_gsl_wavelet2d_nstransform_matrix, -1); rb_define_method(cgsl_wavelet, "nstransform_matrix", rb_gsl_wavelet2d_nstransform_matrix, -1); rb_define_method(cgsl_wavelet2d, "nstransform", rb_gsl_wavelet2d_nstransform_matrix, -1); rb_define_singleton_method(cgsl_wavelet, "nstransform_matrix!", rb_gsl_wavelet2d_nstransform_matrix2, -1); rb_define_singleton_method(cgsl_wavelet2d, "nstransform!", rb_gsl_wavelet2d_nstransform_matrix2, -1); rb_define_method(cgsl_wavelet, "nstransform_matrix!", rb_gsl_wavelet2d_nstransform_matrix2, -1); rb_define_method(cgsl_wavelet2d, "nstransform!", rb_gsl_wavelet2d_nstransform_matrix2, -1); /**/ rb_define_singleton_method(cgsl_wavelet, "nstransform_matrix_forward", rb_gsl_wavelet2d_nstransform_matrix_forward, -1); rb_define_singleton_method(cgsl_wavelet2d, "nstransform_forward", rb_gsl_wavelet2d_nstransform_matrix_forward, -1); rb_define_method(cgsl_wavelet, "nstransform_matrix_forward", rb_gsl_wavelet2d_nstransform_matrix_forward, -1); rb_define_method(cgsl_wavelet2d, "nstransform_forward", rb_gsl_wavelet2d_nstransform_matrix_forward, -1); rb_define_singleton_method(cgsl_wavelet, "nstransform_matrix_forward!", rb_gsl_wavelet2d_nstransform_matrix_forward2, -1); rb_define_singleton_method(cgsl_wavelet2d, "nstransform_forward!", rb_gsl_wavelet2d_nstransform_matrix_forward2, -1); rb_define_method(cgsl_wavelet, "nstransform_matrix_forward!", rb_gsl_wavelet2d_nstransform_matrix_forward2, -1); rb_define_method(cgsl_wavelet2d, "nstransform_forward!", rb_gsl_wavelet2d_nstransform_matrix_forward2, -1); rb_define_singleton_method(cgsl_wavelet, "nstransform_matrix_inverse", rb_gsl_wavelet2d_nstransform_matrix_inverse, -1); rb_define_singleton_method(cgsl_wavelet2d, "nstransform_inverse", rb_gsl_wavelet2d_nstransform_matrix_inverse, -1); rb_define_method(cgsl_wavelet, "nstransform_matrix_inverse", rb_gsl_wavelet2d_nstransform_matrix_inverse, -1); rb_define_method(cgsl_wavelet2d, "nstransform_inverse", rb_gsl_wavelet2d_nstransform_matrix_inverse, -1); rb_define_singleton_method(cgsl_wavelet, "nstransform_matrix_inverse!", rb_gsl_wavelet2d_nstransform_matrix_inverse2, -1); rb_define_singleton_method(cgsl_wavelet2d, "nstransform_inverse!", rb_gsl_wavelet2d_nstransform_matrix_inverse2, -1); rb_define_method(cgsl_wavelet, "nstransform_matrix_inverse!", rb_gsl_wavelet2d_nstransform_matrix_inverse2, -1); rb_define_method(cgsl_wavelet2d, "nstransform_inverse!", rb_gsl_wavelet2d_nstransform_matrix_inverse2, -1); #endif } #undef CHECK_WAVELET #undef CHECK_WORKSPACE gsl-1.15.3/ext/matrix_double.c0000644000175000017500000004073412220252463015554 0ustar boutilboutil/* matrix_double.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_complex.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif enum { GSL_MATRIX_ADD, GSL_MATRIX_SUB, GSL_MATRIX_MUL, GSL_MATRIX_DIV, }; static VALUE rb_gsl_matrix_arithmetics(int flag, VALUE obj, VALUE bb); VALUE rb_gsl_linalg_LU_solve(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_matrix_arithmetics(int flag, VALUE obj, VALUE bb) { gsl_matrix *m = NULL, *mb = NULL, *mnew = NULL; gsl_matrix_complex *cm = NULL, *cmb = NULL, *cmnew = NULL; gsl_complex *c = NULL; gsl_vector *v = NULL, *vnew = NULL; gsl_vector_complex *cv = NULL, *cvnew = NULL; Data_Get_Struct(obj, gsl_matrix, m); switch (TYPE(bb)) { case T_FLOAT: case T_FIXNUM: switch (flag) { case GSL_MATRIX_ADD: mnew = make_matrix_clone(m); gsl_matrix_add_constant(mnew, NUM2DBL(bb)); break; case GSL_MATRIX_SUB: mnew = make_matrix_clone(m); gsl_matrix_add_constant(mnew, -NUM2DBL(bb)); break; case GSL_MATRIX_MUL: mnew = make_matrix_clone(m); gsl_matrix_scale(mnew, NUM2DBL(bb)); break; case GSL_MATRIX_DIV: mnew = make_matrix_clone(m); gsl_matrix_scale(mnew, 1.0/NUM2DBL(bb)); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); break; default: if (MATRIX_INT_P(bb)) bb = rb_gsl_matrix_int_to_f(bb); if (VECTOR_INT_P(bb)) bb = rb_gsl_vector_int_to_f(bb); if (rb_obj_is_kind_of(bb, cgsl_matrix)) { Data_Get_Struct(bb, gsl_matrix, mb); switch (flag) { case GSL_MATRIX_ADD: mnew = make_matrix_clone(m); gsl_matrix_add(mnew, mb); break; case GSL_MATRIX_SUB: mnew = make_matrix_clone(m); gsl_matrix_sub(mnew,mb); break; case GSL_MATRIX_MUL: mnew = make_matrix_clone(m); gsl_matrix_mul_elements(mnew, mb); break; case GSL_MATRIX_DIV: mnew = make_matrix_clone(m); gsl_matrix_div_elements(mnew, mb); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else if (rb_obj_is_kind_of(bb, cgsl_matrix_complex)) { Data_Get_Struct(bb, gsl_matrix_complex, cmb); cmnew = matrix_to_complex(m); switch (flag) { case GSL_MATRIX_ADD: gsl_matrix_complex_add(cmnew, cmb); break; case GSL_MATRIX_SUB: gsl_matrix_complex_sub(cmnew,cmb); break; case GSL_MATRIX_MUL: gsl_matrix_complex_mul_elements(cmnew, cmb); break; case GSL_MATRIX_DIV: gsl_matrix_complex_div_elements(cmnew, cmb); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); } else if (rb_obj_is_kind_of(bb, cgsl_complex)) { Data_Get_Struct(bb, gsl_complex, c); cmnew = matrix_to_complex(m); switch (flag) { case GSL_MATRIX_ADD: gsl_matrix_complex_add_constant(cmnew, *c); break; case GSL_MATRIX_SUB: gsl_matrix_complex_add_constant(cmnew, gsl_complex_negative(*c)); break; case GSL_MATRIX_MUL: gsl_matrix_complex_scale(cmnew, *c); break; case GSL_MATRIX_DIV: gsl_matrix_complex_scale(cmnew, gsl_complex_inverse(*c)); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); } else if (rb_obj_is_kind_of(bb, cgsl_vector)) { if (!VECTOR_COL_P(bb)) rb_raise(rb_eTypeError, "Operation with %s is not defined (GSL::Vector::Col expected)", rb_class2name(CLASS_OF(bb))); Data_Get_Struct(bb, gsl_vector, v); switch (flag) { case GSL_MATRIX_MUL: // vnew = gsl_vector_alloc(v->size); vnew = gsl_vector_alloc(m->size1); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); gsl_matrix_mul_vector(vnew, m, v); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, vnew); break; case GSL_MATRIX_DIV: return rb_gsl_linalg_LU_solve(1, &bb, obj); break; default: rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix", rb_class2name(CLASS_OF(bb))); break; } } else if (rb_obj_is_kind_of(bb, cgsl_vector_complex)) { Data_Get_Struct(bb, gsl_vector_complex, cv); switch (flag) { case GSL_MATRIX_MUL: cm = matrix_to_complex(m); // cvnew = gsl_vector_complex_alloc(cv->size); cvnew = gsl_vector_complex_alloc(m->size1); if (cvnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_matrix_complex_mul_vector(cvnew, cm, cv); gsl_matrix_complex_free(cm); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew); break; default: rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix", rb_class2name(CLASS_OF(bb))); break; } } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(bb))); } } /* never reach here */ return Qnil; } static VALUE rb_gsl_matrix_add(VALUE obj, VALUE bb) { return rb_gsl_matrix_arithmetics(GSL_MATRIX_ADD, obj, bb); } static VALUE rb_gsl_matrix_sub(VALUE obj, VALUE bb) { return rb_gsl_matrix_arithmetics(GSL_MATRIX_SUB, obj, bb); } VALUE rb_gsl_matrix_mul_elements(VALUE obj, VALUE bb) { return rb_gsl_matrix_arithmetics(GSL_MATRIX_MUL, obj, bb); } /* matrix multiplication */ static VALUE rb_gsl_matrix_mul(VALUE obj, VALUE bb) { gsl_matrix *m = NULL, *b = NULL, *mnew = NULL; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix_complex *mc, *mcb, *mcnew; gsl_vector_complex *vc, *vcnew; gsl_complex za, zb; Data_Get_Struct(obj, gsl_matrix, m); if (VECTOR_INT_P(bb)) bb = rb_gsl_vector_int_to_f(bb); if (MATRIX_P(bb)) { Data_Get_Struct(bb, gsl_matrix, b); mnew = gsl_matrix_alloc(m->size1, b->size2); gsl_linalg_matmult(m, b, mnew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else if (VECTOR_P(bb)) { Data_Get_Struct(bb, gsl_vector, v); // vnew = gsl_vector_alloc(v->size); // printf("%d %d\n", m->size1, m->size2); vnew = gsl_vector_alloc(m->size1); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); gsl_matrix_mul_vector(vnew, m, v); return Data_Wrap_Struct(VECTOR_ROW_COL(bb), 0, gsl_vector_free, vnew); } else if (MATRIX_COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_matrix_complex, mcb); mc = matrix_to_complex(m); mcnew = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_mul(mcnew, mc, mcb); gsl_matrix_complex_free(mc); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mcnew); } else if (VECTOR_COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_vector_complex, vc); vcnew = gsl_vector_complex_calloc(m->size1); mc = matrix_to_complex(m); za.dat[0] = 1.0; za.dat[1] = 0.0; zb.dat[0] = 0.0; zb.dat[1] = 0.0; gsl_blas_zgemv(CblasNoTrans, za, mc, vc, zb, vcnew); gsl_matrix_complex_free(mc); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vcnew); } else { switch (TYPE(bb)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_gsl_matrix_mul_elements(obj, bb); break; default: rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(bb))); break; } } return Qnil; } static VALUE rb_gsl_matrix_mul_bang(VALUE obj, VALUE bb) { gsl_matrix *m = NULL, *b = NULL, *mtmp = NULL; gsl_vector *v = NULL, *vnew = NULL; Data_Get_Struct(obj, gsl_matrix, m); if (MATRIX_P(bb)) { Data_Get_Struct(bb, gsl_matrix, b); mtmp = gsl_matrix_alloc(m->size1, b->size2); gsl_linalg_matmult(m, b, mtmp); gsl_matrix_memcpy(m, mtmp); gsl_matrix_free(mtmp); return obj; } else if (VECTOR_P(bb)) { Data_Get_Struct(bb, gsl_vector, v); vnew = gsl_vector_alloc(v->size); if (vnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); gsl_matrix_mul_vector(vnew, m, v); return Data_Wrap_Struct(VECTOR_ROW_COL(bb), 0, gsl_vector_free, vnew); } else { switch (TYPE(bb)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: gsl_matrix_scale(m, NUM2DBL(bb)); return obj; break; default: rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(bb))); break; } } } static VALUE rb_gsl_matrix_div_elements(VALUE obj, VALUE bb) { return rb_gsl_matrix_arithmetics(GSL_MATRIX_DIV, obj, bb); } static VALUE rb_gsl_matrix_to_complex(VALUE obj) { gsl_matrix *m = NULL; gsl_matrix_complex *cm = NULL; Data_Get_Struct(obj, gsl_matrix, m); cm = matrix_to_complex(m); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cm); } gsl_matrix_view* gsl_matrix_view_alloc() { gsl_matrix_view *mv = NULL; mv = ALLOC(gsl_matrix_view); if (mv == NULL) rb_raise(rb_eRuntimeError, "malloc failed"); return mv; } void gsl_matrix_view_free(gsl_matrix_view * mv); void gsl_matrix_view_free(gsl_matrix_view * mv) { free((gsl_matrix_view *) mv); } static VALUE rb_gsl_matrix_coerce(VALUE obj, VALUE other) { gsl_matrix *m = NULL, *mnew = NULL; gsl_matrix_complex *cm = NULL; double x; gsl_complex *z = NULL; VALUE vcm; Data_Get_Struct(obj, gsl_matrix, m); switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: mnew = gsl_matrix_alloc(m->size1, m->size2); if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); x = NUM2DBL(other); gsl_matrix_set_all(mnew, x); return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew), obj); break; default: if (rb_obj_is_kind_of(other, cgsl_complex)) { Data_Get_Struct(other, gsl_complex, z); cm = gsl_matrix_complex_alloc(m->size1, m->size2); if (cm == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_set_all(cm, *z); vcm = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cm); return rb_ary_new3(2, vcm, rb_gsl_matrix_to_complex(obj)); } else if (rb_obj_is_kind_of(other, cgsl_matrix_complex)) { cm = matrix_to_complex(m); vcm = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cm); return rb_ary_new3(2, other, vcm); } else { rb_raise(rb_eTypeError, "cannot coerce %s to Matrix", rb_class2name(CLASS_OF(other))); } break; } } static VALUE rb_gsl_matrix_to_f(VALUE obj) { return obj; } VALUE rb_gsl_matrix_to_i(VALUE obj) { gsl_matrix *m = NULL; gsl_matrix_int *mi = NULL; size_t i, j; Data_Get_Struct(obj, gsl_matrix, m); mi = gsl_matrix_int_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_int_set(mi, i, j, (int) gsl_matrix_get(m, i, j)); } } return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, mi); } static VALUE rb_gsl_matrix_clean(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL, *mnew = NULL; double eps = 1e-10; size_t n, i; switch (argc) { case 0: /* do nothing */ break; case 1: Need_Float(argv[0]); eps = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); break; } Data_Get_Struct(obj, gsl_matrix, m); mnew = make_matrix_clone(m); n = m->size1*m->size2; for (i = 0; i < n; i++) if (fabs(mnew->data[i]) < eps) mnew->data[i] = 0.0; return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);; } static VALUE rb_gsl_matrix_clean_bang(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL; double eps = 1e-10; size_t n, i; switch (argc) { case 0: /* do nothing */ break; case 1: Need_Float(argv[0]); eps = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); break; } Data_Get_Struct(obj, gsl_matrix, m); n = m->size1*m->size2; for (i = 0; i < n; i++) if (fabs(m->data[i]) < eps) m->data[i] = 0.0; return obj; } static VALUE rb_gsl_matrix_op_inplace(VALUE mm1, VALUE mm2, int (*f)(gsl_matrix*, const gsl_matrix*)) { gsl_matrix *m1, *m2; Data_Get_Struct(mm1, gsl_matrix, m1); Data_Get_Struct(mm2, gsl_matrix, m2); (*f)(m1, m2); return mm1; } static VALUE rb_gsl_matrix_add_inplace(VALUE mm1, VALUE mm2) { return rb_gsl_matrix_op_inplace(mm1, mm2, gsl_matrix_add); } static VALUE rb_gsl_matrix_sub_inplace(VALUE mm1, VALUE mm2) { return rb_gsl_matrix_op_inplace(mm1, mm2, gsl_matrix_sub); } VALUE rb_gsl_sf_eval1(double (*func)(double), VALUE argv); static VALUE rb_gsl_matrix_sin(VALUE obj) { return rb_gsl_sf_eval1(sin, obj); } static VALUE rb_gsl_matrix_cos(VALUE obj) { return rb_gsl_sf_eval1(cos, obj); } static VALUE rb_gsl_matrix_tan(VALUE obj) { return rb_gsl_sf_eval1(tan, obj); } static VALUE rb_gsl_matrix_exp(VALUE obj) { return rb_gsl_sf_eval1(exp, obj); } static VALUE rb_gsl_matrix_log(VALUE obj) { return rb_gsl_sf_eval1(log, obj); } static VALUE rb_gsl_matrix_log10(VALUE obj) { return rb_gsl_sf_eval1(log10, obj); } #include #include #include "rb_gsl_rng.h" static VALUE rb_gsl_matrix_randx(int argc, VALUE *argv, VALUE klass, double (*f)(const gsl_rng*)); static VALUE rb_gsl_matrix_rand(int argc, VALUE *argv, VALUE klass) { return rb_gsl_matrix_randx(argc, argv, klass, gsl_rng_uniform); } static VALUE rb_gsl_matrix_randn(int argc, VALUE *argv, VALUE klass) { return rb_gsl_matrix_randx(argc, argv, klass, gsl_ran_ugaussian); } static VALUE rb_gsl_matrix_randx(int argc, VALUE *argv, VALUE klass, double (*f)(const gsl_rng*)) { gsl_matrix *m; gsl_rng *rng; size_t size1, size2; size_t i, j; switch (argc) { case 3: if (!rb_obj_is_kind_of(argv[2], cgsl_rng)) { rb_raise(rb_eTypeError, "Wrong argument type (GSL::Rng expected)"); } Data_Get_Struct(argv[2], gsl_rng, rng); size1 = FIX2INT(argv[0]); size2 = FIX2INT(argv[1]); break; case 2: size1 = FIX2INT(argv[0]); size2 = FIX2INT(argv[1]); rng = gsl_rng_alloc(gsl_rng_default); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 2 or 3)", argc); } m = gsl_matrix_alloc(size1, size2); for (i = 0; i < size1; i++) { for (j = 0; j < size2; j++) { gsl_matrix_set(m, i, j, (*f)(rng)); } } if (argc == 2) gsl_rng_free(rng); return Data_Wrap_Struct(klass, 0, gsl_matrix_free, m); } void Init_gsl_matrix_init(VALUE module); void Init_gsl_matrix(VALUE module) { Init_gsl_matrix_init(module); rb_define_method(cgsl_matrix, "add", rb_gsl_matrix_add, 1); rb_define_alias(cgsl_matrix, "+", "add"); rb_define_method(cgsl_matrix, "sub", rb_gsl_matrix_sub, 1); rb_define_alias(cgsl_matrix, "-", "sub"); rb_define_method(cgsl_matrix, "mul_elements", rb_gsl_matrix_mul_elements, 1); rb_define_method(cgsl_matrix, "div_elements", rb_gsl_matrix_div_elements, 1); rb_define_alias(cgsl_matrix, "/", "div_elements"); rb_define_method(cgsl_matrix, "mul", rb_gsl_matrix_mul, 1); rb_define_alias(cgsl_matrix, "*", "mul"); rb_define_method(cgsl_matrix, "mul!", rb_gsl_matrix_mul_bang, 1); /***/ rb_define_method(cgsl_matrix, "to_complex", rb_gsl_matrix_to_complex, 0); rb_define_method(cgsl_matrix, "coerce", rb_gsl_matrix_coerce, 1); rb_undef_method(cgsl_matrix_view_ro, "set"); rb_define_method(cgsl_matrix, "to_i", rb_gsl_matrix_to_i, 0); rb_define_method(cgsl_matrix, "to_f", rb_gsl_matrix_to_f, 0); rb_define_method(cgsl_matrix, "clean", rb_gsl_matrix_clean, -1); rb_define_method(cgsl_matrix, "clean!", rb_gsl_matrix_clean_bang, -1); /*****/ rb_define_method(cgsl_matrix, "add!", rb_gsl_matrix_add_inplace, 1); rb_define_method(cgsl_matrix, "sub!", rb_gsl_matrix_sub_inplace, 1); rb_define_method(cgsl_matrix, "sin", rb_gsl_matrix_sin, 0); rb_define_method(cgsl_matrix, "cos", rb_gsl_matrix_cos, 0); rb_define_method(cgsl_matrix, "tan", rb_gsl_matrix_tan, 0); rb_define_method(cgsl_matrix, "exp", rb_gsl_matrix_exp, 0); rb_define_method(cgsl_matrix, "log", rb_gsl_matrix_log, 0); rb_define_method(cgsl_matrix, "log10", rb_gsl_matrix_log10, 0); rb_define_singleton_method(cgsl_matrix, "rand", rb_gsl_matrix_rand, -1); rb_define_singleton_method(cgsl_matrix, "randn", rb_gsl_matrix_randn, -1); } gsl-1.15.3/ext/sf_trigonometric.c0000644000175000017500000001467312220252463016276 0ustar boutilboutil/* sf_trigonometric.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_sin(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) return rb_gsl_math_complex_eval(gsl_complex_sin, x); return rb_gsl_sf_eval1(gsl_sf_sin, x); } static VALUE rb_gsl_sf_sin_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_sin_e, x); } static VALUE rb_gsl_sf_cos(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) return rb_gsl_math_complex_eval(gsl_complex_cos, x); return rb_gsl_sf_eval1(gsl_sf_cos, x); } static VALUE rb_gsl_sf_cos_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_cos_e, x); } static VALUE rb_gsl_sf_hypot(VALUE obj, VALUE x, VALUE y) { Need_Float(x); Need_Float(y); return rb_float_new(gsl_sf_hypot(NUM2DBL(x), NUM2DBL(y))); } static VALUE rb_gsl_sf_hypot_e(VALUE obj, VALUE x, VALUE y) { return rb_gsl_sf_eval_e_double2(gsl_sf_hypot_e, x, y); } static VALUE rb_gsl_sf_sinc(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_sinc, x); } static VALUE rb_gsl_sf_sinc_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_sinc_e, x); } static VALUE rb_gsl_sf_complex_XXX_e(int argc, VALUE *argv, VALUE obj, int (*f)(double, double, gsl_sf_result*, gsl_sf_result*)) { gsl_sf_result *r1, *r2; gsl_complex *z; double re, im; VALUE v1, v2; // local variable "status" declared and set, but never used //int status; switch (argc) { case 1: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, z); re = GSL_REAL(*z); im = GSL_IMAG(*z); break; case 2: Need_Float(argv[0]); Need_Float(argv[1]); re = NUM2DBL(argv[0]); im = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } v1 = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r1); v2 = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r2); /*status =*/ (*f)(re, im, r1, r2); return rb_ary_new3(2, v1, v2); } static VALUE rb_gsl_sf_complex_sin_e(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_complex_XXX_e(argc, argv, obj, gsl_sf_complex_sin_e); } static VALUE rb_gsl_sf_complex_cos_e(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_complex_XXX_e(argc, argv, obj, gsl_sf_complex_cos_e); } static VALUE rb_gsl_sf_complex_logsin_e(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_complex_XXX_e(argc, argv, obj, gsl_sf_complex_logsin_e); } static VALUE rb_gsl_sf_lnsinh(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_lnsinh, x); } static VALUE rb_gsl_sf_lnsinh_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_lnsinh_e, x); } static VALUE rb_gsl_sf_lncosh(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_lncosh, x); } static VALUE rb_gsl_sf_lncosh_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_lncosh_e, x); } static VALUE rb_gsl_sf_polar_to_rect(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_complex_XXX_e(argc, argv, obj, gsl_sf_polar_to_rect); } static VALUE rb_gsl_sf_rect_to_polar(int argc, VALUE *argv, VALUE obj) { return rb_gsl_sf_complex_XXX_e(argc, argv, obj, gsl_sf_rect_to_polar); } static VALUE rb_gsl_sf_angle_restrict_symm(VALUE obj, VALUE theta) { return rb_gsl_sf_eval1(gsl_sf_angle_restrict_symm, theta); } static VALUE rb_gsl_sf_angle_restrict_pos(VALUE obj, VALUE theta) { return rb_gsl_sf_eval1(gsl_sf_angle_restrict_pos, theta); } /* static VALUE rb_gsl_sf_sin_err(VALUE obj, VALUE x, VALUE dx) { return rb_float_new(gsl_sf_sin_err(NUM2DBL(x), NUM2DBL(dx))); } static VALUE rb_gsl_sf_cos_err(VALUE obj, VALUE x, VALUE dx) { return rb_float_new(gsl_sf_cos_err(NUM2DBL(x), NUM2DBL(dx))); } */ static VALUE rb_gsl_sf_sin_err_e(VALUE obj, VALUE x, VALUE dx) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(dx); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_sin_err_e(NUM2DBL(x), NUM2DBL(dx), rslt); return v; } static VALUE rb_gsl_sf_cos_err_e(VALUE obj, VALUE x, VALUE dx) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(dx); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_cos_err_e(NUM2DBL(x), NUM2DBL(dx), rslt); return v; } void Init_gsl_sf_trigonometric(VALUE module) { rb_define_module_function(module, "sin", rb_gsl_sf_sin, 1); rb_define_module_function(module, "sin_e", rb_gsl_sf_sin_e, 1); rb_define_module_function(module, "cos", rb_gsl_sf_cos, 1); rb_define_module_function(module, "cos_e", rb_gsl_sf_cos_e, 1); rb_define_module_function(module, "hypot", rb_gsl_sf_hypot, 2); rb_define_module_function(module, "hypot_e", rb_gsl_sf_hypot_e, 2); rb_define_module_function(module, "sinc", rb_gsl_sf_sinc, 1); rb_define_module_function(module, "sinc_e", rb_gsl_sf_sinc_e, 1); rb_define_module_function(module, "complex_sin_e", rb_gsl_sf_complex_sin_e, -1); rb_define_module_function(module, "complex_cos_e", rb_gsl_sf_complex_cos_e, -1); rb_define_module_function(module, "complex_logsin_e", rb_gsl_sf_complex_logsin_e, -1); rb_define_module_function(module, "lnsinh", rb_gsl_sf_lnsinh, 1); rb_define_module_function(module, "lnsinh_e", rb_gsl_sf_lnsinh_e, 1); rb_define_module_function(module, "lncosh", rb_gsl_sf_lncosh, 1); rb_define_module_function(module, "lncosh_e", rb_gsl_sf_lncosh_e, 1); rb_define_module_function(module, "polar_to_rect", rb_gsl_sf_polar_to_rect, -1); rb_define_module_function(module, "rect_to_polar", rb_gsl_sf_rect_to_polar, -1); rb_define_module_function(module, "angle_restrict_symm", rb_gsl_sf_angle_restrict_symm, 1); rb_define_module_function(module, "angle_restrict_pos", rb_gsl_sf_angle_restrict_pos, 1); /* rb_define_module_function(module, "sin_err", rb_gsl_sf_sin_err, 2); rb_define_module_function(module, "cos_err", rb_gsl_sf_cos_err, 2);*/ rb_define_module_function(module, "sin_err_e", rb_gsl_sf_sin_err_e, 2); rb_define_module_function(module, "cos_err_e", rb_gsl_sf_cos_err_e, 2); } gsl-1.15.3/ext/root.c0000644000175000017500000003120712220252463013674 0ustar boutilboutil/* root.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_common.h" #include "rb_gsl_function.h" #include "rb_gsl_root.h" EXTERN VALUE cgsl_function_fdf; enum { GSL_ROOT_FSOLVER_BISECTION, GSL_ROOT_FSOLVER_FALSEPOS, GSL_ROOT_FSOLVER_BRENT, GSL_ROOT_FDFSOLVER_NEWTON, GSL_ROOT_FDFSOLVER_SECANT, GSL_ROOT_FDFSOLVER_STEFFENSON, }; /*****/ static VALUE rb_gsl_fsolver_new(VALUE klass, VALUE t) { gsl_root_fsolver *s = NULL; const gsl_root_fsolver_type *T; char name[32]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (!str_tail_grep(name, "bisection")) { T = gsl_root_fsolver_bisection; } else if (!str_tail_grep(name, "falsepos")) { T = gsl_root_fsolver_falsepos; } else if (!str_tail_grep(name, "brent")) { T = gsl_root_fsolver_brent; } else { rb_raise(rb_eTypeError, "type must be \"bisection\" or \"falsepos\", or \"brent\"."); } break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_ROOT_FSOLVER_BISECTION: T = gsl_root_fsolver_bisection; break; case GSL_ROOT_FSOLVER_FALSEPOS: T = gsl_root_fsolver_falsepos; break; case GSL_ROOT_FSOLVER_BRENT: T = gsl_root_fsolver_brent; break; default: rb_raise(rb_eTypeError, "type must be BISECTION or FALSEPOS, or BRENT."); break; } break; default: rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)", rb_class2name(CLASS_OF(t))); break; } s = gsl_root_fsolver_alloc(T); return Data_Wrap_Struct(klass, 0, gsl_root_fsolver_free, s); } static VALUE rb_gsl_fsolver_set(VALUE obj, VALUE func, VALUE xl, VALUE xh) { gsl_root_fsolver *s = NULL; gsl_function *fff = NULL; double xlow, xup; Need_Float(xl); Need_Float(xh); CHECK_FUNCTION(func); Data_Get_Struct(obj, gsl_root_fsolver, s); Data_Get_Struct(func, gsl_function, fff); xlow = NUM2DBL(xl); xup = NUM2DBL(xh); gsl_root_fsolver_set(s, fff, xlow, xup); return obj; } static VALUE rb_gsl_fsolver_iterate(VALUE obj) { gsl_root_fsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fsolver, s); return INT2FIX(gsl_root_fsolver_iterate(s)); } static VALUE rb_gsl_fsolver_root(VALUE obj) { gsl_root_fsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fsolver, s); return rb_float_new(gsl_root_fsolver_root(s)); } static VALUE rb_gsl_fsolver_x_lower(VALUE obj) { gsl_root_fsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fsolver, s); return rb_float_new(gsl_root_fsolver_x_lower(s)); } static VALUE rb_gsl_fsolver_x_upper(VALUE obj) { gsl_root_fsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fsolver, s); return rb_float_new(gsl_root_fsolver_x_upper(s)); } static VALUE rb_gsl_fsolver_name(VALUE obj) { gsl_root_fsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fsolver, s); return rb_str_new2(gsl_root_fsolver_name(s)); } static VALUE rb_gsl_fsolver_test_interval(VALUE obj, VALUE eabs, VALUE erel) { gsl_root_fsolver *s = NULL; Need_Float(eabs); Need_Float(erel); Data_Get_Struct(obj, gsl_root_fsolver, s); return INT2FIX(gsl_root_test_interval(s->x_lower, s->x_upper, NUM2DBL(eabs), NUM2DBL(erel))); } static VALUE rb_gsl_root_test_interval(VALUE obj, VALUE xl, VALUE xu, VALUE eabs, VALUE erel) { Need_Float(xl); Need_Float(xu); Need_Float(eabs); Need_Float(erel); return INT2FIX(gsl_root_test_interval(NUM2DBL(xl), NUM2DBL(xu), NUM2DBL(eabs), NUM2DBL(erel))); } static VALUE rb_gsl_root_test_delta(VALUE obj, VALUE xl, VALUE xu, VALUE eabs, VALUE erel) { Need_Float(xl); Need_Float(xu); Need_Float(eabs); Need_Float(erel); return INT2FIX(gsl_root_test_delta(NUM2DBL(xl), NUM2DBL(xu), NUM2DBL(eabs), NUM2DBL(erel))); } static VALUE rb_gsl_root_test_residual(VALUE obj, VALUE xl,VALUE eabs) { Need_Float(xl); Need_Float(eabs); return INT2FIX(gsl_root_test_residual(NUM2DBL(xl), NUM2DBL(eabs))); } static VALUE rb_gsl_fsolver_solve(int argc, VALUE *argv, VALUE *obj) { gsl_root_fsolver *s = NULL; gsl_function *F = NULL; double x, xl, xh, epsabs = 0.0, epsrel = 1e-6; int status, iter = 0, max_iter = 100; switch (argc) { case 3: Check_Type(argv[2], T_ARRAY); epsabs = NUM2DBL(rb_ary_entry(argv[2], 0)); epsrel = NUM2DBL(rb_ary_entry(argv[2], 1)); /* no break */ case 2: Check_Type(argv[1], T_ARRAY); xl = NUM2DBL(rb_ary_entry(argv[1], 0)); xh = NUM2DBL(rb_ary_entry(argv[1], 1)); break; default: rb_raise(rb_eArgError, "Usage: solve(f = Function, range = Array, eps = Array)"); break; } CHECK_FUNCTION(argv[0]); Data_Get_Struct(argv[0], gsl_function, F); Data_Get_Struct(obj, gsl_root_fsolver, s); gsl_root_fsolver_set(s, F, xl, xh); do { iter++; status = gsl_root_fsolver_iterate (s); x = gsl_root_fsolver_root (s); xl = gsl_root_fsolver_x_lower (s); xh = gsl_root_fsolver_x_upper (s); status = gsl_root_test_interval (xl, xh, epsabs, epsrel); if (status == GSL_SUCCESS) break; } while (status == GSL_CONTINUE && iter < max_iter); return rb_ary_new3(3, rb_float_new(x), INT2FIX(iter), INT2FIX(status)); } static VALUE rb_gsl_fdfsolver_new(VALUE klass, VALUE t) { gsl_root_fdfsolver *s = NULL; const gsl_root_fdfsolver_type *T; char name[32]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (!str_tail_grep(name, "newton")) { T = gsl_root_fdfsolver_newton; } else if (!str_tail_grep(name, "secant")) { T = gsl_root_fdfsolver_secant; } else if (!str_tail_grep(name, "steffenson")) { T = gsl_root_fdfsolver_steffenson; } else { rb_raise(rb_eTypeError, "type must be NEWTON or SECANT, or STEFFENSON."); } break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_ROOT_FDFSOLVER_NEWTON: T = gsl_root_fdfsolver_newton; break; case GSL_ROOT_FDFSOLVER_SECANT: T = gsl_root_fdfsolver_secant; break; case GSL_ROOT_FDFSOLVER_STEFFENSON: T = gsl_root_fdfsolver_steffenson; break; default: rb_raise(rb_eTypeError, "type must be NEWTON or SECANT, or STEFFENSON."); break; } break; default: rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)", rb_class2name(CLASS_OF(t))); break; } s = gsl_root_fdfsolver_alloc(T); return Data_Wrap_Struct(klass, 0, gsl_root_fdfsolver_free, s); } static VALUE rb_gsl_fdfsolver_set(VALUE obj, VALUE func, VALUE r) { gsl_root_fdfsolver *s = NULL; gsl_function_fdf *fff = NULL; double root; CHECK_FUNCTION_FDF(func); Data_Get_Struct(obj, gsl_root_fdfsolver, s); Data_Get_Struct(func, gsl_function_fdf, fff); root = NUM2DBL(r); gsl_root_fdfsolver_set(s, fff, root); return obj; } static VALUE rb_gsl_fdfsolver_iterate(VALUE obj) { gsl_root_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fdfsolver, s); return INT2FIX(gsl_root_fdfsolver_iterate(s)); } static VALUE rb_gsl_fdfsolver_root(VALUE obj) { gsl_root_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fdfsolver, s); return rb_float_new(gsl_root_fdfsolver_root(s)); } static VALUE rb_gsl_fdfsolver_name(VALUE obj) { gsl_root_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_root_fdfsolver, s); return rb_str_new2(gsl_root_fdfsolver_name(s)); } static VALUE rb_gsl_fdfsolver_solve(int argc, VALUE *argv, VALUE *obj) { gsl_root_fdfsolver *s = NULL; double x = 0.0, x0, epsabs = 0.0, epsrel = 1e-6; gsl_function_fdf *F = NULL; int status, iter = 0, max_iter = 100; switch (argc) { case 3: Check_Type(argv[2], T_ARRAY); epsabs = NUM2DBL(rb_ary_entry(argv[2], 0)); epsrel = NUM2DBL(rb_ary_entry(argv[2], 1)); /* no break */ case 2: Need_Float(argv[1]); x0 = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Usage: solve(f = Function, range = Array, eps = Array)"); break; } CHECK_FUNCTION_FDF(argv[0]); Data_Get_Struct(argv[0], gsl_function_fdf, F); Data_Get_Struct(obj, gsl_root_fdfsolver, s); gsl_root_fdfsolver_set(s, F, x0); do { iter++; status = gsl_root_fdfsolver_iterate (s); x0 = x; x = gsl_root_fdfsolver_root (s); status = gsl_root_test_delta(x, x0, epsabs, epsrel); if (status == GSL_SUCCESS) break; } while (status == GSL_CONTINUE && iter < max_iter); return rb_ary_new3(3, rb_float_new(x), INT2FIX(iter), INT2FIX(status)); } static VALUE rb_gsl_function_rootfinder(int argc, VALUE *argv, VALUE obj) { int status, iter = 0, max_iter = 1000; const gsl_root_fsolver_type *T; gsl_root_fsolver *s = NULL; gsl_function *F = NULL; double r, a, b, epsabs = 0.0, epsrel = 1e-6; Data_Get_Struct(obj, gsl_function, F); switch (argc) { case 2: a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: a = NUM2DBL(rb_ary_entry(argv[0], 0)); b = NUM2DBL(rb_ary_entry(argv[0], 1)); break; default: rb_raise(rb_eTypeError, "interval must be given by an array [a, b]"); } break; default: rb_raise(rb_eArgError, "interval must be given"); break; } T = gsl_root_fsolver_brent; s = gsl_root_fsolver_alloc (T); gsl_root_fsolver_set (s, F, a, b); do { iter++; status = gsl_root_fsolver_iterate (s); r = gsl_root_fsolver_root (s); a = gsl_root_fsolver_x_lower (s); b = gsl_root_fsolver_x_upper (s); status = gsl_root_test_interval (a, b, epsabs, epsrel); if (status == GSL_SUCCESS) break; } while (status == GSL_CONTINUE && iter < max_iter); gsl_root_fsolver_free(s); if (status == GSL_SUCCESS) { return rb_ary_new3(3, rb_float_new(r), INT2FIX(iter), INT2FIX(status)); } else { printf("not converged\n"); return Qfalse; } } void Init_gsl_root(VALUE module) { VALUE mgsl_root; VALUE cgsl_fsolver; VALUE cgsl_fdfsolver; mgsl_root = rb_define_module_under(module, "Root"); cgsl_fsolver = rb_define_class_under(mgsl_root, "FSolver", cGSL_Object); rb_define_singleton_method(cgsl_fsolver, "alloc", rb_gsl_fsolver_new, 1); rb_define_method(cgsl_fsolver, "set", rb_gsl_fsolver_set, 3); rb_define_method(cgsl_fsolver, "iterate", rb_gsl_fsolver_iterate, 0); rb_define_method(cgsl_fsolver, "root", rb_gsl_fsolver_root, 0); rb_define_method(cgsl_fsolver, "name", rb_gsl_fsolver_name, 0); rb_define_method(cgsl_fsolver, "x_lower", rb_gsl_fsolver_x_lower, 0); rb_define_method(cgsl_fsolver, "x_upper", rb_gsl_fsolver_x_upper, 0); rb_define_method(cgsl_fsolver, "test_interval", rb_gsl_fsolver_test_interval, 2); rb_define_method(cgsl_fsolver, "solve", rb_gsl_fsolver_solve, -1); rb_define_singleton_method(mgsl_root, "test_interval", rb_gsl_root_test_interval, 4); rb_define_singleton_method(mgsl_root, "test_delta", rb_gsl_root_test_delta, 4); rb_define_singleton_method(mgsl_root, "test_residual", rb_gsl_root_test_residual, 2); cgsl_fdfsolver = rb_define_class_under(mgsl_root, "FdfSolver", cGSL_Object); rb_define_singleton_method(cgsl_fdfsolver, "alloc", rb_gsl_fdfsolver_new, 1); rb_define_method(cgsl_fdfsolver, "set", rb_gsl_fdfsolver_set, 2); rb_define_method(cgsl_fdfsolver, "iterate", rb_gsl_fdfsolver_iterate, 0); rb_define_method(cgsl_fdfsolver, "root", rb_gsl_fdfsolver_root, 0); rb_define_method(cgsl_fdfsolver, "name", rb_gsl_fdfsolver_name, 0); rb_define_method(cgsl_fdfsolver, "solve", rb_gsl_fdfsolver_solve, -1); rb_define_method(cgsl_function, "fsolve", rb_gsl_function_rootfinder, -1); rb_define_alias(cgsl_function, "solve", "fsolve"); rb_define_const(cgsl_fsolver, "BISECTION", INT2FIX(GSL_ROOT_FSOLVER_BISECTION)); rb_define_const(cgsl_fsolver, "FALSEPOS", INT2FIX(GSL_ROOT_FSOLVER_FALSEPOS)); rb_define_const(cgsl_fsolver, "BRENT", INT2FIX(GSL_ROOT_FSOLVER_BRENT)); rb_define_const(cgsl_fsolver, "Bisection", INT2FIX(GSL_ROOT_FSOLVER_BISECTION)); rb_define_const(cgsl_fsolver, "Falsepos", INT2FIX(GSL_ROOT_FSOLVER_FALSEPOS)); rb_define_const(cgsl_fsolver, "Brent", INT2FIX(GSL_ROOT_FSOLVER_BRENT)); rb_define_const(cgsl_fdfsolver, "NEWTON", INT2FIX(GSL_ROOT_FDFSOLVER_NEWTON)); rb_define_const(cgsl_fdfsolver, "SECANT", INT2FIX(GSL_ROOT_FDFSOLVER_SECANT)); rb_define_const(cgsl_fdfsolver, "STEFFENSON", INT2FIX(GSL_ROOT_FDFSOLVER_STEFFENSON)); rb_define_const(cgsl_fdfsolver, "Newton", INT2FIX(GSL_ROOT_FDFSOLVER_NEWTON)); rb_define_const(cgsl_fdfsolver, "Secant", INT2FIX(GSL_ROOT_FDFSOLVER_SECANT)); rb_define_const(cgsl_fdfsolver, "Steffenson", INT2FIX(GSL_ROOT_FDFSOLVER_STEFFENSON)); } gsl-1.15.3/ext/monte.c0000644000175000017500000010244212220252463014033 0ustar boutilboutil/* monte.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_rng.h" #include #include #include #ifndef CHECK_MONTE_FUNCTION #define CHECK_MONTE_FUNCTION(x) if(!rb_obj_is_kind_of(x,cgsl_monte_function))\ rb_raise(rb_eTypeError, "wrong type (Function expected)"); #endif static VALUE cgsl_monte_plain; static VALUE cgsl_monte_miser; static VALUE cgsl_monte_vegas; static VALUE cgsl_monte_function; #ifdef GSL_1_13_LATER static VALUE cgsl_monte_miser_params, cgsl_monte_vegas_params; #endif EXTERN VALUE cgsl_vector; enum { GSL_MONTE_PLAIN_STATE = 1, GSL_MONTE_MISER_STATE = 2, GSL_MONTE_VEGAS_STATE = 3, }; static void gsl_monte_function_mark(gsl_monte_function *f); static void gsl_monte_function_free(gsl_monte_function *f); static double rb_gsl_monte_function_f(double *x, size_t dim, void *p); static VALUE rb_gsl_monte_function_set_f(int argc, VALUE *argv, VALUE obj) { gsl_monte_function *F = NULL; VALUE ary, ary2; size_t i; Data_Get_Struct(obj, gsl_monte_function, F); if (F->params == NULL) { ary = rb_ary_new2(2); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 1, Qnil); switch (argc) { case 0: break; case 1: if (TYPE(argv[0]) == T_FIXNUM) { F->dim = FIX2INT(argv[0]); } else { rb_ary_store(ary, 0, argv[0]); } break; case 2: rb_ary_store(ary, 0, argv[0]); F->dim = FIX2INT(argv[1]); break; default: rb_ary_store(ary, 0, argv[0]); F->dim = FIX2INT(argv[1]); ary2 = rb_ary_new2(argc-2); for (i = 2; i < argc; i++) rb_ary_store(ary2, i-2, argv[i]); rb_ary_store(ary, 1, ary2); break; } if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); return obj; } static void gsl_monte_function_free(gsl_monte_function *f) { free((gsl_monte_function *) f); } static void gsl_monte_function_mark(gsl_monte_function *f) { rb_gc_mark((VALUE) f->params); } static VALUE rb_gsl_monte_function_new(int argc, VALUE *argv, VALUE klass) { gsl_monte_function *f; VALUE obj; f = ALLOC(gsl_monte_function); f->f = &rb_gsl_monte_function_f; /* (VALUE) f->params = rb_ary_new2(2);*/ f->params = (void *) rb_ary_new2(2); rb_ary_store((VALUE) f->params, 1, Qnil); obj = Data_Wrap_Struct(klass, gsl_monte_function_mark, gsl_monte_function_free, f); rb_gsl_monte_function_set_f(argc, argv, obj); return obj; } static double rb_gsl_monte_function_f(double *x, size_t dim, void *p) { VALUE result, ary, proc, params; gsl_vector vtmp; VALUE vx; vtmp.data = x; vtmp.size = dim; vtmp.stride = 1; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, &vtmp); ary = (VALUE) p; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 2, vx, INT2FIX(dim)); else result = rb_funcall(proc, RBGSL_ID_call, 3, vx, INT2FIX(dim), params); return NUM2DBL(result); } static VALUE rb_gsl_monte_function_eval(VALUE obj, VALUE vx) { gsl_monte_function *F = NULL; VALUE result, ary, proc, params; Data_Get_Struct(obj, gsl_monte_function, F); ary = (VALUE) F->params; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 2, vx, INT2FIX(F->dim)); else result = rb_funcall(proc, RBGSL_ID_call, 3, vx, INT2FIX(F->dim), params); return result; } static VALUE rb_gsl_monte_function_proc(VALUE obj) { gsl_monte_function *F = NULL; Data_Get_Struct(obj, gsl_monte_function, F); return rb_ary_entry((VALUE) F->params, 0); } static VALUE rb_gsl_monte_function_params(VALUE obj) { gsl_monte_function *F = NULL; Data_Get_Struct(obj, gsl_monte_function, F); return rb_ary_entry((VALUE) F->params, 1); } static VALUE rb_gsl_monte_function_set_params(int argc, VALUE *argv, VALUE obj) { gsl_monte_function *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_monte_function, F); ary = (VALUE) F->params; if (argc == 1) { rb_ary_store(ary, 1, argv[0]); } else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 1, ary2); } return obj; } static VALUE rb_gsl_monte_plain_new(VALUE klass, VALUE d) { gsl_monte_plain_state *s; size_t dim; CHECK_FIXNUM(d); dim = FIX2INT(d); s = gsl_monte_plain_alloc(dim); gsl_monte_plain_init(s); return Data_Wrap_Struct(klass, 0, gsl_monte_plain_free, s); } static VALUE rb_gsl_monte_plain_init(VALUE obj) { gsl_monte_plain_state *s; Data_Get_Struct(obj, gsl_monte_plain_state, s); return INT2FIX(gsl_monte_plain_init(s)); } static VALUE rb_gsl_monte_miser_new(VALUE klass, VALUE d) { gsl_monte_miser_state *s; size_t dim; CHECK_FIXNUM(d); dim = FIX2INT(d); s = gsl_monte_miser_alloc(dim); gsl_monte_miser_init(s); return Data_Wrap_Struct(klass, 0, gsl_monte_miser_free, s); } static VALUE rb_gsl_monte_miser_init(VALUE obj) { gsl_monte_miser_state *s; Data_Get_Struct(obj, gsl_monte_miser_state, s); return INT2FIX(gsl_monte_miser_init(s)); } static VALUE rb_gsl_monte_vegas_new(VALUE klass, VALUE d) { gsl_monte_vegas_state *s; size_t dim; CHECK_FIXNUM(d); dim = FIX2INT(d); s = gsl_monte_vegas_alloc(dim); gsl_monte_vegas_init(s); return Data_Wrap_Struct(klass, 0, gsl_monte_vegas_free, s); } static VALUE rb_gsl_monte_vegas_init(VALUE obj) { gsl_monte_vegas_state *s; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return INT2FIX(gsl_monte_vegas_init(s)); } static int get_monte_type(VALUE vt); static VALUE rb_gsl_monte_integrate(int argc, VALUE *argv, VALUE obj) { gsl_monte_function *F = NULL; gsl_monte_plain_state *plain = NULL; gsl_monte_miser_state *miser = NULL; gsl_monte_vegas_state *vegas = NULL; gsl_vector *xl = NULL, *xu = NULL; gsl_rng *r = NULL; size_t dim, calls; int itmp = 0, flagr = 0, type; double result, abserr; if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (!rb_obj_is_kind_of(argv[0], cgsl_monte_function)) rb_raise(rb_eTypeError, "wrong type argument %s (GSL::Monte::Function expected)", rb_class2name(CLASS_OF(argv[0]))); Data_Get_Struct(argv[0], gsl_monte_function, F); itmp = 1; break; default: Data_Get_Struct(obj, gsl_monte_function, F); itmp = 0; } CHECK_VECTOR(argv[itmp]); CHECK_VECTOR(argv[itmp+1]); Data_Get_Struct(argv[itmp], gsl_vector, xl); Data_Get_Struct(argv[itmp+1], gsl_vector, xu); if (argc > itmp+3 && TYPE(argv[itmp+3]) == T_FIXNUM) { dim = FIX2INT(argv[itmp+2]); calls = FIX2INT(argv[itmp+3]); } else { dim = F->dim; calls = FIX2INT(argv[itmp+2]); } if (rb_obj_is_kind_of(argv[argc-2], cgsl_rng)) { Data_Get_Struct(argv[argc-2], gsl_rng, r); } else { r = gsl_rng_alloc(gsl_rng_default); flagr = 1; } type = get_monte_type(argv[argc-1]); switch (type) { case GSL_MONTE_PLAIN_STATE: case GSL_MONTE_PLAIN_STATE+100: if (type > 100) { plain = gsl_monte_plain_alloc(dim); gsl_monte_plain_init(plain); } else { if (!rb_obj_is_kind_of(argv[argc-1], cgsl_monte_plain)) rb_raise(rb_eTypeError, "wrong argument type %s (Monte::Plain expected)", rb_class2name(CLASS_OF(argv[argc-1]))); Data_Get_Struct(argv[argc-1], gsl_monte_plain_state, plain); } gsl_monte_plain_integrate(F, xl->data, xu->data, dim, calls, r, plain, &result, &abserr); if (type > 100) gsl_monte_plain_free(plain); break; case GSL_MONTE_MISER_STATE: case GSL_MONTE_MISER_STATE+100: if (type > 100) { miser = gsl_monte_miser_alloc(dim); gsl_monte_miser_init(miser); } else { if (!rb_obj_is_kind_of(argv[argc-1], cgsl_monte_miser)) rb_raise(rb_eTypeError, "wrong argument type %s (Monte::Miser expected)", rb_class2name(CLASS_OF(argv[argc-1]))); Data_Get_Struct(argv[argc-1], gsl_monte_miser_state, miser); } gsl_monte_miser_integrate(F, xl->data, xu->data, dim, calls, r, miser, &result, &abserr); if (type > 100) gsl_monte_miser_free(miser); break; case GSL_MONTE_VEGAS_STATE: case GSL_MONTE_VEGAS_STATE+100: if (type > 100) { vegas = gsl_monte_vegas_alloc(dim); gsl_monte_vegas_init(vegas); } else { if (!rb_obj_is_kind_of(argv[argc-1], cgsl_monte_vegas)) rb_raise(rb_eTypeError, "wrong argument type %s (Monte::Vegas expected)", rb_class2name(CLASS_OF(argv[argc-1]))); Data_Get_Struct(argv[argc-1], gsl_monte_vegas_state, vegas); } gsl_monte_vegas_integrate(F, xl->data, xu->data, dim, calls, r, vegas, &result, &abserr); if (type > 100) gsl_monte_vegas_free(vegas); break; } if (flagr == 1) gsl_rng_free(r); return rb_ary_new3(2, rb_float_new(result), rb_float_new(abserr)); } static VALUE rb_gsl_monte_plain_integrate(int argc, VALUE *argv, VALUE obj) { gsl_monte_function *F = NULL; gsl_monte_plain_state *plain = NULL; gsl_vector *xl = NULL, *xu = NULL; gsl_rng *r = NULL; size_t dim, calls; int flagr = 0; double result, abserr; if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4, 5 or 6)", argc); CHECK_MONTE_FUNCTION(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(obj, gsl_monte_plain_state, plain); Data_Get_Struct(argv[0], gsl_monte_function, F); Data_Get_Struct(argv[1], gsl_vector, xl); Data_Get_Struct(argv[2], gsl_vector, xu); if (argc >= 5 && TYPE(argv[4]) == T_FIXNUM) { dim = FIX2INT(argv[3]); calls = FIX2INT(argv[4]); } else { dim = F->dim; calls = FIX2INT(argv[3]); } if (rb_obj_is_kind_of(argv[argc-1], cgsl_rng)) { Data_Get_Struct(argv[argc-1], gsl_rng, r); } else { r = gsl_rng_alloc(gsl_rng_default); flagr = 1; } gsl_monte_plain_integrate(F, xl->data, xu->data, dim, calls, r, plain, &result, &abserr); if (flagr == 1) gsl_rng_free(r); return rb_ary_new3(2, rb_float_new(result), rb_float_new(abserr)); } static VALUE rb_gsl_monte_miser_integrate(int argc, VALUE *argv, VALUE obj) { gsl_monte_function *F = NULL; gsl_monte_miser_state *miser = NULL; gsl_vector *xl = NULL, *xu = NULL; gsl_rng *r = NULL; size_t dim, calls; int flagr = 0; double result, abserr; if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_MONTE_FUNCTION(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(obj, gsl_monte_miser_state, miser); Data_Get_Struct(argv[0], gsl_monte_function, F); Data_Get_Struct(argv[1], gsl_vector, xl); Data_Get_Struct(argv[2], gsl_vector, xu); if (argc >= 5 && TYPE(argv[4]) == T_FIXNUM) { dim = FIX2INT(argv[3]); calls = FIX2INT(argv[4]); } else { dim = F->dim; calls = FIX2INT(argv[3]); } if (rb_obj_is_kind_of(argv[argc-1], cgsl_rng)) { Data_Get_Struct(argv[argc-1], gsl_rng, r); } else { r = gsl_rng_alloc(gsl_rng_default); flagr = 1; } gsl_monte_miser_integrate(F, xl->data, xu->data, dim, calls, r, miser, &result, &abserr); if (flagr == 1) gsl_rng_free(r); return rb_ary_new3(2, rb_float_new(result), rb_float_new(abserr)); } static VALUE rb_gsl_monte_vegas_integrate(int argc, VALUE *argv, VALUE obj) { gsl_monte_function *F = NULL; gsl_monte_vegas_state *vegas = NULL; gsl_vector *xl = NULL, *xu = NULL; gsl_rng *r = NULL; size_t dim, calls; int flagr = 0; double result, abserr; if (argc < 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 4)", argc); CHECK_MONTE_FUNCTION(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(obj, gsl_monte_vegas_state, vegas); Data_Get_Struct(argv[0], gsl_monte_function, F); Data_Get_Struct(argv[1], gsl_vector, xl); Data_Get_Struct(argv[2], gsl_vector, xu); if (argc >= 5 && TYPE(argv[4]) == T_FIXNUM) { dim = FIX2INT(argv[3]); calls = FIX2INT(argv[4]); } else { dim = F->dim; calls = FIX2INT(argv[3]); } if (rb_obj_is_kind_of(argv[argc-1], cgsl_rng)) { Data_Get_Struct(argv[argc-1], gsl_rng, r); } else { r = gsl_rng_alloc(gsl_rng_default); flagr = 1; } gsl_monte_vegas_integrate(F, xl->data, xu->data, dim, calls, r, vegas, &result, &abserr); if (flagr == 1) gsl_rng_free(r); return rb_ary_new3(2, rb_float_new(result), rb_float_new(abserr)); } static int get_monte_type(VALUE vt) { char name[32]; if (rb_obj_is_kind_of(vt, cgsl_monte_plain)) return GSL_MONTE_PLAIN_STATE; else if (rb_obj_is_kind_of(vt, cgsl_monte_miser)) return GSL_MONTE_MISER_STATE; else if (rb_obj_is_kind_of(vt, cgsl_monte_vegas)) return GSL_MONTE_VEGAS_STATE; else { /* do next */ } switch(TYPE(vt)) { case T_STRING: strcpy(name, STR2CSTR(vt)); if (str_tail_grep(name, "plain") == 0) { return GSL_MONTE_PLAIN_STATE + 100; } else if (str_tail_grep(name, "miser") == 0) { return GSL_MONTE_MISER_STATE + 100; } else if (str_tail_grep(name, "vegas") == 0) { return GSL_MONTE_VEGAS_STATE + 100; } else { rb_raise(rb_eArgError, "%s: unknown algorithm", name); } break; case T_FIXNUM: return FIX2INT(vt) + 100; break; default: rb_raise(rb_eTypeError, "String or Fixnum expected"); break; } /* wrong argument if reach here */ rb_raise(rb_eArgError, "wrong argument"); } static VALUE rb_gsl_monte_miser_estimate_frac(VALUE obj) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); return rb_float_new(s->estimate_frac); } static VALUE rb_gsl_monte_miser_set_estimate_frac(VALUE obj, VALUE val) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); s->estimate_frac = NUM2DBL(val); return obj; } static VALUE rb_gsl_monte_miser_min_calls(VALUE obj) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); return INT2FIX(s->min_calls); } static VALUE rb_gsl_monte_miser_set_min_calls(VALUE obj, VALUE val) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); s->min_calls = FIX2INT(val); return obj; } static VALUE rb_gsl_monte_miser_min_calls_per_bisection(VALUE obj) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); return INT2FIX(s->min_calls_per_bisection); } static VALUE rb_gsl_monte_miser_set_min_calls_per_bisection(VALUE obj, VALUE val) { gsl_monte_miser_state *s = NULL; CHECK_FIXNUM(val); Data_Get_Struct(obj, gsl_monte_miser_state, s); s->min_calls_per_bisection = FIX2INT(val); return obj; } static VALUE rb_gsl_monte_miser_alpha(VALUE obj) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); return rb_float_new(s->alpha); } static VALUE rb_gsl_monte_miser_set_alpha(VALUE obj, VALUE val) { gsl_monte_miser_state *s = NULL; Need_Float(val); Data_Get_Struct(obj, gsl_monte_miser_state, s); s->alpha = NUM2DBL(val); return obj; } static VALUE rb_gsl_monte_miser_dither(VALUE obj) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); return rb_float_new(s->dither); } static VALUE rb_gsl_monte_miser_set_dither(VALUE obj, VALUE val) { gsl_monte_miser_state *s = NULL; Need_Float(val); Data_Get_Struct(obj, gsl_monte_miser_state, s); s->dither = NUM2DBL(val); return obj; } static VALUE rb_gsl_monte_miser_state(VALUE obj) { gsl_monte_miser_state *s = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); return rb_ary_new3(5, rb_float_new(s->estimate_frac), INT2FIX(s->min_calls), INT2FIX(s->min_calls_per_bisection), rb_float_new(s->alpha), rb_float_new(s->dither)); } static VALUE rb_gsl_monte_vegas_result(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return rb_float_new(s->result); } static VALUE rb_gsl_monte_vegas_sigma(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return rb_float_new(s->sigma); } static VALUE rb_gsl_monte_vegas_chisq(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return rb_float_new(s->chisq); } static VALUE rb_gsl_monte_vegas_alpha(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return rb_float_new(s->alpha); } static VALUE rb_gsl_monte_vegas_set_alpha(VALUE obj, VALUE val) { gsl_monte_vegas_state *s = NULL; Need_Float(val); Data_Get_Struct(obj, gsl_monte_vegas_state, s); s->alpha = NUM2DBL(val); return obj; } static VALUE rb_gsl_monte_vegas_iterations(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return INT2FIX(s->iterations); } static VALUE rb_gsl_monte_vegas_set_iterations(VALUE obj, VALUE val) { gsl_monte_vegas_state *s = NULL; CHECK_FIXNUM(val); Data_Get_Struct(obj, gsl_monte_vegas_state, s); s->iterations = FIX2INT(val); return obj; } static VALUE rb_gsl_monte_vegas_stage(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return INT2FIX(s->stage); } static VALUE rb_gsl_monte_vegas_set_stage(VALUE obj, VALUE val) { gsl_monte_vegas_state *s = NULL; CHECK_FIXNUM(val); Data_Get_Struct(obj, gsl_monte_vegas_state, s); s->stage = FIX2INT(val); return obj; } static VALUE rb_gsl_monte_vegas_mode(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return INT2FIX(s->mode); } static VALUE rb_gsl_monte_vegas_set_mode(VALUE obj, VALUE val) { gsl_monte_vegas_state *s = NULL; CHECK_FIXNUM(val); Data_Get_Struct(obj, gsl_monte_vegas_state, s); s->mode = FIX2INT(val); return obj; } static VALUE rb_gsl_monte_vegas_verbose(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return INT2FIX(s->verbose); } static VALUE rb_gsl_monte_vegas_set_verbose(VALUE obj, VALUE val) { gsl_monte_vegas_state *s = NULL; CHECK_FIXNUM(val); Data_Get_Struct(obj, gsl_monte_vegas_state, s); s->verbose = FIX2INT(val); return obj; } static VALUE rb_gsl_monte_vegas_state(VALUE obj) { gsl_monte_vegas_state *s = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); return rb_ary_new3(8, rb_float_new(s->result), rb_float_new(s->sigma), rb_float_new(s->chisq), rb_float_new(s->alpha), INT2FIX(s->iterations), INT2FIX(s->stage), INT2FIX(s->mode), INT2FIX(s->verbose)); } #ifdef GSL_1_13_LATER static VALUE rb_gsl_monte_miser_params_get(VALUE obj) { gsl_monte_miser_state *s = NULL; gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); p = (gsl_monte_miser_params *) malloc(sizeof(gsl_monte_miser_params)); gsl_monte_miser_params_get(s, p); return Data_Wrap_Struct(cgsl_monte_miser_params, 0, free, p); } static VALUE rb_gsl_monte_miser_params_set(VALUE obj, VALUE params) { gsl_monte_miser_state *s = NULL; gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_state, s); Data_Get_Struct(params, gsl_monte_miser_params, p); gsl_monte_miser_params_set(s, p); return Qtrue; } static VALUE rb_gsl_monte_miser_params_get_estimate_frac(VALUE obj) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); return rb_float_new(p->estimate_frac); } static VALUE rb_gsl_monte_miser_params_set_estimate_frac(VALUE obj, VALUE val) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); p->estimate_frac = NUM2DBL(val); return val; } static VALUE rb_gsl_monte_miser_params_get_min_calls(VALUE obj) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); return INT2FIX(p->min_calls); } static VALUE rb_gsl_monte_miser_params_set_min_calls(VALUE obj, VALUE val) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); p->min_calls = (size_t) FIX2INT(val); return val; } static VALUE rb_gsl_monte_miser_params_get_min_calls_per_bisection(VALUE obj) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); return INT2FIX(p->min_calls_per_bisection); } static VALUE rb_gsl_monte_miser_params_set_min_calls_per_bisection(VALUE obj, VALUE val) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); p->min_calls_per_bisection = (size_t) FIX2INT(val); return val; } static VALUE rb_gsl_monte_miser_params_get_alpha(VALUE obj) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); return rb_float_new(p->alpha); } static VALUE rb_gsl_monte_miser_params_set_alpha(VALUE obj, VALUE val) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); p->alpha = NUM2DBL(val); return val; } static VALUE rb_gsl_monte_miser_params_get_dither(VALUE obj) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); return rb_float_new(p->dither); } static VALUE rb_gsl_monte_miser_params_set_dither(VALUE obj, VALUE val) { gsl_monte_miser_params *p = NULL; Data_Get_Struct(obj, gsl_monte_miser_params, p); p->dither = NUM2DBL(val); return val; } static VALUE rb_gsl_monte_vegas_params_get(VALUE obj) { gsl_monte_vegas_state *s = NULL; gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); p = (gsl_monte_vegas_params *) malloc(sizeof(gsl_monte_vegas_params)); gsl_monte_vegas_params_get(s, p); return Data_Wrap_Struct(cgsl_monte_vegas_params, 0, free, p); } static VALUE rb_gsl_monte_vegas_params_set(VALUE obj, VALUE params) { gsl_monte_vegas_state *s = NULL; gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_state, s); Data_Get_Struct(params, gsl_monte_vegas_params, p); gsl_monte_vegas_params_set(s, p); return Qtrue; } static VALUE rb_gsl_monte_vegas_params_get_alpha(VALUE obj) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); return rb_float_new(p->alpha); } static VALUE rb_gsl_monte_vegas_params_set_alpha(VALUE obj, VALUE val) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); p->alpha = NUM2DBL(val); return val; } static VALUE rb_gsl_monte_vegas_params_get_iterations(VALUE obj) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); return INT2FIX(p->iterations); } static VALUE rb_gsl_monte_vegas_params_set_iterations(VALUE obj, VALUE val) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); p->iterations = (size_t) FIX2INT(val); return val; } static VALUE rb_gsl_monte_vegas_params_get_stage(VALUE obj) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); return INT2FIX(p->stage); } static VALUE rb_gsl_monte_vegas_params_set_stage(VALUE obj, VALUE val) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); p->stage = FIX2INT(val); return val; } static VALUE rb_gsl_monte_vegas_params_get_mode(VALUE obj) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); return INT2FIX(p->mode); } static VALUE rb_gsl_monte_vegas_params_set_mode(VALUE obj, VALUE val) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); p->mode = FIX2INT(val); return val; } static VALUE rb_gsl_monte_vegas_params_get_verbose(VALUE obj) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); return INT2FIX(p->verbose); } static VALUE rb_gsl_monte_vegas_params_set_verbose(VALUE obj, VALUE val) { gsl_monte_vegas_params *p = NULL; Data_Get_Struct(obj, gsl_monte_vegas_params, p); p->verbose = FIX2INT(val); return val; } static VALUE rb_gsl_monte_vegas_runval(VALUE obj) { gsl_monte_vegas_state *s = NULL; double res, sig; VALUE ary; Data_Get_Struct(obj, gsl_monte_vegas_state, s); gsl_monte_vegas_runval(s, &res, &sig); ary = rb_ary_new2(2); rb_ary_store(ary, 0, rb_float_new(res)); rb_ary_store(ary, 1, rb_float_new(sig)); return ary; } #endif void Init_gsl_monte(VALUE module) { VALUE mgsl_monte; mgsl_monte = rb_define_module_under(module, "Monte"); rb_define_const(mgsl_monte, "PLAIN", INT2FIX(GSL_MONTE_PLAIN_STATE)); rb_define_const(mgsl_monte, "MISER", INT2FIX(GSL_MONTE_MISER_STATE)); rb_define_const(mgsl_monte, "VEGAS", INT2FIX(GSL_MONTE_VEGAS_STATE)); cgsl_monte_function = rb_define_class_under(mgsl_monte, "Function", cGSL_Object); cgsl_monte_plain = rb_define_class_under(mgsl_monte, "Plain", cGSL_Object); cgsl_monte_miser = rb_define_class_under(mgsl_monte, "Miser", cGSL_Object); cgsl_monte_vegas = rb_define_class_under(mgsl_monte, "Vegas", cGSL_Object); rb_define_singleton_method(cgsl_monte_function, "new", rb_gsl_monte_function_new, -1); rb_define_singleton_method(cgsl_monte_function, "alloc", rb_gsl_monte_function_new, -1); rb_define_method(cgsl_monte_function, "proc", rb_gsl_monte_function_proc, 0); rb_define_method(cgsl_monte_function, "eval", rb_gsl_monte_function_eval, 0); rb_define_alias(cgsl_monte_function, "call", "eval"); rb_define_method(cgsl_monte_function, "params", rb_gsl_monte_function_params, 0); rb_define_method(cgsl_monte_function, "set", rb_gsl_monte_function_set_f, -1); rb_define_alias(cgsl_monte_function, "set_proc", "set"); rb_define_method(cgsl_monte_function, "set_params", rb_gsl_monte_function_set_params, -1); rb_define_method(cgsl_monte_function, "integrate", rb_gsl_monte_integrate, -1); /*****/ rb_define_singleton_method(cgsl_monte_plain, "new", rb_gsl_monte_plain_new, 1); rb_define_singleton_method(cgsl_monte_plain, "alloc", rb_gsl_monte_plain_new, 1); rb_define_method(cgsl_monte_plain, "init", rb_gsl_monte_plain_init, 0); rb_define_singleton_method(cgsl_monte_miser, "new", rb_gsl_monte_miser_new, 1); rb_define_singleton_method(cgsl_monte_miser, "alloc", rb_gsl_monte_miser_new, 1); rb_define_method(cgsl_monte_miser, "init", rb_gsl_monte_miser_init, 0); rb_define_method(cgsl_monte_miser, "estimate_frac", rb_gsl_monte_miser_estimate_frac, 0); rb_define_method(cgsl_monte_miser, "min_calls", rb_gsl_monte_miser_min_calls, 0); rb_define_method(cgsl_monte_miser, "min_calls_per_bisection", rb_gsl_monte_miser_min_calls_per_bisection, 0); rb_define_method(cgsl_monte_miser, "alpha", rb_gsl_monte_miser_alpha, 0); rb_define_method(cgsl_monte_miser, "dither", rb_gsl_monte_miser_dither, 0); rb_define_method(cgsl_monte_miser, "state", rb_gsl_monte_miser_state, 0); rb_define_method(cgsl_monte_miser, "set_estimate_frac", rb_gsl_monte_miser_set_estimate_frac, 1); rb_define_alias(cgsl_monte_miser, "estimate_frac=", "set_estimate_frac"); rb_define_method(cgsl_monte_miser, "set_min_calls", rb_gsl_monte_miser_set_min_calls, 1); rb_define_alias(cgsl_monte_miser, "min_calls=", "set_min_calls"); rb_define_method(cgsl_monte_miser, "set_min_calls_per_bisection", rb_gsl_monte_miser_set_min_calls_per_bisection, 1); rb_define_alias(cgsl_monte_miser, "min_calls_per_bisection=", "set_min_calls_per_bisection"); rb_define_method(cgsl_monte_miser, "set_alpha", rb_gsl_monte_miser_set_alpha, 1); rb_define_alias(cgsl_monte_miser, "alpha=", "set_alpha"); rb_define_method(cgsl_monte_miser, "set_dither", rb_gsl_monte_miser_set_dither, 1); rb_define_alias(cgsl_monte_miser, "dither=", "set_dither"); /*****/ rb_define_singleton_method(cgsl_monte_vegas, "new", rb_gsl_monte_vegas_new, 1); rb_define_singleton_method(cgsl_monte_vegas, "alloc", rb_gsl_monte_vegas_new, 1); rb_define_method(cgsl_monte_vegas, "init", rb_gsl_monte_vegas_init, 0); rb_define_method(cgsl_monte_vegas, "result", rb_gsl_monte_vegas_result, 0); rb_define_method(cgsl_monte_vegas, "sigma", rb_gsl_monte_vegas_sigma, 0); rb_define_method(cgsl_monte_vegas, "chisq", rb_gsl_monte_vegas_chisq, 0); rb_define_method(cgsl_monte_vegas, "alpha", rb_gsl_monte_vegas_alpha, 0); rb_define_method(cgsl_monte_vegas, "iterations", rb_gsl_monte_vegas_iterations, 0); rb_define_method(cgsl_monte_vegas, "stage", rb_gsl_monte_vegas_stage, 0); rb_define_method(cgsl_monte_vegas, "mode", rb_gsl_monte_vegas_mode, 0); rb_define_method(cgsl_monte_vegas, "verbose", rb_gsl_monte_vegas_verbose, 0); rb_define_method(cgsl_monte_vegas, "state", rb_gsl_monte_vegas_state, 0); rb_define_method(cgsl_monte_vegas, "set_alpha", rb_gsl_monte_vegas_set_alpha, 1); rb_define_alias(cgsl_monte_vegas, "alpha=", "set_alpha"); rb_define_method(cgsl_monte_vegas, "set_iterations", rb_gsl_monte_vegas_set_iterations, 1); rb_define_alias(cgsl_monte_vegas, "iterations=", "set_iterations"); rb_define_method(cgsl_monte_vegas, "set_stage", rb_gsl_monte_vegas_set_stage, 1); rb_define_alias(cgsl_monte_vegas, "stage=", "set_stage"); rb_define_method(cgsl_monte_vegas, "set_mode", rb_gsl_monte_vegas_set_mode, 1); rb_define_alias(cgsl_monte_vegas, "mode=", "set_mode"); rb_define_method(cgsl_monte_vegas, "set_verbose", rb_gsl_monte_vegas_set_verbose, 1); rb_define_alias(cgsl_monte_vegas, "verbose=", "set_verbose"); /*****/ rb_define_singleton_method(cgsl_monte_plain, "integrate", rb_gsl_monte_integrate, -1); rb_define_method(cgsl_monte_plain, "integrate", rb_gsl_monte_plain_integrate, -1); rb_define_singleton_method(cgsl_monte_miser, "integrate", rb_gsl_monte_integrate, -1); rb_define_method(cgsl_monte_miser, "integrate", rb_gsl_monte_miser_integrate, -1); rb_define_singleton_method(cgsl_monte_vegas, "integrate", rb_gsl_monte_integrate, -1); rb_define_method(cgsl_monte_vegas, "integrate", rb_gsl_monte_vegas_integrate, -1); #ifdef GSL_1_13_LATER cgsl_monte_miser_params = rb_define_class_under(cgsl_monte_miser, "Params", cGSL_Object); cgsl_monte_vegas_params = rb_define_class_under(cgsl_monte_vegas, "Params", cGSL_Object); rb_define_method(cgsl_monte_miser, "params_get", rb_gsl_monte_miser_params_get, 0); rb_define_method(cgsl_monte_miser, "params_set", rb_gsl_monte_miser_params_set, 1); rb_define_method(cgsl_monte_miser_params, "estimate_frac", rb_gsl_monte_miser_params_get_estimate_frac, 0); rb_define_method(cgsl_monte_miser_params, "set_estimate_frac", rb_gsl_monte_miser_params_set_estimate_frac, 1); rb_define_alias(cgsl_monte_miser_params, "estimate_frac=", "set_estimate_frac"); rb_define_method(cgsl_monte_miser_params, "min_calls", rb_gsl_monte_miser_params_get_min_calls, 0); rb_define_method(cgsl_monte_miser_params, "set_min_calls", rb_gsl_monte_miser_params_set_min_calls, 1); rb_define_alias(cgsl_monte_miser_params, "min_calls=", "set_min_calls"); rb_define_method(cgsl_monte_miser_params, "min_calls_per_bisection", rb_gsl_monte_miser_params_get_min_calls_per_bisection, 0); rb_define_method(cgsl_monte_miser_params, "set_min_calls_per_bisection", rb_gsl_monte_miser_params_set_min_calls_per_bisection, 1); rb_define_alias(cgsl_monte_miser_params, "min_calls_per_bisection=", "set_min_calls_per_bisection"); rb_define_method(cgsl_monte_miser_params, "alpha", rb_gsl_monte_miser_params_get_alpha, 0); rb_define_method(cgsl_monte_miser_params, "set_alpha", rb_gsl_monte_miser_params_set_alpha, 1); rb_define_alias(cgsl_monte_miser_params, "alpha=", "set_alpha"); rb_define_method(cgsl_monte_miser_params, "dither", rb_gsl_monte_miser_params_get_dither, 0); rb_define_method(cgsl_monte_miser_params, "set_dither", rb_gsl_monte_miser_params_set_dither, 1); rb_define_alias(cgsl_monte_miser_params, "dither=", "set_dither"); rb_define_method(cgsl_monte_vegas, "params_get", rb_gsl_monte_vegas_params_get, 0); rb_define_method(cgsl_monte_vegas, "params_set", rb_gsl_monte_vegas_params_set, 1); rb_define_method(cgsl_monte_vegas_params, "alpha", rb_gsl_monte_vegas_params_get_alpha, 0); rb_define_method(cgsl_monte_vegas_params, "set_alpha", rb_gsl_monte_vegas_params_set_alpha, 1); rb_define_alias(cgsl_monte_vegas_params, "alpha=", "set_alpha"); rb_define_method(cgsl_monte_vegas_params, "iterations", rb_gsl_monte_vegas_params_get_iterations, 0); rb_define_method(cgsl_monte_vegas_params, "set_iterations", rb_gsl_monte_vegas_params_set_iterations, 1); rb_define_alias(cgsl_monte_vegas_params, "iterations=", "set_iterations"); rb_define_method(cgsl_monte_vegas_params, "stage", rb_gsl_monte_vegas_params_get_stage, 0); rb_define_method(cgsl_monte_vegas_params, "set_stage", rb_gsl_monte_vegas_params_set_stage, 1); rb_define_alias(cgsl_monte_vegas_params, "stage=", "set_stage"); rb_define_method(cgsl_monte_vegas_params, "mode", rb_gsl_monte_vegas_params_get_mode, 0); rb_define_method(cgsl_monte_vegas_params, "set_mode", rb_gsl_monte_vegas_params_set_mode, 1); rb_define_alias(cgsl_monte_vegas_params, "mode=", "set_mode"); rb_define_method(cgsl_monte_vegas_params, "verbose", rb_gsl_monte_vegas_params_get_verbose, 0); rb_define_method(cgsl_monte_vegas_params, "set_verbose", rb_gsl_monte_vegas_params_set_verbose, 1); rb_define_alias(cgsl_monte_vegas_params, "verbose=", "set_verbose"); rb_define_method(cgsl_monte_vegas, "runval", rb_gsl_monte_vegas_runval, 0); rb_define_const(cgsl_monte_vegas, "MODE_IMPORTANCE", INT2FIX(GSL_VEGAS_MODE_IMPORTANCE)); rb_define_const(cgsl_monte_vegas, "MODE_IMPORTANCE_ONLY", INT2FIX(GSL_VEGAS_MODE_IMPORTANCE_ONLY)); rb_define_const(cgsl_monte_vegas, "MODE_STRATIFIED", INT2FIX(GSL_VEGAS_MODE_STRATIFIED)); #endif } #ifdef CHECK_MONTE_FUNCTION #undef CHECK_MONTE_FUNCTION #endif gsl-1.15.3/ext/const_additional.c0000644000175000017500000001047112220252463016227 0ustar boutilboutil/* const_additional.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_const.h" #ifndef GSL_1_4_9_LATER #define MKS_STEFAN_BOLTZMANN_CONSTANT (5.6703993443638e-08) #define MKS_THOMSON_CROSS_SECTION (6.65245852869236e-29) #define CGS_STEFAN_BOLTZMANN_CONSTANT (5.6703993443638e-05) #define CGS_THOMSON_CROSS_SECTION (6.65245852869236e-25) #endif #define MKS_CLASSICAL_ELECTRON_RADIUS (2.81794028310825e-15) #define MKS_RADIATION_DENSITY_CONSTANT (7.56576650685962e-16) #define MKS_RADIATION_NUMBER_DENSITY_CONSTANT (20.2869161066108e-6) #define MKS_SOLAR_TIME (4.925490947e-6) #define MKS_SOLAR_GM (1.3271243999e20) #define MKS_PLANCK_MASS (2.17664610503472e-08) #define MKS_PLANCK_LENGTH (1.61609744261067e-35) #define MKS_PLANCK_TIME (5.39072081196475e-44) #define CGS_CLASSICAL_ELECTRON_RADIUS (2.81794028310825e-13) #define CGS_RADIATION_DENSITY_CONSTANT (7.56576650685962e-15) #define CGS_RADIATION_NUMBER_DENSITY_CONSTANT (20.2869161066108) #define CGS_SOLAR_TIME (4.925490947e-6) #define CGS_SOLAR_GM (1.3271243999e26) #define CGS_PLANCK_MASS (2.17664610503472e-05) #define CGS_PLANCK_LENGTH (1.61609744261067e-33) #define CGS_PLANCK_TIME (5.39072081196475e-44) static void rb_gsl_const_mks(VALUE module); static void rb_gsl_const_cgs(VALUE module); static void rb_gsl_const_num(VALUE module); static void rb_gsl_const_mks(VALUE module) { rb_define_const(module, "RADIATION_DENSITY_CONSTANT", rb_float_new(MKS_RADIATION_DENSITY_CONSTANT)); rb_define_const(module, "RADIATION_NUMBER_DENSITY_CONSTANT", rb_float_new(MKS_RADIATION_NUMBER_DENSITY_CONSTANT)); rb_define_const(module, "CLASSICAL_ELECTRON_RADIUS", rb_float_new(MKS_CLASSICAL_ELECTRON_RADIUS)); rb_define_const(module, "SOLAR_TIME", rb_float_new(MKS_SOLAR_TIME)); rb_define_const(module, "SOLAR_GM", rb_float_new(MKS_SOLAR_GM)); rb_define_const(module, "PLANCK_MASS", rb_float_new(MKS_PLANCK_MASS)); rb_define_const(module, "PLANCK_LENGTH", rb_float_new(MKS_PLANCK_LENGTH)); rb_define_const(module, "PLANCK_TIME", rb_float_new(MKS_PLANCK_TIME)); #ifndef GSL_1_4_9_LATER rb_define_const(module, "STEFAN_BOLTZMANN_CONSTANT", rb_float_new(MKS_STEFAN_BOLTZMANN_CONSTANT)); rb_define_const(module, "THOMSON_CROSS_SECTION", rb_float_new(MKS_THOMSON_CROSS_SECTION)); #endif } static void rb_gsl_const_cgs(VALUE module) { rb_define_const(module, "RADIATION_DENSITY_CONSTANT", rb_float_new(CGS_RADIATION_DENSITY_CONSTANT)); rb_define_const(module, "RADIATION_NUMBER_DENSITY_CONSTANT", rb_float_new(CGS_RADIATION_NUMBER_DENSITY_CONSTANT)); rb_define_const(module, "CLASSICAL_ELECTRON_RADIUS", rb_float_new(CGS_CLASSICAL_ELECTRON_RADIUS)); rb_define_const(module, "SOLAR_TIME", rb_float_new(CGS_SOLAR_TIME)); rb_define_const(module, "SOLAR_GM", rb_float_new(CGS_SOLAR_GM)); rb_define_const(module, "PLANCK_MASS", rb_float_new(CGS_PLANCK_MASS)); rb_define_const(module, "PLANCK_LENGTH", rb_float_new(CGS_PLANCK_LENGTH)); rb_define_const(module, "PLANCK_TIME", rb_float_new(CGS_PLANCK_TIME)); #ifndef GSL_1_4_9_LATER rb_define_const(module, "STEFAN_BOLTZMANN_CONSTANT", rb_float_new(CGS_STEFAN_BOLTZMANN_CONSTANT)); rb_define_const(module, "THOMSON_CROSS_SECTION", rb_float_new(CGS_THOMSON_CROSS_SECTION)); #endif } static void rb_gsl_const_num(VALUE module) { } void Init_gsl_const_additional(VALUE mmks, VALUE mcgs, VALUE mnum) { rb_gsl_const_mks(mmks); rb_gsl_const_cgs(mcgs); rb_gsl_const_num(mnum); } #undef MKS_CLASSICAL_ELECTRON_RADIUS #undef MKS_STEFAN_BOLTZMANN_CONSTANT #undef MKS_RADIATION_DENSITY_CONSTANT #undef MKS_RADIATION_NUMBER_DENSITY_CONSTANT #undef CGS_CLASSICAL_ELECTRON_RADIUS #undef CGS_STEFAN_BOLTZMANN_CONSTANT #undef CGS_RADIATION_DENSITY_CONSTANT #undef CGS_RADIATION_NUMBER_DENSITY_CONSTANT #undef CGS_THOMSON_CROSS_SECTION #undef MKS_THOMSON_CROSS_SECTION #undef MKS_SOLAR_TIME #undef CGS_SOLAR_TIME #undef MKS_SOLAR_GM #undef CGS_SOLAR_GM #undef MKS_PLANCK_MASS #undef MKS_PLANCK_LENGTH #undef MKS_PLANCK_TIME #undef CGS_PLANCK_MASS #undef CGS_PLANCK_LENGTH #undef CGS_PLANCK_TIME gsl-1.15.3/ext/rational.c0000644000175000017500000003320112220252463014516 0ustar boutilboutil/* rational.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_rational.h" #include "rb_gsl_array.h" VALUE cgsl_rational; static gsl_rational* gsl_rational_div_poly(const gsl_rational *r1, const gsl_poly *p); static void gsl_rational_mark(gsl_rational *r); gsl_rational* gsl_rational_alloc() { gsl_rational *r = NULL; r = ALLOC(gsl_rational); r->num = (VALUE) NULL; r->den = (VALUE) NULL; return r; } gsl_rational* gsl_rational_new(const gsl_poly *num, const gsl_poly *den) { gsl_rational *r = NULL; r = gsl_rational_alloc(); r->pnum = make_vector_clone(num); r->pden = make_vector_clone(den); r->num = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, r->pnum); r->den = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, r->pden); return r; } gsl_rational* gsl_rational_new2(const gsl_poly *num, const gsl_poly *den) { gsl_rational *r = NULL; r = gsl_rational_alloc(); r->pnum = (gsl_poly *) num; r->pden = (gsl_poly *) den; r->num = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, r->pnum); r->den = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, r->pden); return r; } void gsl_rational_free(gsl_rational *r) { free((gsl_rational *) r); } static gsl_rational* gsl_rational_add(const gsl_rational *r, const gsl_rational *r2) { gsl_rational *rnew = NULL; gsl_poly *dennew = NULL, *numnew = NULL; gsl_poly *a = NULL, *b = NULL; int flag = 0; if (rbgsl_vector_equal(r->pden, r2->pden, 1e-10)) { dennew = r->pden; numnew = gsl_poly_add(r->pnum, r2->pnum); flag = 0; } else { dennew = gsl_poly_conv_vector(r->pden, r2->pden); a = gsl_poly_conv_vector(r->pden, r2->pnum); b = gsl_poly_conv_vector(r2->pden, r->pnum); numnew = gsl_poly_add(a, b); gsl_vector_free(a); gsl_vector_free(b); flag = 1; } rnew = gsl_rational_new(numnew, dennew); gsl_vector_free(numnew); if (flag == 1) gsl_vector_free(dennew); return rnew; } static gsl_rational* gsl_rational_add_poly(const gsl_rational *r, const gsl_poly *p) { gsl_rational *rnew = NULL; gsl_poly *numnew = NULL; gsl_poly *a = NULL; a = gsl_poly_conv_vector(r->pden, p); numnew = gsl_poly_add(a, r->pnum); rnew = gsl_rational_new(numnew, r->pden); gsl_vector_free(a); gsl_vector_free(numnew); return rnew; } static gsl_rational* gsl_rational_mul(const gsl_rational *r1, const gsl_rational *r2) { gsl_rational *rnew = NULL; gsl_poly *num = NULL, *den = NULL; num = gsl_poly_conv_vector(r1->pnum, r2->pnum); den = gsl_poly_conv_vector(r1->pden, r2->pden); rnew = gsl_rational_new2(num, den); return rnew; } static gsl_rational* gsl_rational_mul_poly(const gsl_rational *r1, const gsl_poly *p) { gsl_rational *rnew = NULL; gsl_poly *num = NULL; num = gsl_poly_conv_vector(r1->pnum, p); rnew = gsl_rational_new(num, r1->pden); gsl_vector_free(num); return rnew; } static gsl_rational* gsl_rational_div(const gsl_rational *r1, const gsl_rational *r2) { gsl_rational *rnew = NULL; gsl_poly *num = NULL, *den = NULL; num = gsl_poly_conv_vector(r1->pnum, r2->pden); den = gsl_poly_conv_vector(r1->pden, r2->pnum); rnew = gsl_rational_new2(num, den); return rnew; } static gsl_rational* gsl_rational_div_poly(const gsl_rational *r1, const gsl_poly *p) { gsl_rational *rnew = NULL; gsl_poly *den = NULL; den = gsl_poly_conv_vector(r1->pden, p); rnew = gsl_rational_new(r1->pnum, den); gsl_vector_free(den); return rnew; } static gsl_rational* gsl_rational_inverse(const gsl_rational *r) { return gsl_rational_new(r->pden, r->pnum); } /* static gsl_poly* gsl_rational_partial_fraction(const gsl_rational *r) { gsl_poly *num = NULL, *r = NULL; num = gsl_poly_deconv_vector(r->pnum, r->pden, &r); if (gsl_vector_isnull(r)) { gsl_vector_free(num); gsl_vector_free(r); return NULL; } gsl_vector_free(num); return r; } */ /*****/ gsl_poly* get_poly_get(VALUE obj, int *flag); static void gsl_rational_mark(gsl_rational *r) { rb_gc_mark(r->num); rb_gc_mark(r->den); } static VALUE rb_gsl_rational_new(int argc, VALUE *argv, VALUE klass) { gsl_poly *den = NULL, *num = NULL; gsl_rational *r = NULL; int flag1 = 0, flag2 = 0; switch (argc) { case 0: r = gsl_rational_alloc(); break; case 2: den = get_poly_get(argv[0], &flag1); num = get_poly_get(argv[1], &flag2); r = gsl_rational_new(den, num); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 2)", argc); break; } if (flag1 == 1) gsl_vector_free(den); if (flag2 == 1) gsl_vector_free(num); return Data_Wrap_Struct(klass, gsl_rational_mark, gsl_rational_free, r); } /* singleton */ static VALUE rb_gsl_poly_make_rational(VALUE obj, VALUE other) { gsl_rational *rnew = NULL; gsl_poly *p, *p2; size_t i; Data_Get_Struct(obj, gsl_poly, p); if (VECTOR_P(other)) { Data_Get_Struct(other, gsl_vector, p2); rnew = gsl_rational_new(p, p2); } else { switch (TYPE(other)) { case T_ARRAY: p2 = gsl_vector_alloc(RARRAY_LEN(other)); for (i = 0; i < p2->size; i++) gsl_vector_set(p2, i, NUM2DBL(rb_ary_entry(other, i))); rnew = gsl_rational_new(p, p2); gsl_vector_free(p2); break; case T_FLOAT: case T_FIXNUM: p2 = make_vector_clone(p); gsl_vector_scale(p2, 1.0/NUM2DBL(other)); return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, p2); break; default: rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(other))); break; } } return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew); } static VALUE rb_gsl_rational_print(VALUE obj) { gsl_rational *r = NULL; Data_Get_Struct(obj, gsl_rational, r); gsl_vector_print(r->pnum, cgsl_vector); gsl_vector_print(r->pden, cgsl_vector); return Qnil; } static VALUE rb_gsl_rational_to_s(VALUE obj) { gsl_rational *r = NULL; VALUE str; Data_Get_Struct(obj, gsl_rational, r); str = rb_gsl_vector_to_s(r->num); rb_str_concat(str, rb_str_new2("\n")); rb_str_concat(str, rb_gsl_vector_to_s(r->den)); return str; } static VALUE rb_gsl_rational_inspect(VALUE obj) { VALUE str; str = rb_str_new2(rb_class2name(CLASS_OF(obj))); rb_str_concat(str, rb_str_new2("\n")); rb_str_concat(str, rb_gsl_rational_to_s(obj)); return str; } static VALUE rb_gsl_rational_add(VALUE obj, VALUE other) { gsl_rational *r = NULL, *r2 = NULL, *rnew = NULL; gsl_poly *p = NULL; int flag = 0; Data_Get_Struct(obj, gsl_rational, r); if (RATIONAL_P(other)) { Data_Get_Struct(other, gsl_rational, r2); rnew = gsl_rational_add(r, r2); } else { p = get_poly_get(other, &flag); rnew = gsl_rational_add_poly(r, p); if (flag == 1) gsl_vector_free(p); } return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew); } static VALUE rb_gsl_rational_deconv(VALUE obj) { gsl_rational *r = NULL; Data_Get_Struct(obj, gsl_rational, r); return rb_gsl_poly_deconv(r->num, r->den); } static VALUE rb_gsl_rational_uminus(VALUE obj) { gsl_rational *r = NULL, *rnew; gsl_poly *p = NULL, *ptmp; int flag = 0; size_t i; if (RATIONAL_P(obj)) { Data_Get_Struct(obj, gsl_rational, r); rnew = gsl_rational_new(r->pnum, r->pden); for (i = 0; i < rnew->pnum->size; i++) gsl_vector_set(rnew->pnum, i, -gsl_vector_get(r->pnum, i)); return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew); } else { if (POLY_P(obj)) { Data_Get_Struct(obj, gsl_vector, ptmp); p = make_vector_clone(ptmp); } else { p = get_poly_get(obj, &flag); } for (i = 0; i < p->size; i++) gsl_vector_set(p, i, -gsl_vector_get(p, i)); return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, p); } } static VALUE rb_gsl_rational_uplus(VALUE obj) { return obj; } static VALUE rb_gsl_rational_sub(VALUE obj, VALUE other) { return rb_gsl_rational_add(obj, rb_gsl_rational_uminus(other)); } static VALUE rb_gsl_rational_mul(VALUE obj, VALUE other) { gsl_rational *r = NULL, *r2 = NULL, *rnew = NULL; gsl_poly *p; int flag = 0; Data_Get_Struct(obj, gsl_rational, r); if (RATIONAL_P(other)) { Data_Get_Struct(other, gsl_rational, r2); rnew = gsl_rational_mul(r, r2); } else if (VECTOR_P(other)) { Data_Get_Struct(other, gsl_vector, p); rnew = gsl_rational_mul_poly(r, p); } else { p = get_poly_get(other, &flag); rnew = gsl_rational_mul_poly(r, p); gsl_vector_free(p); } return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew); } static VALUE rb_gsl_rational_div(VALUE obj, VALUE other) { gsl_rational *r = NULL, *r2 = NULL, *rnew = NULL; gsl_poly *p; size_t i; Data_Get_Struct(obj, gsl_rational, r); if (RATIONAL_P(other)) { Data_Get_Struct(other, gsl_rational, r2); rnew = gsl_rational_div(r, r2); } else if (VECTOR_P(other)) { Data_Get_Struct(other, gsl_vector, p); rnew = gsl_rational_div_poly(r, p); } else { switch (TYPE(other)) { case T_ARRAY: p = gsl_vector_alloc(RARRAY_LEN(other)); for (i = 0; i < p->size; i++) gsl_vector_set(p, i, NUM2DBL(rb_ary_entry(other, i))); rnew = gsl_rational_div_poly(r, p); gsl_vector_free(p); break; case T_FLOAT: case T_FIXNUM: rnew = gsl_rational_new(r->pnum, r->pden); gsl_vector_scale(rnew->pnum, 1.0/NUM2DBL(other)); break; default: rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(other))); break; } } return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew); } static VALUE rb_gsl_rational_inverse(VALUE obj) { gsl_rational *r = NULL, *rnew = NULL; Data_Get_Struct(obj, gsl_rational, r); rnew = gsl_rational_inverse(r); return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew); } static VALUE rb_gsl_rational_den(VALUE obj) { gsl_rational *r = NULL; Data_Get_Struct(obj, gsl_rational, r); return r->den; } static VALUE rb_gsl_rational_num(VALUE obj) { gsl_rational *r = NULL; Data_Get_Struct(obj, gsl_rational, r); return r->num; } static VALUE rb_gsl_rational_coerce(VALUE obj, VALUE other) { gsl_rational *r = NULL; gsl_poly *p = NULL, *ptmp = NULL; size_t i; switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: p = gsl_vector_alloc(1); gsl_vector_set(p, 0, NUM2DBL(other)); break; case T_ARRAY: p = gsl_vector_alloc(RARRAY_LEN(other)); for (i = 0; i < p->size; i++) gsl_vector_set(p, i, NUM2DBL(rb_ary_entry(other, i))); break; default: CHECK_VECTOR(other); Data_Get_Struct(other, gsl_vector, ptmp); p = make_vector_clone(ptmp); break; } ptmp = gsl_vector_alloc(1); gsl_vector_set(ptmp, 0, 1.0); r = gsl_rational_new2(p, ptmp); return rb_ary_new3(2, Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, r), obj); } static VALUE rb_gsl_rational_zero(VALUE obj) { gsl_rational *r = NULL; Data_Get_Struct(obj, gsl_rational, r); return rb_gsl_poly_complex_solve(1, &(r->num), cgsl_rational); } static VALUE rb_gsl_rational_pole(VALUE obj) { gsl_rational *r = NULL; Data_Get_Struct(obj, gsl_rational, r); return rb_gsl_poly_complex_solve(1, &(r->den), cgsl_rational); } static VALUE rb_gsl_poly_inverse(VALUE obj) { gsl_poly *p = NULL, *ptmp = NULL; gsl_rational *r = NULL; Data_Get_Struct(obj, gsl_poly, p); ptmp = gsl_vector_alloc(1); gsl_vector_set(ptmp, 0, 1.0); r = gsl_rational_new(ptmp, p); gsl_vector_free(ptmp); return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, r); } void Init_gsl_rational(VALUE module) { cgsl_rational = rb_define_class_under(module, "Rational", cGSL_Object); rb_define_singleton_method(cgsl_rational, "new", rb_gsl_rational_new, -1); rb_define_singleton_method(cgsl_rational, "[]", rb_gsl_rational_new, -1); rb_define_singleton_method(cgsl_rational, "alloc", rb_gsl_rational_new, -1); rb_define_method(cgsl_rational, "den", rb_gsl_rational_den, 0); rb_define_method(cgsl_rational, "num", rb_gsl_rational_num, 0); rb_define_method(cgsl_rational, "print", rb_gsl_rational_print, 0); rb_define_method(cgsl_rational, "to_s", rb_gsl_rational_to_s, 0); rb_define_method(cgsl_rational, "inspect", rb_gsl_rational_inspect, 0); rb_define_method(cgsl_rational, "deconv", rb_gsl_rational_deconv, 0); rb_define_method(cgsl_rational, "-@", rb_gsl_rational_uminus, 0); rb_define_method(cgsl_rational, "+@", rb_gsl_rational_uplus, 0); rb_define_method(cgsl_rational, "add", rb_gsl_rational_add, 1); rb_define_alias(cgsl_rational, "+", "add"); rb_define_method(cgsl_rational, "sub", rb_gsl_rational_sub, 1); rb_define_alias(cgsl_rational, "-", "sub"); rb_define_method(cgsl_rational, "mul", rb_gsl_rational_mul, 1); rb_define_alias(cgsl_rational, "*", "mul"); rb_define_method(cgsl_rational, "div", rb_gsl_rational_div, 1); rb_define_alias(cgsl_rational, "/", "div"); rb_define_method(cgsl_rational, "inverse", rb_gsl_rational_inverse, 0); rb_define_alias(cgsl_rational, "inv", "inverse"); /***** Methods of poly *****/ rb_define_method(cgsl_poly, "inverse", rb_gsl_poly_inverse, 0); rb_define_alias(cgsl_poly, "inv", "inverse"); rb_define_method(cgsl_poly, "make_rational", rb_gsl_poly_make_rational, 1); rb_define_alias(cgsl_poly, "/", "make_rational"); rb_define_method(cgsl_rational, "coerce", rb_gsl_rational_coerce, 1); rb_define_method(cgsl_rational, "zero", rb_gsl_rational_zero, 0); rb_define_method(cgsl_rational, "pole", rb_gsl_rational_pole, 0); } gsl-1.15.3/ext/ieee.c0000644000175000017500000000475612220252463013631 0ustar boutilboutil/* ieee.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" static VALUE rb_gsl_ieee_env_setup(VALUE obj) { gsl_ieee_env_setup(); return obj; } static VALUE rb_gsl_ieee_fprintf_double(int argc, VALUE *argv, VALUE obj) { #ifdef RUBY_1_9_LATER rb_io_t *fptr = NULL; double ftmp; #else OpenFile *fptr = NULL; #endif FILE *fp = NULL; int flag = 0; VALUE vtmp; switch (argc) { case 2: switch (TYPE(argv[0])) { case T_STRING: fp = fopen(RSTRING_PTR(argv[0]), "w"); flag = 1; break; case T_FILE: GetOpenFile(argv[0], fptr); rb_io_check_writable(fptr); #ifdef RUBY_1_9_LATER fp = rb_io_stdio_file(fptr); #else fp = GetWriteFile(fptr); #endif break; default: rb_raise(rb_eTypeError, "wrong type argument %s (IO or String expected)", rb_class2name(CLASS_OF(argv[0]))); } vtmp = argv[1]; break; case 1: vtmp = argv[0]; fp = stdout; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } if (TYPE(vtmp) != T_FLOAT) rb_raise(rb_eTypeError, "wrong argument type %s (Float expected)", rb_class2name(CLASS_OF(vtmp))); #ifdef RUBY_1_9_LATER ftmp = RFLOAT_VALUE(vtmp); gsl_ieee_fprintf_double(fp, &ftmp); #else gsl_ieee_fprintf_double(fp, &(RFLOAT(vtmp)->value)); #endif if (fp == stdout) fprintf(stdout, "\n"); if (flag == 1) fclose(fp); return obj; } static VALUE rb_gsl_ieee_printf_double(VALUE obj, VALUE xx) { double x; x = NUM2DBL(xx); gsl_ieee_printf_double(&x); return xx; } void Init_gsl_ieee(VALUE module) { VALUE mgsl_ieee; mgsl_ieee = rb_define_module_under(module, "IEEE"); rb_define_singleton_method(mgsl_ieee, "env_setup", rb_gsl_ieee_env_setup, 0); rb_define_module_function(module, "ieee_env_setup", rb_gsl_ieee_env_setup, 0); rb_define_singleton_method(mgsl_ieee, "fprintf_double", rb_gsl_ieee_fprintf_double, -1); rb_define_singleton_method(mgsl_ieee, "fprintf", rb_gsl_ieee_fprintf_double, -1); rb_define_singleton_method(mgsl_ieee, "printf", rb_gsl_ieee_printf_double, -1); rb_define_singleton_method(mgsl_ieee, "printf_double", rb_gsl_ieee_printf_double, -1); } gsl-1.15.3/ext/sort.c0000644000175000017500000001571612220252463013707 0ustar boutilboutil/* sort.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include #include EXTERN ID RBGSL_ID_call; EXTERN VALUE cgsl_complex; int rb_gsl_comparison_double(const void *aa, const void *bb); int rb_gsl_comparison_complex(const void *aa, const void *bb); int rb_gsl_comparison_double(const void *aa, const void *bb) { double *a = NULL, *b = NULL; a = (double *) aa; b = (double *) bb; return FIX2INT(rb_funcall(RB_GSL_MAKE_PROC, RBGSL_ID_call, 2, rb_float_new(*a), rb_float_new(*b))); } int rb_gsl_comparison_complex(const void *aa, const void *bb) { gsl_complex *a = NULL, *b = NULL; a = (gsl_complex *) aa; b = (gsl_complex *) bb; return FIX2INT(rb_funcall(RB_GSL_MAKE_PROC, RBGSL_ID_call, 2, Data_Wrap_Struct(cgsl_complex, 0, NULL, a), Data_Wrap_Struct(cgsl_complex, 0, NULL, b))); } static VALUE rb_gsl_heapsort_vector(VALUE obj) { gsl_vector *v = NULL; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); Data_Get_Struct(obj, gsl_vector, v); gsl_heapsort(v->data, v->size, sizeof(double), rb_gsl_comparison_double); return obj; } static VALUE rb_gsl_heapsort_vector2(VALUE obj) { gsl_vector *v = NULL, *vnew = NULL; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); Data_Get_Struct(obj, gsl_vector, v); vnew = gsl_vector_alloc(v->size); gsl_vector_memcpy(vnew, v); gsl_heapsort(vnew->data, vnew->size, sizeof(double), rb_gsl_comparison_double); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } static VALUE rb_gsl_heapsort_index_vector(VALUE obj) { gsl_vector *v = NULL; gsl_permutation *p = NULL; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); Data_Get_Struct(obj, gsl_vector, v); p = gsl_permutation_alloc(v->size); gsl_heapsort_index(p->data, v->data, v->size, sizeof(double), rb_gsl_comparison_double); return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); } static VALUE rb_gsl_heapsort_vector_complex(VALUE obj) { gsl_vector_complex *v = NULL; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); Data_Get_Struct(obj, gsl_vector_complex, v); gsl_heapsort(v->data, v->size, sizeof(gsl_complex), rb_gsl_comparison_complex); return obj; } static VALUE rb_gsl_heapsort_vector_complex2(VALUE obj) { gsl_vector_complex *v = NULL, *vnew = NULL; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); gsl_vector_complex_memcpy(vnew, v); gsl_heapsort(vnew->data, vnew->size, sizeof(gsl_complex), rb_gsl_comparison_complex); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } static VALUE rb_gsl_heapsort_index_vector_complex(VALUE obj) { gsl_vector_complex *v = NULL; gsl_permutation *p = NULL; if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); Data_Get_Struct(obj, gsl_vector_complex, v); p = gsl_permutation_alloc(v->size); gsl_heapsort_index(p->data, v->data, v->size, sizeof(gsl_complex), rb_gsl_comparison_complex); return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); } /* singleton */ static VALUE rb_gsl_heapsort(VALUE obj, VALUE vv) { if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); if (rb_obj_is_kind_of(vv, cgsl_vector_complex)) { return rb_gsl_heapsort_vector_complex(vv); } else if (rb_obj_is_kind_of(vv, cgsl_vector)) { return rb_gsl_heapsort_vector(vv); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Vector::Complex expected)", rb_class2name(CLASS_OF(vv))); } return vv; } static VALUE rb_gsl_heapsort2(VALUE obj, VALUE vv) { if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); if (rb_obj_is_kind_of(vv, cgsl_vector_complex)) { return rb_gsl_heapsort_vector_complex2(vv); } else if (rb_obj_is_kind_of(vv, cgsl_vector)) { return rb_gsl_heapsort_vector2(vv); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Vector::Complex expected)", rb_class2name(CLASS_OF(vv))); } return vv; } static VALUE rb_gsl_heapsort_index(VALUE obj, VALUE vv) { if (!rb_block_given_p()) rb_raise(rb_eRuntimeError, "Proc is not given"); if (rb_obj_is_kind_of(vv, cgsl_vector_complex)) { return rb_gsl_heapsort_index_vector_complex(vv); } else if (rb_obj_is_kind_of(vv, cgsl_vector)) { return rb_gsl_heapsort_index_vector(vv); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Vector::Complex expected)", rb_class2name(CLASS_OF(vv))); } return vv; } /*****/ #ifdef HAVE_NARRAY_H #include "narray.h" static VALUE rb_gsl_sort_narray(VALUE obj) { struct NARRAY *na; size_t size, stride; double *ptr1, *ptr2; VALUE ary; GetNArray(obj, na); ptr1 = (double*) na->ptr; size = na->total; stride = 1; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(obj)); ptr2 = NA_PTR_TYPE(ary, double*); memcpy(ptr2, ptr1, sizeof(double)*size); gsl_sort(ptr2, stride, size); return ary; } static VALUE rb_gsl_sort_narray_bang(VALUE obj) { struct NARRAY *na; size_t size, stride; double *ptr1; GetNArray(obj, na); ptr1 = (double*) na->ptr; size = na->total; stride = 1; gsl_sort(ptr1, stride, size); return obj; } static VALUE rb_gsl_sort_index_narray(VALUE obj) { struct NARRAY *na; size_t size, stride; double *ptr1; gsl_permutation *p; GetNArray(obj, na); ptr1 = (double*) na->ptr; size = na->total; stride = 1; p = gsl_permutation_alloc(size); gsl_sort_index(p->data, ptr1, stride, size); return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); } #endif void Init_gsl_sort(VALUE module) { rb_define_singleton_method(module, "heapsort!", rb_gsl_heapsort, 1); rb_define_singleton_method(module, "heapsort", rb_gsl_heapsort2, 1); rb_define_singleton_method(module, "heapsort_index", rb_gsl_heapsort_index, 1); rb_define_method(cgsl_vector, "heapsort!", rb_gsl_heapsort_vector, 0); rb_define_method(cgsl_vector, "heapsort", rb_gsl_heapsort_vector2, 0); rb_define_method(cgsl_vector, "heapsort_index", rb_gsl_heapsort_index_vector, 0); rb_define_method(cgsl_vector_complex, "heapsort!", rb_gsl_heapsort_vector_complex, 0); rb_define_method(cgsl_vector_complex, "heapsort", rb_gsl_heapsort_vector_complex2, 0); rb_define_method(cgsl_vector_complex, "heapsort_index", rb_gsl_heapsort_index_vector_complex, 0); #ifdef HAVE_NARRAY_H rb_define_method(cNArray, "gsl_sort", rb_gsl_sort_narray, 0); rb_define_method(cNArray, "gsl_sort!", rb_gsl_sort_narray_bang, 0); rb_define_method(cNArray, "gsl_sort_index", rb_gsl_sort_index_narray, 0); #endif } gsl-1.15.3/ext/blas1.c0000644000175000017500000005643212220252463013722 0ustar boutilboutil/* blas1.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include #include "rb_gsl_complex.h" #include "rb_gsl_array.h" #include "rb_gsl_common.h" static int get_vector1(int argc, VALUE *argv, VALUE obj, gsl_vector **x); static int get_vector_complex1(int argc, VALUE *argv, VALUE obj, gsl_vector_complex **x); static int get_vector2(int argc, VALUE *argv, VALUE obj, gsl_vector **x, gsl_vector **y); static int get_vector_complex2(int argc, VALUE *argv, VALUE obj, gsl_vector_complex **x, gsl_vector_complex **y); static int get_vector1(int argc, VALUE *argv, VALUE obj, gsl_vector **x) { int flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Data_Get_Vector(argv[0], (*x)); break; default: Data_Get_Vector(obj, (*x)); flag = 1; break; } return flag; } static int get_vector_complex1(int argc, VALUE *argv, VALUE obj, gsl_vector_complex **x) { int flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_VECTOR_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_vector_complex, (*x)); break; default: Data_Get_Struct(obj, gsl_vector_complex, (*x)); flag = 1; break; } return flag; } static int get_vector2(int argc, VALUE *argv, VALUE obj, gsl_vector **x, gsl_vector **y) { int flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Data_Get_Vector(argv[0], (*x)); Data_Get_Vector(argv[1], (*y)); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Data_Get_Vector(obj, (*x)); Data_Get_Vector(argv[0], (*y)); flag = 1; break; } return flag; } static int get_vector_complex2(int argc, VALUE *argv, VALUE obj, gsl_vector_complex **x, gsl_vector_complex **y) { int flag = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_VECTOR_COMPLEX(argv[0]); CHECK_VECTOR_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_vector_complex, (*x)); Data_Get_Struct(argv[1], gsl_vector_complex, (*y)); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_VECTOR_COMPLEX(argv[0]); Data_Get_Struct(obj, gsl_vector_complex, (*x)); Data_Get_Struct(argv[0], gsl_vector_complex, (*y)); flag = 1; break; } return flag; } static VALUE rb_gsl_blas_ddot(int argc, VALUE *argv, VALUE obj) { double r; // local variable "status" declared and set, but never used //int status; gsl_vector *x = NULL, *y = NULL; get_vector2(argc, argv, obj, &x, &y); /*status =*/ gsl_blas_ddot(x, y, &r); return rb_float_new(r); } static VALUE rb_gsl_blas_zdotu(int argc, VALUE *argv, VALUE obj) { gsl_complex *r; // local variable "status" declared and set, but never used //int status; gsl_vector_complex *x = NULL, *y = NULL; get_vector_complex2(argc, argv, obj, &x, &y); r = ALLOC(gsl_complex); /*status =*/ gsl_blas_zdotu(x, y, r); return Data_Wrap_Struct(cgsl_complex, 0, free, r); } static VALUE rb_gsl_blas_zdotc(int argc, VALUE *argv, VALUE obj) { gsl_complex *r; // local variable "status" declared and set, but never used //int status; gsl_vector_complex *x = NULL, *y = NULL; get_vector_complex2(argc, argv, obj, &x, &y); r = ALLOC(gsl_complex); /*status =*/ gsl_blas_zdotc(x, y, r); return Data_Wrap_Struct(cgsl_complex, 0, free, r); } static VALUE rb_gsl_blas_dnrm2(int argc, VALUE *argv, VALUE obj) { gsl_vector *x = NULL; get_vector1(argc, argv, obj, &x); return rb_float_new(gsl_blas_dnrm2(x)); } static VALUE rb_gsl_blas_dnrm(int argc, VALUE *argv, VALUE obj) { gsl_vector *x = NULL; double a; get_vector1(argc, argv, obj, &x); a = gsl_blas_dnrm2(x); return rb_float_new(a*a); } static VALUE rb_gsl_blas_dznrm2(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *x = NULL; get_vector_complex1(argc, argv, obj, &x); return rb_float_new(gsl_blas_dznrm2(x)); } static VALUE rb_gsl_blas_dasum(int argc, VALUE *argv, VALUE obj) { gsl_vector *x = NULL; get_vector1(argc, argv, obj, &x); return rb_float_new(gsl_blas_dasum(x)); } static VALUE rb_gsl_blas_dzasum(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *x = NULL; get_vector_complex1(argc, argv, obj, &x); return rb_float_new(gsl_blas_dzasum(x)); } static VALUE rb_gsl_blas_idamax(int argc, VALUE *argv, VALUE obj) { gsl_vector *x = NULL; get_vector1(argc, argv, obj, &x); return INT2FIX(gsl_blas_idamax(x)); } static VALUE rb_gsl_blas_izamax(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *x = NULL; get_vector_complex1(argc, argv, obj, &x); return INT2FIX(gsl_blas_izamax(x)); } static VALUE rb_gsl_blas_dswap(int argc, VALUE *argv, VALUE obj) { gsl_vector *x = NULL, *y = NULL; get_vector2(argc, argv, obj, &x, &y); return INT2FIX(gsl_blas_dswap(x, y)); } static VALUE rb_gsl_blas_zswap(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *x = NULL, *y = NULL; get_vector_complex2(argc, argv, obj, &x, &y); return INT2FIX(gsl_blas_zswap(x, y)); } static VALUE rb_gsl_blas_dcopy(int argc, VALUE *argv, VALUE obj) { gsl_vector *x = NULL, *y = NULL; get_vector2(argc, argv, obj, &x, &y); return INT2FIX(gsl_blas_dcopy(x, y)); } static VALUE rb_gsl_blas_zcopy(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *x = NULL, *y = NULL; get_vector_complex2(argc, argv, obj, &x, &y); return INT2FIX(gsl_blas_zcopy(x, y)); } static VALUE rb_gsl_blas_daxpy(int argc, VALUE *argv, VALUE obj) { double a; gsl_vector *x = NULL, *y = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: get_vector2(argc-1, argv+1, obj, &x, &y); Need_Float(argv[0]); // a = RFLOAT(argv[0])->value; a = NUM2DBL(argv[0]); break; default: Data_Get_Struct(obj, gsl_vector, x); if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Need_Float(argv[0]); // a = RFLOAT(argv[0])->value; a = NUM2DBL(argv[0]); Data_Get_Vector(argv[1], y); break; } gsl_blas_daxpy(a, x, y); return argv[argc-1]; } static VALUE rb_gsl_blas_daxpy2(int argc, VALUE *argv, VALUE obj) { double a; gsl_vector *x = NULL, *y = NULL, *y2 = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: get_vector2(argc-1, argv+1, obj, &x, &y); Need_Float(argv[0]); // a = RFLOAT(argv[0])->value; a = NUM2DBL(argv[0]); break; default: Data_Get_Struct(obj, gsl_vector, x); if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Need_Float(argv[0]); CHECK_VECTOR(argv[1]); // a = RFLOAT(argv[0])->value; a = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, y); break; } y2 = gsl_vector_alloc(y->size); gsl_vector_memcpy(y2, y); gsl_blas_daxpy(a, x, y2); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, y2); } static VALUE rb_gsl_blas_zaxpy(int argc, VALUE *argv, VALUE obj) { gsl_complex *a = NULL; gsl_vector_complex *x = NULL, *y = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, a); get_vector_complex2(argc-1, argv+1, obj, &x, &y); break; default: Data_Get_Struct(obj, gsl_vector_complex, x); if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_COMPLEX(argv[0]); CHECK_VECTOR_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_complex, a); Data_Get_Struct(argv[1], gsl_vector_complex, y); break; } gsl_blas_zaxpy(*a, x, y); return argv[argc-1]; } static VALUE rb_gsl_blas_zaxpy2(int argc, VALUE *argv, VALUE obj) { gsl_complex *a = NULL; gsl_vector_complex *x = NULL, *y = NULL, *y2 = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: get_vector_complex2(argc-1, argv+1, obj, &x, &y); CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, a); break; default: Data_Get_Struct(obj, gsl_vector_complex, x); if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_COMPLEX(argv[0]); CHECK_VECTOR_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_complex, a); Data_Get_Struct(argv[1], gsl_vector_complex, y); break; } y2 = gsl_vector_complex_alloc(y->size); gsl_vector_complex_memcpy(y2, y); gsl_blas_zaxpy(*a, x, y2); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, y2); } static VALUE rb_gsl_blas_dscal(int argc, VALUE *argv, VALUE obj) { double a; gsl_vector *x = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Need_Float(argv[0]); CHECK_VECTOR(argv[1]); // a = RFLOAT(argv[0])->value; a = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, x); gsl_blas_dscal(a, x); return argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Need_Float(argv[0]); // a = RFLOAT(argv[0])->value; a = NUM2DBL(argv[0]); Data_Get_Struct(obj, gsl_vector, x); gsl_blas_dscal(a, x); return obj; break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_blas_dscal2(int argc, VALUE *argv, VALUE obj) { double a; gsl_vector *x = NULL, *xnew = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Need_Float(argv[0]); CHECK_VECTOR(argv[1]); a = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, x); break; default: Data_Get_Struct(obj, gsl_vector, x); if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Need_Float(argv[0]); a = NUM2DBL(argv[0]); break; } xnew = gsl_vector_alloc(x->size); gsl_vector_memcpy(xnew, x); gsl_blas_dscal(a, xnew); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew); } static VALUE rb_gsl_blas_zdscal(int argc, VALUE *argv, VALUE obj) { double a; gsl_vector_complex *x = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Need_Float(argv[0]); CHECK_VECTOR_COMPLEX(argv[1]); // a = RFLOAT(argv[0])->value; a = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector_complex, x); gsl_blas_zdscal(a, x); return argv[1]; break; default: Data_Get_Struct(obj, gsl_vector_complex, x); if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Need_Float(argv[0]); a = NUM2DBL(argv[0]); gsl_blas_zdscal(a, x); return obj; break; } } static VALUE rb_gsl_blas_zdscal2(int argc, VALUE *argv, VALUE obj) { double a; gsl_vector_complex *x = NULL, *xnew = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Need_Float(argv[0]); CHECK_VECTOR_COMPLEX(argv[1]); a = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector_complex, x); break; default: Data_Get_Struct(obj, gsl_vector_complex, x); if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Need_Float(argv[0]); a = NUM2DBL(argv[0]); break; } xnew = gsl_vector_complex_alloc(x->size); gsl_vector_complex_memcpy(xnew, x); gsl_blas_zdscal(a, xnew); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, xnew); } static VALUE rb_gsl_blas_zscal(int argc, VALUE *argv, VALUE obj) { gsl_complex *a = NULL; gsl_vector_complex *x = NULL; CHECK_COMPLEX(argv[0]); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_VECTOR_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_complex, a); Data_Get_Struct(argv[1], gsl_vector_complex, x); gsl_blas_zscal(*a, x); return argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Data_Get_Struct(obj, gsl_vector_complex, x); Data_Get_Struct(argv[0], gsl_complex, a); gsl_blas_zscal(*a, x); return obj; break; } } static VALUE rb_gsl_blas_zscal2(int argc, VALUE *argv, VALUE obj) { gsl_complex *a = NULL; gsl_vector_complex *x = NULL, *xnew = NULL; CHECK_COMPLEX(argv[0]); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_VECTOR_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_complex, a); Data_Get_Struct(argv[1], gsl_vector_complex, x); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Data_Get_Struct(obj, gsl_vector_complex, x); Data_Get_Struct(argv[0], gsl_complex, a); break; } xnew = gsl_vector_complex_alloc(x->size); gsl_vector_complex_memcpy(xnew, x); gsl_blas_zscal(*a, xnew); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, xnew); } static VALUE rb_gsl_blas_drot(VALUE obj, VALUE xx, VALUE yy, VALUE cc, VALUE ss) { gsl_vector *x = NULL, *y = NULL; double c, s; CHECK_VECTOR(xx); CHECK_VECTOR(yy); Need_Float(cc); Need_Float(ss); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); c = NUM2DBL(cc); s = NUM2DBL(ss); gsl_blas_drot(x, y, c, s); return rb_ary_new3(2, xx, yy); } static VALUE rb_gsl_blas_drot2(VALUE obj, VALUE xx, VALUE yy, VALUE cc, VALUE ss) { gsl_vector *x = NULL, *y = NULL, *xnew = NULL, *ynew = NULL; double c, s; CHECK_VECTOR(xx); CHECK_VECTOR(yy); Need_Float(cc); Need_Float(ss); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); c = NUM2DBL(cc); s = NUM2DBL(ss); xnew = gsl_vector_alloc(x->size); ynew = gsl_vector_alloc(y->size); gsl_vector_memcpy(xnew, x); gsl_vector_memcpy(ynew, y); gsl_blas_drot(xnew, ynew, c, s); return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, ynew)); } static VALUE rb_gsl_blas_drotm(VALUE obj, VALUE xx, VALUE yy, VALUE PP) { gsl_vector *x = NULL, *y = NULL, *p = NULL; int flag = 0, i; CHECK_VECTOR(xx); CHECK_VECTOR(yy); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); if (rb_obj_is_kind_of(PP, cgsl_vector)) { Data_Get_Struct(PP, gsl_vector, p); } else { if (TYPE(PP) != T_ARRAY) rb_raise(rb_eTypeError, "wrong argument type %s (Array of Vector expected", rb_class2name(CLASS_OF(PP))); // p = gsl_vector_alloc(RARRAY(PP)->len); p = gsl_vector_alloc(RARRAY_LEN(PP)); for (i = 0; i < RARRAY_LEN(PP); i++) { gsl_vector_set(p, i, rb_ary_entry(PP, i)); } flag = 1; } gsl_blas_drotm(x, y, p->data); if (flag == 1) gsl_vector_free(p); return rb_ary_new3(2, xx, yy); } static VALUE rb_gsl_blas_drotm2(VALUE obj, VALUE xx, VALUE yy, VALUE PP) { gsl_vector *x = NULL, *y = NULL, *p = NULL, *xnew = NULL, *ynew = NULL; int flag = 0, i; CHECK_VECTOR(xx); CHECK_VECTOR(yy); Data_Get_Struct(xx, gsl_vector, x); Data_Get_Struct(yy, gsl_vector, y); if (rb_obj_is_kind_of(PP, cgsl_vector)) { Data_Get_Struct(PP, gsl_vector, p); } else { if (TYPE(PP) != T_ARRAY) rb_raise(rb_eTypeError, "wrong argument type %s (Array of Vector expected", rb_class2name(CLASS_OF(PP))); // p = gsl_vector_alloc(RARRAY(PP)->len); p = gsl_vector_alloc(RARRAY_LEN(PP)); for (i = 0; i < RARRAY_LEN(PP); i++) { gsl_vector_set(p, i, rb_ary_entry(PP, i)); } flag = 1; } xnew = gsl_vector_alloc(x->size); ynew = gsl_vector_alloc(y->size); gsl_vector_memcpy(xnew, x); gsl_vector_memcpy(ynew, y); gsl_blas_drotm(xnew, ynew, p->data); if (flag == 1) gsl_vector_free(p); return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, ynew)); } void Init_gsl_blas1(VALUE module) { rb_define_module_function(module, "ddot", rb_gsl_blas_ddot, -1); rb_define_method(cgsl_vector, "blas_ddot", rb_gsl_blas_ddot, -1); rb_define_alias(cgsl_vector, "ddot", "blas_ddot"); /* rb_define_alias(cgsl_vector, "dot", "blas_ddot");*/ rb_define_module_function(module, "zdotu", rb_gsl_blas_zdotu, -1); rb_define_method(cgsl_vector_complex, "blas_zdotu", rb_gsl_blas_zdotu, -1); rb_define_alias(cgsl_vector_complex, "zdotu", "blas_zdotu"); rb_define_alias(cgsl_vector_complex, "dotu", "blas_zdotu"); rb_define_module_function(module, "zdotc", rb_gsl_blas_zdotc, -1); rb_define_method(cgsl_vector_complex, "blas_zdotc", rb_gsl_blas_zdotc, -1); rb_define_alias(cgsl_vector_complex, "zdotc", "blas_zdotc"); rb_define_alias(cgsl_vector_complex, "dotc", "blas_zdotc"); rb_define_module_function(module, "dnrm2", rb_gsl_blas_dnrm2, -1); rb_define_method(cgsl_vector, "blas_dnrm2", rb_gsl_blas_dnrm2, -1); rb_define_alias(cgsl_vector, "dnrm2", "blas_dnrm2"); rb_define_alias(cgsl_vector, "nrm2", "blas_dnrm2"); rb_define_alias(cgsl_vector, "norm", "blas_dnrm2"); rb_define_module_function(module, "dnrm", rb_gsl_blas_dnrm, -1); rb_define_method(cgsl_vector, "blas_dnrm", rb_gsl_blas_dnrm, -1); rb_define_alias(cgsl_vector, "dnrm", "blas_dnrm"); rb_define_alias(cgsl_vector, "nrm", "blas_dnrm"); rb_define_alias(cgsl_vector, "sumsq", "blas_dnrm"); rb_define_module_function(module, "dznrm2", rb_gsl_blas_dznrm2, -1); rb_define_method(cgsl_vector_complex, "blas_dznrm2", rb_gsl_blas_dznrm2, -1); rb_define_alias(cgsl_vector_complex, "dznrm2", "blas_dznrm2"); rb_define_alias(cgsl_vector_complex, "nrm2", "blas_dznrm2"); rb_define_module_function(module, "dasum", rb_gsl_blas_dasum, -1); rb_define_method(cgsl_vector, "blas_dasum", rb_gsl_blas_dasum, -1); rb_define_alias(cgsl_vector, "dasum", "blas_dasum"); rb_define_alias(cgsl_vector, "asum", "blas_dasum"); rb_define_module_function(module, "dzasum", rb_gsl_blas_dzasum, -1); rb_define_method(cgsl_vector_complex, "blas_dzasum", rb_gsl_blas_dzasum, -1); rb_define_alias(cgsl_vector_complex, "dzasum", "blas_dzasum"); rb_define_alias(cgsl_vector_complex, "asum", "blas_dzasum"); rb_define_module_function(module, "idamax", rb_gsl_blas_idamax, -1); rb_define_method(cgsl_vector, "blas_idamax", rb_gsl_blas_idamax, -1); rb_define_alias(cgsl_vector, "idamax", "blas_idamax"); rb_define_module_function(module, "izamax", rb_gsl_blas_izamax, -1); rb_define_method(cgsl_vector_complex, "blas_izamax", rb_gsl_blas_izamax, -1); rb_define_alias(cgsl_vector_complex, "izamax", "blas_izamax"); rb_define_module_function(module, "dswap", rb_gsl_blas_dswap, -1); rb_define_method(cgsl_vector, "blas_dswap", rb_gsl_blas_dswap, -1); rb_define_alias(cgsl_vector, "dswap", "blas_dswap"); rb_define_alias(cgsl_vector, "swap", "blas_dswap"); rb_define_module_function(module, "zswap", rb_gsl_blas_zswap, -1); rb_define_method(cgsl_vector_complex, "blas_zswap", rb_gsl_blas_zswap, -1); rb_define_alias(cgsl_vector_complex, "zswap", "blas_zswap"); rb_define_alias(cgsl_vector_complex, "swap", "blas_zswap"); rb_define_module_function(module, "dcopy", rb_gsl_blas_dcopy, -1); rb_define_method(cgsl_vector, "blas_dcopy", rb_gsl_blas_dcopy, -1); rb_define_alias(cgsl_vector, "dcopy", "blas_dcopy"); rb_define_alias(cgsl_vector, "copy", "blas_dcopy"); rb_define_module_function(module, "zcopy", rb_gsl_blas_zcopy, -1); rb_define_method(cgsl_vector_complex, "blas_zcopy", rb_gsl_blas_zcopy, -1); rb_define_alias(cgsl_vector_complex, "zcopy", "blas_zcopy"); rb_define_alias(cgsl_vector_complex, "copy", "blas_zcopy"); rb_define_module_function(module, "daxpy!", rb_gsl_blas_daxpy, -1); rb_define_method(cgsl_vector, "blas_daxpy!", rb_gsl_blas_daxpy, -1); rb_define_alias(cgsl_vector, "daxpy!", "blas_daxpy!"); rb_define_alias(cgsl_vector, "axpy!", "blas_daxpy!"); rb_define_module_function(module, "daxpy", rb_gsl_blas_daxpy2, -1); rb_define_method(cgsl_vector, "blas_daxpy", rb_gsl_blas_daxpy2, -1); rb_define_alias(cgsl_vector, "daxpy", "blas_daxpy"); rb_define_alias(cgsl_vector, "axpy", "blas_daxpy"); rb_define_module_function(module, "zaxpy!", rb_gsl_blas_zaxpy, -1); rb_define_method(cgsl_vector_complex, "blas_zaxpy!", rb_gsl_blas_zaxpy, -1); rb_define_alias(cgsl_vector_complex, "zaxpy!", "blas_zaxpy!"); rb_define_alias(cgsl_vector_complex, "axpy!", "blas_zaxpy!"); rb_define_module_function(module, "zaxpy", rb_gsl_blas_zaxpy2, -1); rb_define_method(cgsl_vector_complex, "blas_zaxpy", rb_gsl_blas_zaxpy2, -1); rb_define_alias(cgsl_vector_complex, "zaxpy", "blas_zaxpy"); rb_define_alias(cgsl_vector_complex, "axpy", "blas_zaxpy"); rb_define_module_function(module, "dscal!", rb_gsl_blas_dscal, -1); rb_define_method(cgsl_vector, "blas_dscal!", rb_gsl_blas_dscal, -1); rb_define_alias(cgsl_vector, "dscal!", "blas_dscal!"); rb_define_alias(cgsl_vector, "scal!", "blas_dscal!"); rb_define_module_function(module, "dscal", rb_gsl_blas_dscal2, -1); rb_define_method(cgsl_vector, "blas_dscal", rb_gsl_blas_dscal2, -1); rb_define_alias(cgsl_vector, "dscal", "blas_dscal"); rb_define_alias(cgsl_vector, "scal", "blas_dscal"); rb_define_module_function(module, "zdscal!", rb_gsl_blas_zdscal, -1); rb_define_method(cgsl_vector_complex, "blas_zdscal!", rb_gsl_blas_zdscal, -1); rb_define_alias(cgsl_vector_complex, "zdscal!", "blas_zdscal!"); rb_define_alias(cgsl_vector_complex, "scal!", "blas_zdscal!"); rb_define_module_function(module, "zdscal", rb_gsl_blas_zdscal2, -1); rb_define_method(cgsl_vector_complex, "blas_zdscal", rb_gsl_blas_zdscal2, -1); rb_define_alias(cgsl_vector_complex, "zdscal", "blas_zdscal"); rb_define_alias(cgsl_vector_complex, "scal", "blas_zdscal"); rb_define_module_function(module, "zscal!", rb_gsl_blas_zscal, -1); rb_define_method(cgsl_vector_complex, "blas_zscal!", rb_gsl_blas_zscal, -1); rb_define_alias(cgsl_vector_complex, "zscal!", "blas_zscal!"); rb_define_module_function(module, "zscal2", rb_gsl_blas_zscal2, -1); rb_define_method(cgsl_vector_complex, "blas_zscal2", rb_gsl_blas_zscal2, -1); rb_define_alias(cgsl_vector_complex, "zscal2", "blas_zscal2"); rb_define_alias(cgsl_vector_complex, "scal2", "blas_zscal2"); rb_define_module_function(module, "drot!", rb_gsl_blas_drot, 4); rb_define_module_function(module, "drot", rb_gsl_blas_drot2, 4); rb_define_module_function(module, "drotm!", rb_gsl_blas_drotm, 3); rb_define_module_function(module, "drotm", rb_gsl_blas_drotm2, 3); } gsl-1.15.3/ext/complex.c0000644000175000017500000007437212220252463014372 0ustar boutilboutil/* complex.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_config.h" #include "rb_gsl_complex.h" #include "rb_gsl_array.h" VALUE cgsl_complex; // Set real/imag components of gsl_complex from Ruby object. // If z is NULL, it is as if it pointed to a temporary (0+0i) value, // otherwise the gsl_complex pointed to z is modified. // Returns the resulting gsl_complex value in both cases. // // NOTE: This function does not always set both components of *z, so if *z is // non-null, it should be initialized before calling this function. gsl_complex rb_gsl_obj_to_gsl_complex(VALUE obj, gsl_complex *z) { VALUE vre, vim; gsl_complex tmp, *zz; if(!z) { z = &tmp; GSL_SET_COMPLEX(z, 0.0, 0.0); } if(obj == Qnil) { return *z; } switch(TYPE(obj)) { case T_ARRAY: vre = rb_ary_entry(obj,0); vim = rb_ary_entry(obj,1); if (!NIL_P(vre)) GSL_SET_REAL(z, NUM2DBL(vre)); if (!NIL_P(vim)) GSL_SET_IMAG(z, NUM2DBL(vim)); break; case T_FLOAT: case T_FIXNUM: case T_BIGNUM: *z = gsl_complex_rect(NUM2DBL(obj), 0.0); break; default: if (rb_obj_is_kind_of(obj, cgsl_complex)) { Data_Get_Struct(obj, gsl_complex, zz); *z = *zz; } else { rb_raise(rb_eTypeError, "wrong type %s, (nil, Array, Float, Integer, or GSL::Complex expected)", rb_class2name(CLASS_OF(obj))); } break; } return *z; } static VALUE rb_gsl_complex_new(int argc, VALUE *argv, VALUE klass) { gsl_complex *c = NULL; VALUE obj; obj = Data_Make_Struct(klass, gsl_complex, 0, free, c); switch (argc) { case 1: switch (TYPE(argv[0])) { case T_ARRAY: *c = ary2complex(argv[0]); break; case T_FLOAT: case T_FIXNUM: case T_BIGNUM: Need_Float(argv[0]); *c = gsl_complex_rect(NUM2DBL(argv[0]), 0.0); break; default: rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[0]))); } break; case 2: Need_Float(argv[0]); Need_Float(argv[1]); *c = gsl_complex_rect(NUM2DBL(argv[0]), NUM2DBL(argv[1])); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } return obj; } gsl_complex* make_complex(double re, double im) { gsl_complex *c = NULL; c = ALLOC(gsl_complex); *c = gsl_complex_rect(re, im); return c; } static VALUE rb_gsl_complex_polar(VALUE klass, VALUE r, VALUE theta) { VALUE obj; gsl_complex *c = NULL; Need_Float(r); Need_Float(theta); obj = Data_Make_Struct(klass, gsl_complex, 0, free, c); *c = gsl_complex_polar(NUM2DBL(r), NUM2DBL(theta)); return obj; } static VALUE rb_gsl_complex_get(VALUE obj, VALUE ii) { gsl_complex *c = NULL; int i; CHECK_FIXNUM(ii); Data_Get_Struct(obj, gsl_complex, c); i = FIX2INT(ii); switch (i) { case 0: return rb_float_new(GSL_REAL(*c)); break; case 1: return rb_float_new(GSL_IMAG(*c)); break; default: rb_raise(rb_eArgError, "wrong argument (%d for 0 or 1)", i); break; } return Qnil; } static VALUE rb_gsl_complex_real(VALUE obj) { gsl_complex *c = NULL; Data_Get_Struct(obj, gsl_complex, c); return rb_float_new(GSL_REAL(*c)); } static VALUE rb_gsl_complex_imag(VALUE obj) { gsl_complex *c = NULL; Data_Get_Struct(obj, gsl_complex, c); return rb_float_new(GSL_IMAG(*c)); } static VALUE rb_gsl_complex_print(VALUE obj) { gsl_complex *c = NULL; Data_Get_Struct(obj, gsl_complex, c); fprintf(stdout, "[%4.3e %4.3e] \n", GSL_REAL(*c), GSL_IMAG(*c)); return obj; } static VALUE rb_gsl_complex_printf(VALUE obj, VALUE s) { gsl_complex *c = NULL; char tmp[32], format[64]; Check_Type(s, T_STRING); Data_Get_Struct(obj, gsl_complex, c); strcpy(tmp, STR2CSTR(s)); sprintf(format, "%s %s\n", tmp, tmp); fprintf(stdout, format, GSL_REAL(*c), GSL_IMAG(*c)); return obj; } static VALUE rb_gsl_complex_return_double(double (*func)(gsl_complex), VALUE obj); static VALUE rb_gsl_complex_return_double(double (*func)(gsl_complex), VALUE obj) { gsl_complex *c = NULL; Data_Get_Struct(obj, gsl_complex, c); return rb_float_new((*func)(*c)); } static VALUE rb_gsl_complex_arg(VALUE obj) { return rb_gsl_complex_return_double(gsl_complex_arg, obj); } static VALUE rb_gsl_complex_abs(VALUE obj) { return rb_gsl_complex_return_double(gsl_complex_abs, obj); } static VALUE rb_gsl_complex_abs2(VALUE obj) { return rb_gsl_complex_return_double(gsl_complex_abs2, obj); } static VALUE rb_gsl_complex_logabs(VALUE obj) { return rb_gsl_complex_return_double(gsl_complex_logabs, obj); } static VALUE rb_gsl_complex_arithmetics2(gsl_complex (*func)(gsl_complex, double), VALUE obj, VALUE xx); static VALUE rb_gsl_complex_arithmetics2(gsl_complex (*func)(gsl_complex, double), VALUE obj, VALUE xx) { gsl_complex *a = NULL, *c = NULL, tmp; VALUE obj2; double x; Need_Float(xx); Data_Get_Struct(obj, gsl_complex, a); x = NUM2DBL(xx); tmp = (*func)(*a, x); obj2 = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, c); *c = tmp; return obj2; } static VALUE rb_gsl_complex_add_real(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_add_real, obj, xx); } static VALUE rb_gsl_complex_sub_real(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_sub_real, obj, xx); } static VALUE rb_gsl_complex_mul_real(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_mul_real, obj, xx); } static VALUE rb_gsl_complex_div_real(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_div_real, obj, xx); } static VALUE rb_gsl_complex_add_imag(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_add_imag, obj, xx); } static VALUE rb_gsl_complex_sub_imag(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_sub_imag, obj, xx); } static VALUE rb_gsl_complex_mul_imag(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_mul_imag, obj, xx); } static VALUE rb_gsl_complex_div_imag(VALUE obj, VALUE xx) { return rb_gsl_complex_arithmetics2(gsl_complex_div_imag, obj, xx); } static VALUE rb_gsl_complex_operate(gsl_complex (*func)(gsl_complex), VALUE obj); static VALUE rb_gsl_complex_operate2(gsl_complex (*func)(gsl_complex), int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_complex_operate(gsl_complex (*func)(gsl_complex), VALUE obj) { gsl_complex *c = NULL, *cnew = NULL; Data_Get_Struct(obj, gsl_complex, c); cnew = ALLOC(gsl_complex); *cnew = (*func)(*c); return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_operate2(gsl_complex (*func)(gsl_complex), int argc, VALUE *argv, VALUE obj) { gsl_complex *c = NULL, *cnew = NULL, tmp; gsl_vector_complex *v, *vnew; gsl_matrix_complex *m, *mnew; size_t i, j; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: switch (TYPE(argv[0])) { case T_ARRAY: tmp = ary2complex(argv[0]); c = &tmp; break; default: if (VECTOR_COMPLEX_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); for (i = 0; i < v->size; i++) { c = GSL_COMPLEX_AT(v, i); gsl_vector_complex_set(vnew, i, (*func)(*c)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_free, vnew); } else if (MATRIX_COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_complex_set(mnew, i, j, (*func)(gsl_matrix_complex_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } else { CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, c); } break; } break; case 2: c = &tmp; GSL_SET_REAL(c, NUM2DBL(argv[0])); GSL_SET_IMAG(c, NUM2DBL(argv[1])); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: Data_Get_Struct(obj, gsl_complex, c); break; } cnew = ALLOC(gsl_complex); *cnew = (*func)(*c); return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_conjugate(VALUE obj) { return rb_gsl_complex_operate(gsl_complex_conjugate, obj); } static VALUE rb_gsl_complex_inverse(VALUE obj) { return rb_gsl_complex_operate(gsl_complex_inverse, obj); } static VALUE rb_gsl_complex_negative(VALUE obj) { return rb_gsl_complex_operate(gsl_complex_negative, obj); } /* singleton */ static VALUE rb_gsl_complex_sqrt_real(VALUE obj, VALUE x) { gsl_complex *cnew = NULL, tmp; Need_Float(x); tmp = gsl_complex_sqrt_real(NUM2DBL(x)); cnew = ALLOC(gsl_complex); *cnew = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_sqrt(int argc, VALUE *argv, VALUE obj) { gsl_complex *z, tmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: switch (TYPE(argv[0])) { case T_FIXNUM: case T_FLOAT: return rb_gsl_complex_sqrt_real(obj, argv[0]); break; case T_ARRAY: tmp = ary2complex(argv[0]); z = ALLOC(gsl_complex); *z = gsl_complex_sqrt(tmp); return Data_Wrap_Struct(cgsl_complex, 0, free, z); break; default: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, z); tmp = *z; z = ALLOC(gsl_complex); *z = gsl_complex_sqrt(tmp); return Data_Wrap_Struct(cgsl_complex, 0, free, z); break; } break; case 2: z = ALLOC(gsl_complex); GSL_SET_REAL(&tmp, NUM2DBL(argv[0])); GSL_SET_IMAG(&tmp, NUM2DBL(argv[1])); *z = gsl_complex_sqrt(tmp); return Data_Wrap_Struct(cgsl_complex, 0, free, z); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: return rb_gsl_complex_operate2(gsl_complex_sqrt, argc, argv, obj); break; } } VALUE rb_gsl_complex_pow(int argc, VALUE *argv, VALUE obj) { gsl_complex *c = NULL, *a = NULL, *cnew = NULL, tmpc, tmpa; gsl_vector_complex *v, *vnew; gsl_matrix_complex *m, *mnew; size_t i, j; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); switch (TYPE(argv[1])) { case T_ARRAY: tmpa = ary2complex(argv[1]); a = &tmpa; break; case T_FLOAT: case T_FIXNUM: return rb_gsl_complex_pow_real(argc, argv, obj); break; default: CHECK_COMPLEX(argv[1]); Data_Get_Struct(argv[1], gsl_complex, a); break; } switch (TYPE(argv[0])) { case T_ARRAY: tmpc = ary2complex(argv[0]); c = &tmpc; break; default: if (VECTOR_COMPLEX_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); for (i = 0; i < v->size; i++) { c = GSL_COMPLEX_AT(v, i); gsl_vector_complex_set(vnew, i, gsl_complex_pow(*c, *a)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } if (MATRIX_COMPLEX_P(argv[0])) { Data_Get_Struct(argv[0], gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { c = gsl_matrix_complex_ptr(m, i, j); gsl_matrix_complex_set(mnew, i, j, gsl_complex_pow(*c, *a)); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, c); break; } break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_COMPLEX(obj); Data_Get_Struct(obj, gsl_complex, c); switch (TYPE(argv[0])) { case T_ARRAY: tmpa = ary2complex(argv[0]); a = &tmpa; break; case T_FLOAT: case T_FIXNUM: return rb_gsl_complex_pow_real(argc, argv, obj); break; default: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, a); break; } break; } cnew = ALLOC(gsl_complex); *cnew = gsl_complex_pow(*c, *a); return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } VALUE rb_gsl_complex_pow_real(int argc, VALUE *argv, VALUE obj) { double a = 1; gsl_complex *c = NULL, *cnew = NULL, tmpc; gsl_vector_complex *v, *vnew; gsl_matrix_complex *m, *mnew; size_t i, j; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); switch (TYPE(argv[0])) { case T_ARRAY: tmpc = ary2complex(argv[0]); c = &tmpc; a = NUM2DBL(argv[1]); break; default: if (VECTOR_COMPLEX_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); a = NUM2DBL(argv[1]); for (i = 0; i < v->size; i++) { c = GSL_COMPLEX_AT(v, i); tmpc = gsl_complex_pow_real(*c, a); gsl_vector_complex_set(vnew, i, tmpc); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_free, vnew); } if (MATRIX_COMPLEX_P(argv[0])) { Data_Get_Struct(argv[0], gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { tmpc = gsl_complex_pow_real(gsl_matrix_complex_get(m, i, j), a); gsl_matrix_complex_set(mnew, i, j, tmpc); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, c); break; } Need_Float(argv[1]); a = NUM2DBL(argv[1]); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_COMPLEX(obj); Need_Float(argv[0]); Data_Get_Struct(obj, gsl_complex, c); a = NUM2DBL(argv[0]); break; } cnew = ALLOC(gsl_complex); *cnew = gsl_complex_pow_real(*c, a); return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_exp(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_exp, argc, argv, obj); } static VALUE rb_gsl_complex_log(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_log, argc, argv, obj); } static VALUE rb_gsl_complex_log10(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_log10, argc, argv, obj); } static VALUE rb_gsl_complex_log_b(int argc, VALUE *argv, VALUE obj) { gsl_complex *c = NULL, *a = NULL, *cnew = NULL, tmpc, tmpa; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); switch (TYPE(argv[1])) { case T_ARRAY: tmpa = ary2complex(argv[1]); a = &tmpa; break; default: CHECK_COMPLEX(argv[1]); Data_Get_Struct(argv[1], gsl_complex, a); break; } switch (TYPE(argv[0])) { case T_ARRAY: tmpc = ary2complex(argv[0]); c = &tmpc; break; default: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, c); break; } break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_COMPLEX(obj); Data_Get_Struct(obj, gsl_complex, c); switch (TYPE(argv[0])) { case T_ARRAY: tmpa = ary2complex(argv[0]); a = &tmpa; break; default: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, a); break; } break; } cnew = ALLOC(gsl_complex); *cnew = gsl_complex_log_b(*c, *a); return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_sin(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_sin, argc, argv, obj); } static VALUE rb_gsl_complex_cos(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_cos, argc, argv, obj); } static VALUE rb_gsl_complex_tan(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_tan, argc, argv, obj); } static VALUE rb_gsl_complex_sec(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_sec, argc, argv, obj); } static VALUE rb_gsl_complex_csc(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_csc, argc, argv, obj); } static VALUE rb_gsl_complex_cot(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_cot, argc, argv, obj); } /*****/ static VALUE rb_gsl_complex_arcsin(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arcsin, argc, argv, obj); } static VALUE rb_gsl_complex_arcsin_real(VALUE obj, VALUE xx) { gsl_complex tmp, *cnew = NULL; double x; Need_Float(xx); x = NUM2DBL(xx); tmp = gsl_complex_arcsin_real(x); cnew = ALLOC(gsl_complex); *cnew = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_arccos(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arccos, argc, argv, obj); } static VALUE rb_gsl_complex_arccos_real(VALUE obj, VALUE xx) { gsl_complex tmp, *cnew = NULL; double x; Need_Float(xx); x = NUM2DBL(xx); tmp = gsl_complex_arccos_real(x); cnew = ALLOC(gsl_complex); *cnew = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_arctan(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arctan, argc, argv, obj); } static VALUE rb_gsl_complex_arcsec(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arcsec, argc, argv, obj); } static VALUE rb_gsl_complex_arcsec_real(VALUE obj, VALUE xx) { gsl_complex tmp, *cnew = NULL; double x; Need_Float(xx); x = NUM2DBL(xx); tmp = gsl_complex_arcsec_real(x); cnew = ALLOC(gsl_complex); *cnew = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_arccsc(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arccsc, argc, argv, obj); } static VALUE rb_gsl_complex_arccsc_real(VALUE obj, VALUE xx) { gsl_complex tmp, *cnew = NULL; double x; Need_Float(xx); x = NUM2DBL(xx); tmp = gsl_complex_arccsc_real(x); cnew = ALLOC(gsl_complex); *cnew = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_arccot(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arccot, argc, argv, obj); } static VALUE rb_gsl_complex_sinh(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_sinh, argc, argv, obj); } static VALUE rb_gsl_complex_cosh(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_cosh, argc, argv, obj); } static VALUE rb_gsl_complex_tanh(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_tanh, argc, argv, obj); } static VALUE rb_gsl_complex_sech(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_sech, argc, argv, obj); } static VALUE rb_gsl_complex_csch(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_csch, argc, argv, obj); } static VALUE rb_gsl_complex_coth(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_coth, argc, argv, obj); } static VALUE rb_gsl_complex_arcsinh(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arcsinh, argc, argv, obj); } static VALUE rb_gsl_complex_arccosh_real(VALUE obj, VALUE xx) { gsl_complex tmp, *cnew = NULL; double x; Need_Float(xx); x = NUM2DBL(xx); tmp = gsl_complex_arccosh_real(x); cnew = ALLOC(gsl_complex); *cnew = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_arccosh(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arccosh, argc, argv, obj); } static VALUE rb_gsl_complex_arctanh(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arctanh, argc, argv, obj); } static VALUE rb_gsl_complex_arctanh_real(VALUE obj, VALUE xx) { gsl_complex tmp, *cnew = NULL; double x; Need_Float(xx); x = NUM2DBL(xx); tmp = gsl_complex_arctanh_real(x); cnew = ALLOC(gsl_complex); *cnew = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, cnew); } static VALUE rb_gsl_complex_arcsech(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arcsech, argc, argv, obj); } static VALUE rb_gsl_complex_arccsch(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arccsch, argc, argv, obj); } static VALUE rb_gsl_complex_arccoth(int argc, VALUE *argv, VALUE obj) { return rb_gsl_complex_operate2(gsl_complex_arccoth, argc, argv, obj); } int rbgsl_complex_equal(const gsl_complex *z1, const gsl_complex *z2, double eps) { if (gsl_fcmp(z1->dat[0], z2->dat[0], eps) != 0) return 0; if (gsl_fcmp(z1->dat[1], z2->dat[1], eps) != 0) return 0; return 1; } int rbgsl_complex_zero(const gsl_complex *z1) { if (z1->dat[0] != 0.0) return 0; if (z1->dat[1] != 0.0) return 0; return 1; } static VALUE rb_gsl_complex_equal(int argc, VALUE *argv, VALUE obj) { gsl_complex *z1 = NULL, *z2 = NULL; double eps = 1e-8; switch (argc) { case 1: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, z2); break; case 2: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, z2); eps = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of argumsnts (%d for 1 or 2)", argc); } Data_Get_Struct(obj, gsl_complex, z1); if (rbgsl_complex_equal(z1, z2, eps)) return Qtrue; else return Qfalse; } static VALUE rb_gsl_complex_zero(VALUE obj) { gsl_complex *z = NULL; Data_Get_Struct(obj, gsl_complex, z); if (rbgsl_complex_zero(z)) return Qtrue; else return Qfalse; } static VALUE rb_gsl_complex_to_s(VALUE obj) { char buf[256]; gsl_complex *z; Data_Get_Struct(obj, gsl_complex, z); sprintf(buf, "[ %4.3e %4.3e ]", GSL_REAL(*z), GSL_IMAG(*z)); return rb_str_new2(buf); } static VALUE rb_gsl_complex_inspect(VALUE obj) { char buf[256]; VALUE str; sprintf(buf, "%s\n", rb_class2name(CLASS_OF(obj))); str = rb_str_new2(buf); return rb_str_concat(str, rb_gsl_complex_to_s(obj)); } void Init_gsl_complex(VALUE module) { cgsl_complex = rb_define_class_under(module, "Complex", rb_cNumeric); rb_define_singleton_method(cgsl_complex, "alloc", rb_gsl_complex_new, -1); rb_define_singleton_method(cgsl_complex, "rect", rb_gsl_complex_new, -1); rb_define_singleton_method(cgsl_complex, "[]", rb_gsl_complex_new, -1); rb_define_singleton_method(cgsl_complex, "polar", rb_gsl_complex_polar, 2); rb_define_method(cgsl_complex, "equal?", rb_gsl_complex_equal, -1); rb_define_alias(cgsl_complex, "==", "equal?"); rb_define_method(cgsl_complex, "zero?", rb_gsl_complex_zero, 0); rb_define_method(cgsl_complex, "get", rb_gsl_complex_get, 1); rb_define_alias(cgsl_complex, "[]", "get"); rb_define_method(cgsl_complex, "real", rb_gsl_complex_real, 0); rb_define_alias(cgsl_complex, "re", "real"); rb_define_alias(cgsl_complex, "REAL", "real"); rb_define_method(cgsl_complex, "imag", rb_gsl_complex_imag, 0); rb_define_alias(cgsl_complex, "im", "imag"); rb_define_alias(cgsl_complex, "IMAG", "imag"); rb_define_method(cgsl_complex, "print", rb_gsl_complex_print, 0); rb_define_method(cgsl_complex, "printf", rb_gsl_complex_printf, 1); rb_define_alias(cgsl_complex, "show", "print"); rb_define_method(cgsl_complex, "arg", rb_gsl_complex_arg, 0); rb_define_alias(cgsl_complex, "angle", "arg"); rb_define_alias(cgsl_complex, "phase", "arg"); rb_define_method(cgsl_complex, "abs", rb_gsl_complex_abs, 0); rb_define_alias(cgsl_complex, "amp", "abs"); rb_define_alias(cgsl_complex, "mag", "abs"); rb_define_method(cgsl_complex, "abs2", rb_gsl_complex_abs2, 0); rb_define_method(cgsl_complex, "logabs", rb_gsl_complex_logabs, 0); rb_define_method(cgsl_complex, "add_real", rb_gsl_complex_add_real, 1); rb_define_method(cgsl_complex, "sub_real", rb_gsl_complex_sub_real, 1); rb_define_method(cgsl_complex, "mul_real", rb_gsl_complex_mul_real, 1); rb_define_method(cgsl_complex, "div_real", rb_gsl_complex_div_real, 1); rb_define_method(cgsl_complex, "add_imag", rb_gsl_complex_add_imag, 1); rb_define_method(cgsl_complex, "sub_imag", rb_gsl_complex_sub_imag, 1); rb_define_method(cgsl_complex, "mul_imag", rb_gsl_complex_mul_imag, 1); rb_define_method(cgsl_complex, "div_imag", rb_gsl_complex_div_imag, 1); rb_define_method(cgsl_complex, "conjugate", rb_gsl_complex_conjugate, 0); rb_define_alias(cgsl_complex, "conj", "conjugate"); rb_define_method(cgsl_complex, "inverse", rb_gsl_complex_inverse, 0); rb_define_method(cgsl_complex, "negative", rb_gsl_complex_negative, 0); rb_define_singleton_method(cgsl_complex, "sqrt", rb_gsl_complex_sqrt, -1); rb_define_singleton_method(cgsl_complex, "sqrt_real", rb_gsl_complex_sqrt_real, 1); rb_define_singleton_method(cgsl_complex, "pow", rb_gsl_complex_pow, -1); rb_define_singleton_method(cgsl_complex, "pow_real", rb_gsl_complex_pow_real, -1); rb_define_singleton_method(cgsl_complex, "exp", rb_gsl_complex_exp, -1); rb_define_singleton_method(cgsl_complex, "log", rb_gsl_complex_log, -1); rb_define_singleton_method(cgsl_complex, "log10", rb_gsl_complex_log10, -1); rb_define_singleton_method(cgsl_complex, "log_b", rb_gsl_complex_log_b, -1); rb_define_singleton_method(cgsl_complex, "sin", rb_gsl_complex_sin, -1); rb_define_singleton_method(cgsl_complex, "cos", rb_gsl_complex_cos, -1); rb_define_singleton_method(cgsl_complex, "tan", rb_gsl_complex_tan, -1); rb_define_singleton_method(cgsl_complex, "sec", rb_gsl_complex_sec, -1); rb_define_singleton_method(cgsl_complex, "csc", rb_gsl_complex_csc, -1); rb_define_singleton_method(cgsl_complex, "cot", rb_gsl_complex_cot, -1); rb_define_singleton_method(cgsl_complex, "arcsin", rb_gsl_complex_arcsin, -1); rb_define_singleton_method(cgsl_complex, "arcsin_real", rb_gsl_complex_arcsin_real, 1); rb_define_singleton_method(cgsl_complex, "arccos", rb_gsl_complex_arccos, -1); rb_define_singleton_method(cgsl_complex, "arccos_real", rb_gsl_complex_arccos_real, 1); rb_define_singleton_method(cgsl_complex, "arctan", rb_gsl_complex_arctan, -1); rb_define_singleton_method(cgsl_complex, "arcsec", rb_gsl_complex_arcsec, -1); rb_define_singleton_method(cgsl_complex, "arcsec_real", rb_gsl_complex_arcsec_real, 1); rb_define_singleton_method(cgsl_complex, "arccsc", rb_gsl_complex_arccsc, -1); rb_define_singleton_method(cgsl_complex, "arccsc_real", rb_gsl_complex_arccsc_real, 1); rb_define_singleton_method(cgsl_complex, "arccot", rb_gsl_complex_arccot, -1); rb_define_singleton_method(cgsl_complex, "sinh", rb_gsl_complex_sinh, -1); rb_define_singleton_method(cgsl_complex, "cosh", rb_gsl_complex_cosh, -1); rb_define_singleton_method(cgsl_complex, "tanh", rb_gsl_complex_tanh, -1); rb_define_singleton_method(cgsl_complex, "sech", rb_gsl_complex_sech, -1); rb_define_singleton_method(cgsl_complex, "csch", rb_gsl_complex_csch, -1); rb_define_singleton_method(cgsl_complex, "coth", rb_gsl_complex_coth, -1); rb_define_singleton_method(cgsl_complex, "arcsinh", rb_gsl_complex_arcsinh, -1); rb_define_singleton_method(cgsl_complex, "arccosh", rb_gsl_complex_arccosh, -1); rb_define_singleton_method(cgsl_complex, "arccosh_real", rb_gsl_complex_arccosh_real, 1); rb_define_singleton_method(cgsl_complex, "arctanh", rb_gsl_complex_arctanh, -1); rb_define_singleton_method(cgsl_complex, "arctanh_real", rb_gsl_complex_arctanh_real, 1); rb_define_singleton_method(cgsl_complex, "arcsech", rb_gsl_complex_arcsech, -1); rb_define_singleton_method(cgsl_complex, "arccsch", rb_gsl_complex_arccsch, -1); rb_define_singleton_method(cgsl_complex, "arccoth", rb_gsl_complex_arccoth, -1); /***/ rb_define_method(cgsl_complex, "pow", rb_gsl_complex_pow, -1); rb_define_method(cgsl_complex, "pow_real", rb_gsl_complex_pow_real, -1); rb_define_method(cgsl_complex, "exp", rb_gsl_complex_exp, -1); rb_define_method(cgsl_complex, "log", rb_gsl_complex_log, -1); rb_define_method(cgsl_complex, "log10", rb_gsl_complex_log10, -1); rb_define_method(cgsl_complex, "log_b", rb_gsl_complex_log_b, -1); rb_define_method(cgsl_complex, "sin", rb_gsl_complex_sin, -1); rb_define_method(cgsl_complex, "cos", rb_gsl_complex_cos, -1); rb_define_method(cgsl_complex, "tan", rb_gsl_complex_tan, -1); rb_define_method(cgsl_complex, "sec", rb_gsl_complex_sec, -1); rb_define_method(cgsl_complex, "csc", rb_gsl_complex_csc, -1); rb_define_method(cgsl_complex, "cot", rb_gsl_complex_cot, -1); rb_define_method(cgsl_complex, "arcsin", rb_gsl_complex_arcsin, -1); rb_define_method(cgsl_complex, "arccos", rb_gsl_complex_arccos, -1); rb_define_method(cgsl_complex, "arctan", rb_gsl_complex_arctan, -1); rb_define_method(cgsl_complex, "arcsec", rb_gsl_complex_arcsec, -1); rb_define_method(cgsl_complex, "arccsc", rb_gsl_complex_arccsc, -1); rb_define_method(cgsl_complex, "arccot", rb_gsl_complex_arccot, -1); rb_define_method(cgsl_complex, "sinh", rb_gsl_complex_sinh, -1); rb_define_method(cgsl_complex, "cosh", rb_gsl_complex_cosh, -1); rb_define_method(cgsl_complex, "tanh", rb_gsl_complex_tanh, -1); rb_define_method(cgsl_complex, "sech", rb_gsl_complex_sech, -1); rb_define_method(cgsl_complex, "csch", rb_gsl_complex_csch, -1); rb_define_method(cgsl_complex, "coth", rb_gsl_complex_coth, -1); rb_define_method(cgsl_complex, "arcsinh", rb_gsl_complex_arcsinh, -1); rb_define_method(cgsl_complex, "arccosh", rb_gsl_complex_arccosh, -1); rb_define_method(cgsl_complex, "arctanh", rb_gsl_complex_arctanh, -1); rb_define_method(cgsl_complex, "arcsech", rb_gsl_complex_arcsech, -1); rb_define_method(cgsl_complex, "arccsch", rb_gsl_complex_arccsch, -1); rb_define_method(cgsl_complex, "arccoth", rb_gsl_complex_arccoth, -1); rb_define_method(cgsl_complex, "to_s", rb_gsl_complex_to_s, 0); rb_define_method(cgsl_complex, "inspect", rb_gsl_complex_inspect, 0); } gsl-1.15.3/ext/block_source.c0000644000175000017500000005741112220252463015370 0ustar boutilboutil/* block_source.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2005 by Yoshiki Tsunesada Cameron McBride Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #ifdef BASE_DOUBLE #define CHECK_BL CHECK_BLOCK #define C_TO_VALUE rb_float_new #define BL_P BLOCK_P #elif defined(BASE_INT) #define C_TO_VALUE INT2FIX #define CHECK_BL CHECK_BLOCK_INT #define BL_P BLOCK_INT_P #else #define C_TO_VALUE INT2FIX #define CHECK_BL CHECK_BLOCK_UCHAR #define BL_P BLOCK_UCHAR_P #endif static VALUE FUNCTION(rb_gsl_block,new)(VALUE klass, VALUE nn) { GSL_TYPE(gsl_block) *block = NULL; CHECK_FIXNUM(nn); block = FUNCTION(gsl_block,alloc)(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_block,free), block); } static VALUE FUNCTION(rb_gsl_block,calloc)(VALUE klass, VALUE nn) { GSL_TYPE(gsl_block) *block = NULL; CHECK_FIXNUM(nn); block = FUNCTION(gsl_block,calloc)(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_block,free), block); } static VALUE FUNCTION(rb_gsl_block,size)(VALUE obj) { GSL_TYPE(gsl_block) *block = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_block), block); return INT2FIX(block->size); } static VALUE FUNCTION(rb_gsl_block,fwrite)(VALUE obj, VALUE io) { GSL_TYPE(gsl_block) *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_block), h); f = rb_gsl_open_writefile(io, &flag); status = FUNCTION(gsl_block,fwrite)(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_block,fread)(VALUE obj, VALUE io) { GSL_TYPE(gsl_block) *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_block), h); f = rb_gsl_open_readfile(io, &flag); status = FUNCTION(gsl_block,fread)(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } #ifdef BASE_DOUBLE #define FORMAT_DEFAULT "%g" #else #define FORMAT_DEFAULT "%d" #endif static VALUE FUNCTION(rb_gsl_block,fprintf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_block) *h = NULL; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); Data_Get_Struct(obj, GSL_TYPE(gsl_block), h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 2) { Check_Type(argv[1], T_STRING); status = FUNCTION(gsl_block,fprintf)(fp, h, STR2CSTR(argv[1])); } else { status = FUNCTION(gsl_block,fprintf)(fp, h, FORMAT_DEFAULT); } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_block,printf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_block) *h = NULL; int status; Data_Get_Struct(obj, GSL_TYPE(gsl_block), h); if (argc == 1) { Check_Type(argv[0], T_STRING); status = FUNCTION(gsl_block,fprintf)(stdout, h, STR2CSTR(argv[0])); } else { status = FUNCTION(gsl_block,fprintf)(stdout, h, FORMAT_DEFAULT); } return INT2FIX(status); } #undef FORMAT_DEFAULT static VALUE FUNCTION(rb_gsl_block,fscanf)(VALUE obj, VALUE io) { GSL_TYPE(gsl_block) *h = NULL; FILE *fp = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_block), h); fp = rb_gsl_open_readfile(io, &flag); status = FUNCTION(gsl_block,fscanf)(fp, h); if (flag == 1) fclose(fp); return INT2FIX(status); } #ifdef BASE_DOUBLE #define SHOW_ELM 6 #define PRINTF_FORMAT "%4.3e " #define TYPE2 double #else #define SHOW_ELM 15 #define PRINTF_FORMAT "%d " #define TYPE2 int #endif static VALUE FUNCTION(rb_gsl_block,to_s)(VALUE obj) { GSL_TYPE(gsl_block) *v = NULL; char buf[32]; size_t i, n; VALUE str; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); str = rb_str_new2("[ "); n = v->size; if (rb_obj_is_kind_of(obj, cgsl_block_complex)) n *= 2; for (i = 0; i < n; i++) { sprintf(buf, PRINTF_FORMAT, (TYPE2) v->data[i]); rb_str_cat(str, buf, strlen(buf)); if (i == SHOW_ELM && i != v->size-1) { strcpy(buf, "... "); rb_str_cat(str, buf, strlen(buf)); break; } } sprintf(buf, "]"); rb_str_cat(str, buf, strlen(buf)); return str; } #undef SHOW_ELM #undef PRINTF_FORMAT static VALUE FUNCTION(rb_gsl_block,inspect)(VALUE obj) { VALUE str; char buf[64]; sprintf(buf, "%s\n", rb_class2name(CLASS_OF(obj))); str = rb_str_new2(buf); return rb_str_concat(str, FUNCTION(rb_gsl_block,to_s)(obj)); } #ifdef BASE_DOUBLE #define C_TO_VALUE rb_float_new #define NUMCONV NUM2DBL #else #define C_TO_VALUE INT2FIX #define NUMCONV FIX2INT #endif void get_range_int_beg_en_n(VALUE range, int *beg, int *en, size_t *n, int *step); static VALUE FUNCTION(rb_gsl_block,get)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_block) *b, *bnew; gsl_index *p; int beg, en, i, step; size_t n, j, k; Data_Get_Struct(obj, GSL_TYPE(gsl_block), b); switch (argc) { case 0: rb_raise(rb_eArgError, "too few arguments (%d for >= 1)", argc); break; case 1: switch (TYPE(argv[0])) { case T_FIXNUM: i = FIX2INT(argv[0]); if (i < 0) j = b->size + i; else j = (size_t) i; return C_TO_VALUE(b->data[j]); break; case T_ARRAY: // n = RARRAY(argv[0])->len; n = RARRAY_LEN(argv[0]); bnew = FUNCTION(gsl_block,alloc)(n); for (j = 0; j < n; j++) { i = FIX2INT(rb_ary_entry(argv[0], j)); if (i < 0) k = b->size + i; else k = i; bnew->data[j] = b->data[k]; } return Data_Wrap_Struct(GSL_TYPE(cgsl_block), 0, FUNCTION(gsl_block,free), bnew); break; default: if (PERMUTATION_P(argv[0])) { Data_Get_Struct(argv[0], gsl_index, p); bnew = FUNCTION(gsl_block,alloc)(p->size); for (j = 0; j < p->size; j++) bnew->data[j] = b->data[p->data[j]]; return Data_Wrap_Struct(GSL_TYPE(cgsl_block), 0, FUNCTION(gsl_block,free), bnew); } else if (CLASS_OF(argv[0]) == rb_cRange) { get_range_int_beg_en_n(argv[0], &beg, &en, &n, &step); bnew = FUNCTION(gsl_block,alloc)(n); for (j = 0; j < n; j++) bnew->data[j] = b->data[beg+j]; return Data_Wrap_Struct(GSL_TYPE(cgsl_block), 0, FUNCTION(gsl_block,free), bnew); } else { rb_raise(rb_eArgError, "wrong argument type %s (Fixnum, Array, or Range expected)", rb_class2name(CLASS_OF(argv[0]))); break; } } break; default: bnew = FUNCTION(gsl_block,alloc)(argc); for (j = 0; j < argc; j++) { i = FIX2INT(argv[j]); if (i < 0) k = b->size + i; else k = i; bnew->data[j] = b->data[k]; } return Data_Wrap_Struct(GSL_TYPE(cgsl_block), 0, FUNCTION(gsl_block,free), bnew); break; } return Qnil; } static VALUE FUNCTION(rb_gsl_block,set)(VALUE obj, VALUE ii, VALUE xx) { GSL_TYPE(gsl_block) *b; BASE x; size_t i; CHECK_FIXNUM(ii); i = FIX2INT(ii); x = (BASE) NUMCONV(xx); Data_Get_Struct(obj, GSL_TYPE(gsl_block), b); b->data[i] = x; return obj; } static int FUNCTION(gsl_block,eq)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x > y || x < y) ? 0 : 1; } return 0; } static int FUNCTION(gsl_block,ne)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x > y || x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,gt)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x > y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,ge)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x >= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,lt)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,le)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x <= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,and)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x != 0 && y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,or)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = (x != 0 || y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,xor)(const GSL_TYPE(gsl_block) *a, const GSL_TYPE(gsl_block) *b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != b->size) return -1; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b->data[i]; c->data[i] = ((x != 0) == (y != 0)) ? 0 : 1; } return 0; } static int FUNCTION(gsl_block,eq2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x > y || x < y) ? 0 : 1; } return 0; } static int FUNCTION(gsl_block,ne2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x > y || x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,gt2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x > y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,ge2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x >= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,lt2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x < y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,le2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x <= y) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,and2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x != 0 && y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,or2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = (x != 0 || y != 0) ? 1 : 0; } return 0; } static int FUNCTION(gsl_block,xor2)(const GSL_TYPE(gsl_block) *a, BASE b, gsl_block_uchar *c) { size_t i; BASE x, y; if (a->size != c->size) return -2; for (i = 0; i < a->size; i++) { x = a->data[i]; y = b; c->data[i] = ((x != 0) == (y != 0)) ? 0 : 1; } return 0; } static VALUE FUNCTION(rb_gsl_block,compare)(VALUE aa, VALUE bb, int (*cmp)(const GSL_TYPE(gsl_block)*, const GSL_TYPE(gsl_block)*, gsl_block_uchar*), int (*cmp2)(const GSL_TYPE(gsl_block)*, BASE, gsl_block_uchar*)) { GSL_TYPE(gsl_block) *a, *b; /* gsl_block_int *c;*/ gsl_block_uchar *c; // local variable "status" declared and set, but never used //int status; Data_Get_Struct(aa, GSL_TYPE(gsl_block), a); c = gsl_block_uchar_alloc(a->size); if (BL_P(bb)) { Data_Get_Struct(bb, GSL_TYPE(gsl_block), b); if (a->size != b->size) rb_raise(rb_eRuntimeError, "Block size mismatch, %d and %d", (int) a->size, (int) b->size); /*status =*/ (*cmp)(a, b, c); } else { /*status =*/ (*cmp2)(a, NUMCONV(bb), c); } return Data_Wrap_Struct(cgsl_block_uchar, 0, gsl_block_uchar_free, c); } static VALUE FUNCTION(rb_gsl_block,eq)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,eq), FUNCTION(gsl_block,eq2)); } static VALUE FUNCTION(rb_gsl_block,ne)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,ne), FUNCTION(gsl_block,ne2)); } static VALUE FUNCTION(rb_gsl_block,gt)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,gt), FUNCTION(gsl_block,gt2)); } static VALUE FUNCTION(rb_gsl_block,ge)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,ge), FUNCTION(gsl_block,ge2)); } static VALUE FUNCTION(rb_gsl_block,lt)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,lt), FUNCTION(gsl_block,lt2)); } static VALUE FUNCTION(rb_gsl_block,le)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,le), FUNCTION(gsl_block,le2)); } static VALUE FUNCTION(rb_gsl_block,and)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,and), FUNCTION(gsl_block,and2)); } static VALUE FUNCTION(rb_gsl_block,or)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,or), FUNCTION(gsl_block,or2)); } static VALUE FUNCTION(rb_gsl_block,xor)(VALUE aa, VALUE bb) { return FUNCTION(rb_gsl_block,compare)(aa, bb, FUNCTION(gsl_block,xor), FUNCTION(gsl_block,xor2)); } static VALUE FUNCTION(rb_gsl_block,not)(VALUE obj) { GSL_TYPE(gsl_block) *v; gsl_block_uchar *vv; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); vv = gsl_block_uchar_alloc(v->size); for (i = 0; i < v->size; i++) vv->data[i] = (v->data[i] != 0) ? 0 : 1; return Data_Wrap_Struct(cgsl_block_uchar, 0, gsl_block_uchar_free, vv); } static VALUE FUNCTION(rb_gsl_block,any)(VALUE obj) { GSL_TYPE(gsl_block) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) { if (rb_yield(C_TO_VALUE(v->data[i]))) return INT2FIX(1); } return INT2FIX(0); } else { for (i = 0; i < v->size; i++) if (v->data[i]) return INT2FIX(1); return INT2FIX(0); } } static VALUE FUNCTION(rb_gsl_block,any2)(VALUE obj) { GSL_TYPE(gsl_block) *v = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) { if (rb_yield(C_TO_VALUE(v->data[i]))) return Qtrue; } return Qfalse; } else { for (i = 0; i < v->size; i++) if (v->data[i]) return Qtrue; return Qfalse; } } static VALUE FUNCTION(rb_gsl_block,all)(VALUE obj) { GSL_TYPE(gsl_block) *v; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) if (!rb_yield(C_TO_VALUE(v->data[i]))) return Qfalse; return Qtrue; } else { for (i = 0; i < v->size; i++) if (!v->data[i]) return Qfalse; return Qtrue; } } static VALUE FUNCTION(rb_gsl_block,none)(VALUE obj) { GSL_TYPE(gsl_block) *v; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); if (rb_block_given_p()) { for (i = 0; i < v->size; i++) if (rb_yield(C_TO_VALUE(v->data[i]))) return Qfalse; return Qtrue; } else { for (i = 0; i < v->size; i++) if (v->data[i]) return Qfalse; return Qtrue; } } static VALUE FUNCTION(rb_gsl_block,where)(VALUE obj) { GSL_TYPE(gsl_block) *v; gsl_index *vv; gsl_block_uchar *btmp = NULL; size_t i, j, n = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); /* count true elements */ if (rb_block_given_p()) { btmp = gsl_block_uchar_alloc(v->size); for (i = 0; i < v->size; i++) { if (rb_yield(C_TO_VALUE(v->data[i]))) { btmp->data[i] = 1; n++; } else { btmp->data[i] = 0; } } /* for */ } else { /* block is not given */ for (i = 0; i < v->size; i++) { if (v->data[i]) n++; } } if (n == 0) { if (btmp) gsl_block_uchar_free(btmp); return Qnil; } vv = gsl_permutation_alloc(n); for (i = 0, j = 0; i < v->size; i++) { if ((!btmp && v->data[i]) || (btmp && btmp->data[i])) { vv->data[j++] = i; } } if (btmp) gsl_block_uchar_free(btmp); return Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, vv); } static VALUE FUNCTION(rb_gsl_block,where2)(VALUE obj) { GSL_TYPE(gsl_block) *v; gsl_index *v1, *v2; gsl_block_uchar *btmp = NULL; VALUE vv1, vv2; size_t i, j, k, n = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_block), v); if (rb_block_given_p()) { btmp = gsl_block_uchar_alloc(v->size); for (i = 0; i < v->size; i++) { if (rb_yield(C_TO_VALUE(v->data[i]))) { btmp->data[i] = 1; n++; } else { btmp->data[i] = 0; } } /* for */ } else { /* block is not given */ for (i = 0; i < v->size; i++) { if (v->data[i]) n++; } } /* true and false logic. need to handle both */ if (n == 0) { v2 = gsl_permutation_calloc(v->size); /* calloc() initializes v2 */ vv1 = Qnil; vv2 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v2); } else if (v->size-n == 0) { v1 = gsl_permutation_calloc(n); /* calloc() initializes v1 */ vv1 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v1); vv2 = Qnil; } else { /* same case as 'where' */ v1 = gsl_permutation_alloc(n); v2 = gsl_permutation_alloc(v->size-n); for (i = 0, j = 0, k = 0; i < v->size; i++) { if ((!btmp && v->data[i]) || (btmp && btmp->data[i])) v1->data[j++] = i; else v2->data[k++] = i; } vv1 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v1); vv2 = Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, v2); } if (btmp) gsl_block_uchar_free(btmp); return rb_ary_new3(2, vv1, vv2); } static VALUE FUNCTION(rb_gsl_block,each)(VALUE obj) { GSL_TYPE(gsl_block) *b = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), b); for (i = 0; i < b->size; i++) { rb_yield(C_TO_VALUE(b->data[i])); } return obj; } static VALUE FUNCTION(rb_gsl_block,each_index)(VALUE obj) { GSL_TYPE(gsl_block) *b = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), b); for (i = 0; i < b->size; i++) { rb_yield(INT2FIX(i)); } return obj; } static VALUE FUNCTION(rb_gsl_block,collect)(VALUE obj) { GSL_TYPE(gsl_block) *b = NULL, *bnew; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), b); bnew = FUNCTION(gsl_block,alloc)(b->size); for (i = 0; i < b->size; i++) { bnew->data[i] = NUMCONV(rb_yield(C_TO_VALUE(b->data[i]))); } return Data_Wrap_Struct(GSL_TYPE(cgsl_block), 0, FUNCTION(gsl_block,free), bnew); } static VALUE FUNCTION(rb_gsl_block,collect_bang)(VALUE obj) { GSL_TYPE(gsl_block) *b = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_block), b); for (i = 0; i < b->size; i++) { b->data[i] = NUMCONV(rb_yield(C_TO_VALUE(b->data[i]))); } return obj; } #undef C_TO_VALUE #undef NUMCONV #undef TYPE2 #undef CHECK_BL #undef BL_P void FUNCTION(Init_gsl_block,init)(VALUE module) { rb_define_singleton_method(GSL_TYPE(cgsl_block), "new", FUNCTION(rb_gsl_block,new), 1); rb_define_singleton_method(GSL_TYPE(cgsl_block), "alloc", FUNCTION(rb_gsl_block,new), 1); rb_define_singleton_method(GSL_TYPE(cgsl_block), "calloc", FUNCTION(rb_gsl_block,calloc), 1); rb_define_method(GSL_TYPE(cgsl_block), "size", FUNCTION(rb_gsl_block,size), 0); rb_define_alias(GSL_TYPE(cgsl_block), "length", "size"); rb_define_method(GSL_TYPE(cgsl_block), "fwrite", FUNCTION(rb_gsl_block,fwrite), 1); rb_define_method(GSL_TYPE(cgsl_block), "fread", FUNCTION(rb_gsl_block,fread), 1); rb_define_method(GSL_TYPE(cgsl_block), "fprintf", FUNCTION(rb_gsl_block,fprintf), -1); rb_define_method(GSL_TYPE(cgsl_block), "printf", FUNCTION(rb_gsl_block,printf), -1); rb_define_method(GSL_TYPE(cgsl_block), "fscanf", FUNCTION(rb_gsl_block,fscanf), 1); rb_define_method(GSL_TYPE(cgsl_block), "inspect", FUNCTION(rb_gsl_block,inspect), 0); rb_define_method(GSL_TYPE(cgsl_block), "to_s", FUNCTION(rb_gsl_block,to_s), 0); rb_define_method(GSL_TYPE(cgsl_block), "get", FUNCTION(rb_gsl_block,get), -1); rb_define_alias(GSL_TYPE(cgsl_block), "[]", "get"); rb_define_method(GSL_TYPE(cgsl_block), "set", FUNCTION(rb_gsl_block,set), 2); rb_define_alias(GSL_TYPE(cgsl_block), "[]=", "set"); /*****/ rb_define_method(GSL_TYPE(cgsl_block), "eq", FUNCTION(rb_gsl_block,eq), 1); rb_define_method(GSL_TYPE(cgsl_block), "ne", FUNCTION(rb_gsl_block,ne), 1); rb_define_method(GSL_TYPE(cgsl_block), "gt", FUNCTION(rb_gsl_block,gt), 1); rb_define_alias(GSL_TYPE(cgsl_block), ">", "gt"); rb_define_method(GSL_TYPE(cgsl_block), "ge", FUNCTION(rb_gsl_block,ge), 1); rb_define_alias(GSL_TYPE(cgsl_block), ">=", "ge"); rb_define_method(GSL_TYPE(cgsl_block), "lt", FUNCTION(rb_gsl_block,lt), 1); rb_define_alias(GSL_TYPE(cgsl_block), "<", "lt"); rb_define_method(GSL_TYPE(cgsl_block), "le", FUNCTION(rb_gsl_block,le), 1); rb_define_alias(GSL_TYPE(cgsl_block), "<=", "le"); rb_define_method(GSL_TYPE(cgsl_block), "and", FUNCTION(rb_gsl_block,and), 1); rb_define_method(GSL_TYPE(cgsl_block), "or", FUNCTION(rb_gsl_block,or), 1); rb_define_method(GSL_TYPE(cgsl_block), "xor", FUNCTION(rb_gsl_block,xor), 1); rb_define_method(GSL_TYPE(cgsl_block), "not", FUNCTION(rb_gsl_block,not), 0); rb_define_method(GSL_TYPE(cgsl_block), "all?", FUNCTION(rb_gsl_block,all), 0); rb_define_method(GSL_TYPE(cgsl_block), "none?", FUNCTION(rb_gsl_block,none), 0); rb_define_method(GSL_TYPE(cgsl_block), "any", FUNCTION(rb_gsl_block,any), 0); rb_define_method(GSL_TYPE(cgsl_block), "any?", FUNCTION(rb_gsl_block,any2), 0); rb_define_method(GSL_TYPE(cgsl_block), "where", FUNCTION(rb_gsl_block,where), 0); rb_define_method(GSL_TYPE(cgsl_block), "where2", FUNCTION(rb_gsl_block,where2), 0); rb_define_method(GSL_TYPE(cgsl_block), "each", FUNCTION(rb_gsl_block,each), 0); rb_define_method(GSL_TYPE(cgsl_block), "each_index", FUNCTION(rb_gsl_block,each_index), 0); rb_define_method(GSL_TYPE(cgsl_block), "collect", FUNCTION(rb_gsl_block,collect), 0); rb_define_method(GSL_TYPE(cgsl_block), "collect!", FUNCTION(rb_gsl_block,collect_bang), 0); rb_define_alias(GSL_TYPE(cgsl_block), "map", "collect"); rb_define_alias(GSL_TYPE(cgsl_block), "map!", "collect!"); } gsl-1.15.3/ext/sf_elljac.c0000644000175000017500000000176512220252463014641 0ustar boutilboutil/* sf_elljac.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_elljac_e(VALUE obj, VALUE n, VALUE m) { double sn, cn, dn; // local variable "status" declared and set, but never used //int status; Need_Float(n); Need_Float(m); /*status =*/ gsl_sf_elljac_e(NUM2DBL(n), NUM2DBL(m), &sn, &cn, &dn); return rb_ary_new3(3, rb_float_new(sn), rb_float_new(cn), rb_float_new(dn)); } void Init_gsl_sf_elljac(VALUE module) { rb_define_module_function(module, "elljac_e", rb_gsl_sf_elljac_e, 2); rb_define_module_function(module, "elljac", rb_gsl_sf_elljac_e, 2); } gsl-1.15.3/ext/siman.c0000644000175000017500000005160612220252463014025 0ustar boutilboutil/* siman.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include #include #include "rb_gsl.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #include "rb_gsl_rng.h" #include "rb_gsl_common.h" static VALUE cgsl_siman_Efunc; static VALUE cgsl_siman_step; static VALUE cgsl_siman_metric; static VALUE cgsl_siman_print; static VALUE cgsl_siman_solver; static VALUE cgsl_siman_params; /***** siman_solver *****/ typedef struct __siman_solver { VALUE proc_efunc; VALUE proc_step; VALUE proc_metric; VALUE proc_print; gsl_vector *vx; } siman_solver; static siman_solver* gsl_siman_solver_alloc(size_t size); static void gsl_siman_solver_free(siman_solver *ss); static void gsl_siman_solver_mark(siman_solver *s); static void gsl_siman_solver_mark(siman_solver *s) { rb_gc_mark(s->proc_efunc); rb_gc_mark(s->proc_step); rb_gc_mark(s->proc_metric); rb_gc_mark(s->proc_print); } static siman_solver* gsl_siman_solver_alloc(size_t size) { siman_solver *ss = NULL; ss = ALLOC(siman_solver); if (size > 0) { ss->vx = gsl_vector_alloc(size); } else { ss->vx = NULL; } return ss; } static void gsl_siman_solver_free(siman_solver *ss) { if (ss->vx) gsl_vector_free(ss->vx); free((siman_solver *) ss); } static VALUE rb_gsl_siman_solver_new(int argc, VALUE *argv, VALUE klass) { siman_solver *ss = NULL; if (argc == 1) ss = gsl_siman_solver_alloc(FIX2INT(argv[0])); else ss = gsl_siman_solver_alloc(0); return Data_Wrap_Struct(klass, gsl_siman_solver_mark, gsl_siman_solver_free, ss); } /***** siman_Efunc *****/ typedef struct ___siman_Efunc { double (*siman_Efunc_t)(void *); VALUE proc; } siman_Efunc; static siman_Efunc* siman_Efunc_alloc(); static void siman_Efunc_free(siman_Efunc *se); static double rb_gsl_siman_Efunc_t(void *xp); static VALUE rb_gsl_siman_Efunc_set(int argc, VALUE *argv, VALUE obj); static void siman_Efunc_mark(siman_Efunc *se); static siman_Efunc* siman_Efunc_alloc() { siman_Efunc *se = NULL; se = ALLOC(siman_Efunc); se->siman_Efunc_t = rb_gsl_siman_Efunc_t; return se; } static void siman_Efunc_mark(siman_Efunc *se) { rb_gc_mark(se->proc); } static void siman_Efunc_free(siman_Efunc *se) { free((siman_Efunc *) se); } static VALUE rb_gsl_siman_Efunc_new(int argc, VALUE *argv, VALUE klass) { VALUE obj; siman_Efunc *se = NULL; se = siman_Efunc_alloc(); obj = Data_Wrap_Struct(klass, siman_Efunc_mark, siman_Efunc_free, se); rb_gsl_siman_Efunc_set(argc, argv, obj); return obj; } static double rb_gsl_siman_Efunc_t(void *data) { VALUE proc, params, result; siman_solver *ss = NULL; ss = (siman_solver *) data; proc = (VALUE) ss->proc_efunc; params = Data_Wrap_Struct(cgsl_vector, 0, NULL, ss->vx); result = rb_funcall(proc, RBGSL_ID_call, 1, params); return NUM2DBL(result); } static VALUE rb_gsl_siman_Efunc_set(int argc, VALUE *argv, VALUE obj) { siman_Efunc *se = NULL; Data_Get_Struct(obj, siman_Efunc, se); switch (argc) { case 0: if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC; break; case 1: if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0]; else rb_raise(rb_eTypeError, "Proc expected"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); } return obj; } /***** siman_copy *****/ static void rb_gsl_siman_copy_t(void *source, void *dest); static void* rb_gsl_siman_copy_construct_t(void *data); static void rb_gsl_siman_destroy_t(void *data); static void rb_gsl_siman_copy_t(void *source, void *dest) { siman_solver *sssrc = NULL, *ssdest = NULL; sssrc = (siman_solver *) source; ssdest = (siman_solver *) dest; gsl_vector_memcpy(ssdest->vx, sssrc->vx); } /***** siman_copy_construct *****/ static void* rb_gsl_siman_copy_construct_t(void *data) { siman_solver *ssdest = NULL; siman_solver *sssrc = NULL; sssrc = (siman_solver *) data; ssdest = (siman_solver *) gsl_siman_solver_alloc(sssrc->vx->size); ssdest->proc_efunc = sssrc->proc_efunc; ssdest->proc_step = sssrc->proc_step; ssdest->proc_metric = sssrc->proc_metric; ssdest->proc_print = sssrc->proc_print; gsl_vector_memcpy(ssdest->vx, sssrc->vx); return ssdest; } /***** siman_destroy *****/ static void rb_gsl_siman_destroy_t(void *data) { siman_solver *ss = NULL; ss = (siman_solver *) data; gsl_siman_solver_free(ss); } /****** siman_print *****/ typedef struct ___siman_print { void (*siman_print_t)(void *); VALUE proc; } siman_print; static siman_print* siman_print_alloc(); static void siman_print_free(siman_print *se); static void rb_gsl_siman_print_t(void *xp); static VALUE rb_gsl_siman_print_set(int argc, VALUE *argv, VALUE obj); static void siman_print_mark(siman_print *se); static siman_print* siman_print_alloc() { siman_print *se = NULL; se = ALLOC(siman_print); se->siman_print_t = &rb_gsl_siman_print_t; return se; } static void siman_print_mark(siman_print *se) { rb_gc_mark(se->proc); } static void siman_print_free(siman_print *se) { free((siman_print *) se); } static VALUE rb_gsl_siman_print_new(int argc, VALUE *argv, VALUE klass) { VALUE obj; siman_print *se = NULL; se = siman_print_alloc(); obj = Data_Wrap_Struct(klass, siman_print_mark, siman_print_free, se); rb_gsl_siman_print_set(argc, argv, obj); return obj; } static void rb_gsl_siman_print_t(void *data) { VALUE proc, params; siman_solver *ss = NULL; ss = (siman_solver *) data; proc = ss->proc_print; if (NIL_P(proc)) return; params = Data_Wrap_Struct(cgsl_vector, 0, NULL, ss->vx); rb_funcall(proc, RBGSL_ID_call, 1, params); } static VALUE rb_gsl_siman_print_set(int argc, VALUE *argv, VALUE obj) { siman_print *se = NULL; Data_Get_Struct(obj, siman_print, se); switch (argc) { case 0: if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC; break; case 1: if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); } return obj; } /***** siman_step *****/ typedef struct ___siman_step { void (*siman_step_t)(const gsl_rng *r, void *xp, double step_size); VALUE proc; } siman_step; static siman_step* siman_step_alloc(); static void siman_step_free(siman_step *se); static void rb_gsl_siman_step_t(const gsl_rng *r, void *xp, double step_size); static VALUE rb_gsl_siman_step_set(int argc, VALUE *argv, VALUE obj); static void siman_step_mark(siman_step *se); static siman_step* siman_step_alloc() { siman_step *se = NULL; se = ALLOC(siman_step); se->siman_step_t = rb_gsl_siman_step_t; return se; } static void siman_step_mark(siman_step *se) { rb_gc_mark(se->proc); } static void siman_step_free(siman_step *se) { free((siman_step *) se); } static VALUE rb_gsl_siman_step_new(int argc, VALUE *argv, VALUE klass) { VALUE obj; siman_step *se = NULL; se = siman_step_alloc(); obj = Data_Wrap_Struct(klass, siman_step_mark, siman_step_free, se); rb_gsl_siman_step_set(argc, argv, obj); return obj; } static void rb_gsl_siman_step_t(const gsl_rng *r, void *data, double step_size) { VALUE proc, params; VALUE rng; siman_solver *ss = NULL; ss = (siman_solver *) data; proc = (VALUE) ss->proc_step; rng = Data_Wrap_Struct(cgsl_rng, 0, NULL, (gsl_rng *) r); params = Data_Wrap_Struct(cgsl_vector, 0, NULL, ss->vx); rb_funcall(proc, RBGSL_ID_call, 3, rng, params, rb_float_new(step_size)); } static VALUE rb_gsl_siman_step_set(int argc, VALUE *argv, VALUE obj) { siman_step *se = NULL; Data_Get_Struct(obj, siman_step, se); switch (argc) { case 0: if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC; break; case 1: if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); } return obj; } /***** siman_metric *****/ typedef struct ___siman_metric { double (*siman_metric_t)(void *, void *); VALUE proc; } siman_metric; static siman_metric* siman_metric_alloc(); static void siman_metric_free(siman_metric *se); static double rb_gsl_siman_metric_t(void *xp, void *yp); static VALUE rb_gsl_siman_metric_set(int argc, VALUE *argv, VALUE obj); static void siman_metric_mark(siman_metric *se); static siman_metric* siman_metric_alloc() { siman_metric *se = NULL; se = ALLOC(siman_metric); if (se == NULL) rb_raise(rb_eRuntimeError, "ALLOC failed"); se->siman_metric_t = &rb_gsl_siman_metric_t; return se; } static void siman_metric_mark(siman_metric *se) { rb_gc_mark(se->proc); } static void siman_metric_free(siman_metric *se) { free((siman_metric *) se); } static VALUE rb_gsl_siman_metric_new(int argc, VALUE *argv, VALUE klass) { VALUE obj; siman_metric *se = NULL; se = siman_metric_alloc(); obj = Data_Wrap_Struct(klass, siman_metric_mark, siman_metric_free, se); rb_gsl_siman_metric_set(argc, argv, obj); return obj; } static double rb_gsl_siman_metric_t(void *data, void *yp) { VALUE proc, vxp, vyp, result; siman_solver *ss = NULL, *ssy = NULL; ss = (siman_solver *) data; ssy = (siman_solver *) yp; proc = ss->proc_metric; vxp = Data_Wrap_Struct(cgsl_vector, 0, NULL, ss->vx); vyp = Data_Wrap_Struct(cgsl_vector, 0, NULL, ssy->vx); result = rb_funcall(proc, RBGSL_ID_call, 2, vxp, vyp); return NUM2DBL(result); } static VALUE rb_gsl_siman_metric_set(int argc, VALUE *argv, VALUE obj) { siman_metric *se = NULL; Data_Get_Struct(obj, siman_metric, se); switch (argc) { case 0: if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC; break; case 1: if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); } return obj; } /***** siman_params_t *****/ static gsl_siman_params_t* gsl_siman_params_alloc(); static void gsl_siman_params_free(gsl_siman_params_t *params); static gsl_siman_params_t* gsl_siman_params_alloc() { gsl_siman_params_t *params = NULL; params = ALLOC(gsl_siman_params_t); return params; } static void gsl_siman_params_free(gsl_siman_params_t *params) { free((gsl_siman_params_t *) params); } static VALUE rb_gsl_siman_params_set(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_siman_params_new(int argc, VALUE *argv, VALUE klass) { gsl_siman_params_t *params = NULL; VALUE obj; params = gsl_siman_params_alloc(); obj = Data_Wrap_Struct(klass, 0, gsl_siman_params_free, params); rb_gsl_siman_params_set(argc, argv, obj); return obj; } static VALUE rb_gsl_siman_params_set(int argc, VALUE *argv, VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); switch (argc) { case 7: params->t_min = NUM2DBL(argv[6]); /* no break */ case 6: params->mu_t = NUM2DBL(argv[5]); /* no break */ case 5: params->t_initial = NUM2DBL(argv[4]); /* no break */ case 4: params->k = NUM2DBL(argv[3]); /* no break */ case 3: params->step_size = NUM2DBL(argv[2]); /* no break */ case 2: params->iters_fixed_T = NUM2INT(argv[1]); /* no break */ case 1: params->n_tries = NUM2INT(argv[0]); } return obj; } static VALUE rb_gsl_siman_params_n_tries(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return INT2FIX(params->n_tries); } static VALUE rb_gsl_siman_params_set_n_tries(VALUE obj, VALUE n) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); params->n_tries = NUM2INT(n); return obj; } static VALUE rb_gsl_siman_params_iters_fixed_T(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return INT2FIX(params->iters_fixed_T); } static VALUE rb_gsl_siman_params_set_iters_fixed_T(VALUE obj, VALUE n) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); params->iters_fixed_T = NUM2INT(n); return obj; } static VALUE rb_gsl_siman_params_step_size(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return rb_float_new(params->step_size); } static VALUE rb_gsl_siman_params_set_step_size(VALUE obj, VALUE s) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); params->step_size = NUM2DBL(s); return obj; } static VALUE rb_gsl_siman_params_k(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return rb_float_new(params->k); } static VALUE rb_gsl_siman_params_set_k(VALUE obj, VALUE s) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); params->k = NUM2DBL(s); return obj; } static VALUE rb_gsl_siman_params_t_initial(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return rb_float_new(params->t_initial); } static VALUE rb_gsl_siman_params_set_t_initial(VALUE obj, VALUE s) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); params->t_initial = NUM2DBL(s); return obj; } static VALUE rb_gsl_siman_params_mu_t(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return rb_float_new(params->mu_t); } static VALUE rb_gsl_siman_params_set_mu_t(VALUE obj, VALUE s) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); params->mu_t = NUM2DBL(s); return obj; } static VALUE rb_gsl_siman_params_t_min(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return rb_float_new(params->t_min); } static VALUE rb_gsl_siman_params_set_t_min(VALUE obj, VALUE s) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); params->t_min = NUM2DBL(s); return obj; } static VALUE rb_gsl_siman_params_params(VALUE obj) { gsl_siman_params_t *params = NULL; Data_Get_Struct(obj, gsl_siman_params_t, params); return rb_ary_new3(7, INT2FIX(params->n_tries), INT2FIX(params->iters_fixed_T), rb_float_new(params->step_size), rb_float_new(params->k), rb_float_new(params->t_initial), rb_float_new(params->mu_t), rb_float_new(params->t_min)); } /***** solver *****/ static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng, VALUE vx0p, VALUE vefunc, VALUE vstep, VALUE vmetric, VALUE vprint, VALUE vparams) { gsl_rng *r = NULL; siman_solver *ss = NULL; siman_Efunc *efunc = NULL; siman_step *step = NULL; siman_metric *metric = NULL; siman_print *print = NULL; gsl_vector *vtmp = NULL; gsl_siman_params_t *params = NULL; int flag = 0; /* Data_Get_Struct(obj, siman_solver, ss);*/ CHECK_VECTOR(vx0p); Data_Get_Struct(vx0p, gsl_vector, vtmp); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: ss = gsl_siman_solver_alloc(vtmp->size); flag = 1; break; default: Data_Get_Struct(obj, siman_solver, ss); } if (!rb_obj_is_kind_of(rng, cgsl_rng)) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Rng expected)", rb_class2name(CLASS_OF(rng))); if (!rb_obj_is_kind_of(vefunc, cgsl_siman_Efunc)) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Efunc expected)", rb_class2name(CLASS_OF(vefunc))); if (!rb_obj_is_kind_of(vstep, cgsl_siman_step)) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Step expected)", rb_class2name(CLASS_OF(vstep))); if (!rb_obj_is_kind_of(vmetric, cgsl_siman_metric)) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Metric expected)", rb_class2name(CLASS_OF(vmetric))); Data_Get_Struct(rng, gsl_rng, r); Data_Get_Struct(vefunc, siman_Efunc, efunc); Data_Get_Struct(vstep, siman_step, step); Data_Get_Struct(vmetric, siman_metric, metric); if (NIL_P(vprint)) { ss->proc_print = Qnil; } else { if (!rb_obj_is_kind_of(vprint, cgsl_siman_print)) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Print expected)", rb_class2name(CLASS_OF(vprint))); Data_Get_Struct(vprint, siman_print, print); ss->proc_print = print->proc; } if (!rb_obj_is_kind_of(vparams, cgsl_siman_params)) rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Params expected)", rb_class2name(CLASS_OF(vparams))); Data_Get_Struct(vparams, gsl_siman_params_t, params); ss->proc_efunc = efunc->proc; ss->proc_step = step->proc; ss->proc_metric = metric->proc; gsl_vector_memcpy(ss->vx, vtmp); if (NIL_P(vprint)) { gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t, rb_gsl_siman_step_t, rb_gsl_siman_metric_t, NULL, rb_gsl_siman_copy_t, rb_gsl_siman_copy_construct_t, rb_gsl_siman_destroy_t, 0, *params); } else { gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t, rb_gsl_siman_step_t, rb_gsl_siman_metric_t, rb_gsl_siman_print_t, rb_gsl_siman_copy_t, rb_gsl_siman_copy_construct_t, rb_gsl_siman_destroy_t, 0, *params); } gsl_vector_memcpy(vtmp, ss->vx); if (flag == 1) gsl_siman_solver_free(ss); return obj; } void Init_gsl_siman(VALUE module) { VALUE mgsl_siman; mgsl_siman = rb_define_module_under(module, "Siman"); cgsl_siman_Efunc = rb_define_class_under(mgsl_siman, "Efunc", cGSL_Object); cgsl_siman_step = rb_define_class_under(mgsl_siman, "Step", cGSL_Object); cgsl_siman_metric = rb_define_class_under(mgsl_siman, "Metric", cGSL_Object); cgsl_siman_print = rb_define_class_under(mgsl_siman, "Print", cGSL_Object); cgsl_siman_params = rb_define_class_under(mgsl_siman, "Params", cGSL_Object); cgsl_siman_solver = rb_define_class_under(mgsl_siman, "Solver", cGSL_Object); /***** Efunc *****/ rb_define_singleton_method(cgsl_siman_Efunc, "alloc", rb_gsl_siman_Efunc_new, -1); rb_define_method(cgsl_siman_Efunc, "set", rb_gsl_siman_Efunc_set, -1); rb_define_alias(cgsl_siman_Efunc, "set_proc", "set"); /***** Print *****/ rb_define_singleton_method(cgsl_siman_print, "alloc", rb_gsl_siman_print_new, -1); rb_define_method(cgsl_siman_print, "set", rb_gsl_siman_print_set, -1); rb_define_alias(cgsl_siman_print, "set_proc", "set"); rb_define_singleton_method(cgsl_siman_step, "alloc", rb_gsl_siman_step_new, -1); rb_define_method(cgsl_siman_step, "set", rb_gsl_siman_step_set, -1); rb_define_alias(cgsl_siman_step, "set_proc", "set"); rb_define_singleton_method(cgsl_siman_metric, "alloc", rb_gsl_siman_metric_new, -1); rb_define_method(cgsl_siman_metric, "set", rb_gsl_siman_metric_set, -1); rb_define_alias(cgsl_siman_metric, "set_proc", "set"); /***** params *****/ rb_define_singleton_method(cgsl_siman_params, "alloc", rb_gsl_siman_params_new, -1); rb_define_method(cgsl_siman_params, "set", rb_gsl_siman_params_set, -1); rb_define_method(cgsl_siman_params, "params", rb_gsl_siman_params_params, 0); rb_define_method(cgsl_siman_params, "n_tries", rb_gsl_siman_params_n_tries, 0); rb_define_method(cgsl_siman_params, "set_n_tries", rb_gsl_siman_params_set_n_tries, 1); rb_define_alias(cgsl_siman_params, "n_tries=", "set_n_tries"); rb_define_method(cgsl_siman_params, "iters_fixed_T", rb_gsl_siman_params_iters_fixed_T, 0); rb_define_method(cgsl_siman_params, "set_iters_fixed_T", rb_gsl_siman_params_set_iters_fixed_T, 1); rb_define_alias(cgsl_siman_params, "iters_fixed_T=", "set_iters_fixed_T"); rb_define_method(cgsl_siman_params, "step_size", rb_gsl_siman_params_step_size, 0); rb_define_method(cgsl_siman_params, "set_step_size", rb_gsl_siman_params_set_step_size, 1); rb_define_alias(cgsl_siman_params, "step_size=", "set_step_size"); rb_define_method(cgsl_siman_params, "k", rb_gsl_siman_params_k, 0); rb_define_method(cgsl_siman_params, "set_k", rb_gsl_siman_params_set_k, 1); rb_define_alias(cgsl_siman_params, "k=", "set_k"); rb_define_method(cgsl_siman_params, "t_initial", rb_gsl_siman_params_t_initial, 0); rb_define_method(cgsl_siman_params, "set_t_initial", rb_gsl_siman_params_set_t_initial, 1); rb_define_alias(cgsl_siman_params, "t_initial=", "set_t_initial"); rb_define_method(cgsl_siman_params, "mu_t", rb_gsl_siman_params_mu_t, 0); rb_define_method(cgsl_siman_params, "set_mu_t", rb_gsl_siman_params_set_mu_t, 1); rb_define_alias(cgsl_siman_params, "mu_t=", "set_mu_t"); rb_define_method(cgsl_siman_params, "t_min", rb_gsl_siman_params_t_min, 0); rb_define_method(cgsl_siman_params, "set_t_min", rb_gsl_siman_params_set_t_min, 1); rb_define_alias(cgsl_siman_params, "t_min=", "set_t_min"); /***** solver *****/ rb_define_singleton_method(cgsl_siman_solver, "alloc", rb_gsl_siman_solver_new, -1); rb_define_method(cgsl_siman_solver, "solve", rb_gsl_siman_solver_solve, 7); rb_define_singleton_method(cgsl_siman_solver, "solve", rb_gsl_siman_solver_solve, 7); rb_define_singleton_method(mgsl_siman, "solve", rb_gsl_siman_solver_solve, 7); } gsl-1.15.3/ext/histogram2d.c0000644000175000017500000010264312220252463015137 0ustar boutilboutil/* histogram2d.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_histogram.h" #include "rb_gsl_common.h" #include "rb_gsl_array.h" VALUE cgsl_histogram2d; VALUE cgsl_histogram2d_view; static VALUE cgsl_histogram2d_integ; #ifdef GSL_0_9_4_LATER static VALUE rb_gsl_histogram2d_alloc_uniform(int argc, VALUE *argv, VALUE klass); static VALUE rb_gsl_histogram2d_alloc(int argc, VALUE *argv, VALUE klass) { gsl_histogram2d *h = NULL; size_t xsize, ysize; gsl_vector *vx, *vy; switch (argc) { case 2: switch (TYPE(argv[0])) { case T_FIXNUM: CHECK_FIXNUM(argv[1]); h = gsl_histogram2d_calloc(FIX2INT(argv[0]), FIX2INT(argv[1])); break; case T_ARRAY: vx = make_cvector_from_rarray(argv[0]); vy = make_cvector_from_rarray(argv[1]); h = gsl_histogram2d_alloc(vx->size-1, vy->size-1); gsl_histogram2d_set_ranges(h, vx->data, vx->size, vy->data, vy->size); gsl_vector_free(vx); gsl_vector_free(vy); break; default: CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_vector, vx); Data_Get_Struct(argv[1], gsl_vector, vy); h = gsl_histogram2d_alloc(vx->size-1, vy->size-1); gsl_histogram2d_set_ranges(h, vx->data, vx->size, vy->data, vy->size); break; } return Data_Wrap_Struct(klass, 0, gsl_histogram2d_free, h); break; case 4: if (VECTOR_P(argv[0]) && VECTOR_P(argv[2])) { CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[3]); Data_Get_Struct(argv[0], gsl_vector, vx); Data_Get_Struct(argv[2], gsl_vector, vy); xsize = (size_t) FIX2UINT(argv[1]); ysize = (size_t) FIX2UINT(argv[3]); h = gsl_histogram2d_alloc(xsize-1, ysize-1); gsl_histogram2d_set_ranges(h, vx->data, xsize, vy->data, ysize); return Data_Wrap_Struct(klass, 0, gsl_histogram2d_free, h); } else { return rb_gsl_histogram2d_alloc_uniform(argc, argv, klass); } break; case 6: return rb_gsl_histogram2d_alloc_uniform(argc, argv, klass); break; default: rb_raise(rb_eArgError, "wrong number of arguments %d", argc); break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_histogram2d_alloc_uniform(int argc, VALUE *argv, VALUE klass) { gsl_histogram2d *h = NULL; double xmin, xmax, ymin, ymax; switch (argc) { case 4: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[2]); Check_Type(argv[1], T_ARRAY); Check_Type(argv[3], T_ARRAY); // if (RARRAY(argv[1])->len != 2 || RARRAY(argv[3])->len != 2) if (RARRAY_LEN(argv[1]) != 2 || RARRAY_LEN(argv[3]) != 2) rb_raise(rb_eArgError, "array size must be 2"); xmin = NUM2DBL(rb_ary_entry(argv[1], 0)); xmax = NUM2DBL(rb_ary_entry(argv[1], 1)); ymin = NUM2DBL(rb_ary_entry(argv[3], 0)); ymax = NUM2DBL(rb_ary_entry(argv[3], 1)); h = gsl_histogram2d_alloc(FIX2INT(argv[0]), FIX2INT(argv[2])); gsl_histogram2d_set_ranges_uniform(h, xmin, xmax, ymin, ymax); return Data_Wrap_Struct(klass, 0, gsl_histogram2d_free, h); break; case 6: CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); CHECK_FIXNUM(argv[3]); Need_Float(argv[4]); Need_Float(argv[5]); h = gsl_histogram2d_alloc(FIX2INT(argv[0]), FIX2INT(argv[3])); gsl_histogram2d_set_ranges_uniform(h, NUM2DBL(argv[1]), NUM2DBL(argv[2]), NUM2DBL(argv[4]), NUM2DBL(argv[5])); return Data_Wrap_Struct(klass, 0, gsl_histogram2d_free, h); break; default: rb_raise(rb_eArgError, "wrong number of arguments %d", argc); break; } return Qnil; /* never reach here */ } #endif static VALUE rb_gsl_histogram2d_set_ranges(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h = NULL; gsl_vector *vx, *vy; size_t xsize, ysize; Data_Get_Struct(obj, gsl_histogram2d, h); switch (argc) { case 4: CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[2]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[3]); Data_Get_Struct(argv[0], gsl_vector, vx); Data_Get_Struct(argv[2], gsl_vector, vy); xsize = (size_t) FIX2UINT(argv[1]); ysize = (size_t) FIX2UINT(argv[3]); break; case 2: CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_vector, vx); Data_Get_Struct(argv[1], gsl_vector, vy); xsize = vx->size; ysize = vy->size; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 4)", argc); } gsl_histogram2d_set_ranges(h, vx->data, xsize, vy->data, ysize); return obj; } static VALUE rb_gsl_histogram2d_set_ranges_uniform(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h = NULL; double xmin, xmax, ymin, ymax; switch (argc) { case 2: Check_Type(argv[0], T_ARRAY); Check_Type(argv[1], T_ARRAY); xmin = NUM2DBL(rb_ary_entry(argv[0], 0)); xmax = NUM2DBL(rb_ary_entry(argv[0], 1)); ymin = NUM2DBL(rb_ary_entry(argv[1], 0)); ymax = NUM2DBL(rb_ary_entry(argv[1], 1)); break; case 4: xmin = NUM2DBL(argv[0]); xmax = NUM2DBL(argv[1]); ymin = NUM2DBL(argv[2]); ymax = NUM2DBL(argv[3]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 4)", argc); break; } Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_set_ranges_uniform(h, xmin, xmax, ymin, ymax); return obj; } static VALUE rb_gsl_histogram2d_clone(VALUE obj) { gsl_histogram2d *h, *h2 = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); h2 = gsl_histogram2d_clone(h); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram2d_free, h2); } /* singleton */ static VALUE rb_gsl_histogram2d_memcpy(VALUE obj, VALUE vhdest, VALUE vhsrc) { gsl_histogram2d *hdest, *hsrc; CHECK_HISTOGRAM2D(vhdest); CHECK_HISTOGRAM2D(vhsrc); Data_Get_Struct(vhdest, gsl_histogram2d, hdest); Data_Get_Struct(vhsrc, gsl_histogram2d, hsrc); gsl_histogram2d_memcpy(hdest, hsrc); return vhdest; } static VALUE rb_gsl_histogram2d_accumulate(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h = NULL; gsl_vector *vx, *vy; size_t n, i; double weight = 1; switch (argc) { case 3: Need_Float(argv[2]); weight = NUM2DBL(argv[2]); break; case 2: weight = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } Data_Get_Struct(obj, gsl_histogram2d, h); if (VECTOR_P(argv[0]) && VECTOR_P(argv[1])) { Data_Get_Struct(argv[0], gsl_vector, vx); Data_Get_Struct(argv[1], gsl_vector, vy); n = (size_t) GSL_MIN_INT((int) vx->size, (int) vy->size); for (i = 0; i < n; i++) gsl_histogram2d_accumulate(h, gsl_vector_get(vx, i), gsl_vector_get(vy, i), weight); } else { gsl_histogram2d_accumulate(h, NUM2DBL(argv[0]), NUM2DBL(argv[1]), weight); } return obj; } static VALUE rb_gsl_histogram2d_accumulate2(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h = NULL; double x, y, weight=1; switch (argc) { case 3: Need_Float(argv[2]); weight = NUM2DBL(argv[2]); /* no break */ case 2: Need_Float(argv[0]); Need_Float(argv[1]); x = NUM2DBL(argv[0]); y = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } Data_Get_Struct(obj, gsl_histogram2d, h); if (x < h->xrange[0]) x = h->xrange[0] + 4*GSL_DBL_EPSILON; if (x > h->xrange[h->nx]) x = h->xrange[h->nx] - 4*GSL_DBL_EPSILON; if (y < h->yrange[0]) y = h->yrange[0] + 4*GSL_DBL_EPSILON; if (y > h->yrange[h->ny]) y = h->yrange[h->ny] - 4*GSL_DBL_EPSILON; gsl_histogram2d_accumulate(h, x, y, weight); return obj; } static VALUE rb_gsl_histogram2d_get(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h2 = NULL; mygsl_histogram2d_view *h1 = NULL; size_t i; switch (argc) { case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); Data_Get_Struct(obj, gsl_histogram2d, h2); return rb_float_new(gsl_histogram2d_get(h2, (size_t) FIX2INT(argv[0]), (size_t) FIX2INT(argv[1]))); break; case 1: Data_Get_Struct(obj, gsl_histogram2d, h2); switch (TYPE(argv[0])) { case T_ARRAY: return rb_float_new(gsl_histogram2d_get(h2, FIX2INT(rb_ary_entry(argv[0], 0)), FIX2INT(rb_ary_entry(argv[0], 1)))); break; case T_FIXNUM: CHECK_FIXNUM(argv[0]); i = (size_t) FIX2INT(argv[0]); if (i >= h2->ny) rb_raise(rb_eIndexError, "wrong index"); h1 = ALLOC(mygsl_histogram2d_view); h1->h.n = h2->ny; h1->h.range = h2->yrange; h1->h.bin = h2->bin + i*h2->ny; return Data_Wrap_Struct(cgsl_histogram2d_view, 0, free, h1); break; default: rb_raise(rb_eTypeError, "wrong argument type %s (Array or Fixnum expected)", rb_class2name(CLASS_OF(argv[0]))); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 1)",argc); break; } } static VALUE rb_gsl_histogram2d_get_xrange(VALUE obj, VALUE i) { gsl_histogram2d *h = NULL; double x1, x2; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_get_xrange(h, FIX2INT(i), &x1, &x2); return rb_ary_new3(2, rb_float_new(x1), rb_float_new(x2)); } static VALUE rb_gsl_histogram2d_get_yrange(VALUE obj, VALUE j) { gsl_histogram2d *h = NULL; double y1, y2; CHECK_FIXNUM(j); Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_get_yrange(h, FIX2INT(j), &y1, &y2); return rb_ary_new3(2, rb_float_new(y1), rb_float_new(y2)); } static VALUE rb_gsl_histogram2d_xmax(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_xmax(h)); } static VALUE rb_gsl_histogram2d_xmin(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_xmin(h)); } static VALUE rb_gsl_histogram2d_nx(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return INT2FIX(gsl_histogram2d_nx(h)); } static VALUE rb_gsl_histogram2d_ymax(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_ymax(h)); } static VALUE rb_gsl_histogram2d_ymin(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_ymin(h)); } static VALUE rb_gsl_histogram2d_ny(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return INT2FIX(gsl_histogram2d_ny(h)); } static VALUE rb_gsl_histogram2d_find(VALUE obj, VALUE x, VALUE y) { gsl_histogram2d *h = NULL; size_t i, j; Need_Float(x);Need_Float(y); Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_find(h, NUM2DBL(x), NUM2DBL(y), &i, &j); return rb_ary_new3(2, INT2FIX(i), INT2FIX(j)); } static VALUE rb_gsl_histogram2d_max_val(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_max_val(h)); } static VALUE rb_gsl_histogram2d_max_bin(VALUE obj) { gsl_histogram2d *h = NULL; size_t i, j; Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_max_bin(h, &i, &j); return rb_ary_new3(2, INT2FIX(i), INT2FIX(j)); } static VALUE rb_gsl_histogram2d_min_val(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_min_val(h)); } static VALUE rb_gsl_histogram2d_min_bin(VALUE obj) { gsl_histogram2d *h = NULL; size_t i, j; Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_min_bin(h, &i, &j); return rb_ary_new3(2, INT2FIX(i), INT2FIX(j)); } #ifdef GSL_1_1_LATER static VALUE rb_gsl_histogram2d_xmean(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_xmean(h)); } static VALUE rb_gsl_histogram2d_ymean(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_ymean(h)); } static VALUE rb_gsl_histogram2d_xsigma(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_xsigma(h)); } static VALUE rb_gsl_histogram2d_ysigma(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_ysigma(h)); } static VALUE rb_gsl_histogram2d_cov(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_cov(h)); } static VALUE rb_gsl_histogram2d_sum(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); return rb_float_new(gsl_histogram2d_sum(h)); } #endif /* singleton */ static VALUE rb_gsl_histogram2d_equal_bins_p(VALUE obj, VALUE hh1, VALUE hh2) { gsl_histogram2d *h1 = NULL, *h2 = NULL; CHECK_HISTOGRAM2D(hh1); CHECK_HISTOGRAM2D(hh2); Data_Get_Struct(hh1, gsl_histogram2d, h1); Data_Get_Struct(hh2, gsl_histogram2d, h2); return INT2FIX(gsl_histogram2d_equal_bins_p(h1, h2)); } static VALUE rb_gsl_histogram2d_equal_bins_p2(VALUE obj, VALUE hh1, VALUE hh2) { gsl_histogram2d *h1 = NULL, *h2 = NULL; CHECK_HISTOGRAM2D(hh1); CHECK_HISTOGRAM2D(hh2); Data_Get_Struct(hh1, gsl_histogram2d, h1); Data_Get_Struct(hh2, gsl_histogram2d, h2); if (gsl_histogram2d_equal_bins_p(h1, h2)) return Qtrue; else return Qfalse; } static VALUE rb_gsl_histogram2d_scale(VALUE obj, VALUE s) { gsl_histogram2d *h = NULL; Need_Float(s); Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_scale(h, NUM2DBL(s)); return obj; } static VALUE rb_gsl_histogram2d_shift(VALUE obj, VALUE s) { gsl_histogram2d *h = NULL; Need_Float(s); Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_shift(h, NUM2DBL(s)); return obj; } /*****/ static VALUE rb_gsl_histogram2d_add(VALUE obj, VALUE hh2) { gsl_histogram2d *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram2d, h1); hnew = gsl_histogram2d_clone(h1); if (HISTOGRAM2D_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram2d, h2); gsl_histogram2d_add(hnew, h2); } else { Need_Float(hh2); gsl_histogram2d_shift(hnew, NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(h1), 0, gsl_histogram2d_free, hnew); } static VALUE rb_gsl_histogram2d_sub(VALUE obj, VALUE hh2) { gsl_histogram2d *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram2d, h1); hnew = gsl_histogram2d_clone(h1); if (HISTOGRAM2D_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram2d, h2); gsl_histogram2d_sub(hnew, h2); } else { Need_Float(hh2); gsl_histogram2d_shift(hnew, -NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(h1), 0, gsl_histogram2d_free, hnew); } static VALUE rb_gsl_histogram2d_mul(VALUE obj, VALUE hh2) { gsl_histogram2d *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram2d, h1); hnew = gsl_histogram2d_clone(h1); if (HISTOGRAM2D_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram2d, h2); gsl_histogram2d_mul(hnew, h2); } else { Need_Float(hh2); gsl_histogram2d_scale(hnew, NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(h1), 0, gsl_histogram2d_free, hnew); } static VALUE rb_gsl_histogram2d_div(VALUE obj, VALUE hh2) { gsl_histogram2d *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram2d, h1); hnew = gsl_histogram2d_clone(h1); if (HISTOGRAM2D_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram2d, h2); gsl_histogram2d_div(hnew, h2); } else { Need_Float(hh2); gsl_histogram2d_scale(hnew, 1.0/NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(h1), 0, gsl_histogram2d_free, hnew); } static VALUE rb_gsl_histogram2d_scale2(VALUE obj, VALUE val) { gsl_histogram2d *h1 = NULL, *hnew = NULL; Need_Float(val); Data_Get_Struct(obj, gsl_histogram2d, h1); hnew = gsl_histogram2d_clone(h1); gsl_histogram2d_scale(hnew, NUM2DBL(val)); return Data_Wrap_Struct(CLASS_OF(h1), 0, gsl_histogram2d_free, hnew); } static VALUE rb_gsl_histogram2d_shift2(VALUE obj, VALUE val) { gsl_histogram2d *h1 = NULL, *hnew = NULL; Need_Float(val); Data_Get_Struct(obj, gsl_histogram2d, h1); hnew = gsl_histogram2d_clone(h1); gsl_histogram2d_shift(hnew, NUM2DBL(val)); return Data_Wrap_Struct(CLASS_OF(h1), 0, gsl_histogram2d_free, hnew); } static VALUE rb_gsl_histogram2d_fwrite(VALUE obj, VALUE io) { gsl_histogram2d *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram2d, h); f = rb_gsl_open_writefile(io, &flag); status = gsl_histogram2d_fwrite(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram2d_fread(VALUE obj, VALUE io) { gsl_histogram2d *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram2d, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_histogram2d_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram2d_fprintf(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h = NULL; FILE *fp; int status, flag = 0; if (argc != 1 && argc != 3) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc); } Data_Get_Struct(obj, gsl_histogram2d, h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 3) { Check_Type(argv[1], T_STRING); Check_Type(argv[2], T_STRING); status = gsl_histogram2d_fprintf(fp, h, STR2CSTR(argv[1]), STR2CSTR(argv[2])); } else { status = gsl_histogram2d_fprintf(fp, h, "%g", "%g"); } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_histogram2d_fscanf(VALUE obj, VALUE io) { gsl_histogram2d *h = NULL; FILE *fp; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram2d, h); fp = rb_gsl_open_readfile(io, &flag); status = gsl_histogram2d_fscanf(fp, h); if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_histogram2d_reset(VALUE obj) { gsl_histogram2d *h = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); gsl_histogram2d_reset(h); return obj; } #ifdef GSL_0_9_4_LATER static VALUE rb_gsl_histogram2d_pdf_alloc(VALUE klass, VALUE nx, VALUE ny) { gsl_histogram2d_pdf *h = NULL; CHECK_FIXNUM(nx); CHECK_FIXNUM(ny); h = gsl_histogram2d_pdf_alloc(FIX2INT(nx), FIX2INT(ny)); return Data_Wrap_Struct(klass, 0, gsl_histogram2d_pdf_free, h); } static VALUE rb_gsl_histogram2d_pdf_init(VALUE obj, VALUE hh) { gsl_histogram2d_pdf *pdf = NULL; gsl_histogram2d *h = NULL; CHECK_HISTOGRAM2D(hh); Data_Get_Struct(obj, gsl_histogram2d_pdf, pdf); Data_Get_Struct(hh, gsl_histogram2d, h); gsl_histogram2d_pdf_init(pdf, h); return obj; } #else static VALUE rb_gsl_histogram2d_pdf_alloc(VALUE klass, VALUE hhh) { gsl_histogram2d_pdf *h = NULL; gsl_histogram2d *hh; Data_Get_Struct(hhh, gsl_histogram2d, hh); h = gsl_histogram2d_pdf_alloc(hh); return Data_Wrap_Struct(klass, 0, gsl_histogram2d_pdf_free, h); } #endif static VALUE rb_gsl_histogram2d_pdf_sample(VALUE obj, VALUE r1, VALUE r2) { gsl_histogram2d_pdf *pdf = NULL; double x, y; Need_Float(r1); Need_Float(r2); Data_Get_Struct(obj, gsl_histogram2d_pdf, pdf); gsl_histogram2d_pdf_sample(pdf, NUM2DBL(r1), NUM2DBL(r2), &x, &y); return rb_ary_new3(2, rb_float_new(x), rb_float_new(y)); } static VALUE rb_gsl_histogram2d_xrange(VALUE obj) { gsl_histogram2d *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); v = gsl_vector_view_alloc(h->nx); v->vector.data = h->xrange; v->vector.size = h->nx + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_range, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram2d_yrange(VALUE obj) { gsl_histogram2d *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); v = gsl_vector_view_alloc(h->ny); v->vector.data = h->yrange; v->vector.size = h->ny + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_range, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram2d_bin(VALUE obj) { gsl_histogram2d *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); v = gsl_vector_view_alloc(h->nx*h->ny); v->vector.data = h->bin; v->vector.size = h->nx*h->ny; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_bin, 0, gsl_vector_view_free, v); } void mygsl_histogram2d_yproject(const gsl_histogram2d *h2, size_t istart, size_t iend, gsl_histogram *h) { size_t i, j; double sum; for (j = 0; j < h2->ny; j++) { sum = 0.0; for (i = istart; i <= iend; i++) { if (i >= h2->nx) break; sum += gsl_histogram2d_get(h2, i, j); } h->bin[j] = sum; } } gsl_histogram* mygsl_histogram2d_calloc_yproject(const gsl_histogram2d *h2, size_t istart, size_t iend) { gsl_histogram *h; h = gsl_histogram_calloc_range(h2->ny, h2->yrange); mygsl_histogram2d_yproject(h2, istart, iend, h); return h; } void mygsl_histogram2d_xproject(const gsl_histogram2d *h2, size_t jstart, size_t jend, gsl_histogram *h) { size_t i, j; double sum; for (i = 0; i < h2->nx; i++) { sum = 0.0; for (j = jstart; j <= jend; j++) { if (j >= h2->ny) break; sum += gsl_histogram2d_get(h2, i, j); } h->bin[i] = sum; } } gsl_histogram* mygsl_histogram2d_calloc_xproject(const gsl_histogram2d *h2, size_t jstart, size_t jend) { gsl_histogram *h; h = gsl_histogram_calloc_range(h2->nx, h2->xrange); mygsl_histogram2d_xproject(h2, jstart, jend, h); return h; } static VALUE rb_gsl_histogram2d_xproject(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h2 = NULL; gsl_histogram *h = NULL; size_t jstart = 0, jend; Data_Get_Struct(obj, gsl_histogram2d, h2); switch (argc) { case 2: jstart = (size_t) FIX2INT(argv[0]); jend = (size_t) FIX2INT(argv[1]); break; case 1: jstart = (size_t) FIX2INT(argv[0]); jend = h2->ny; break; case 0: jend = h2->ny; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } h = mygsl_histogram2d_calloc_xproject(h2, jstart, jend); return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, h); } static VALUE rb_gsl_histogram2d_yproject(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h2 = NULL; gsl_histogram *h = NULL; size_t istart = 0, iend; Data_Get_Struct(obj, gsl_histogram2d, h2); switch (argc) { case 2: istart = (size_t) FIX2INT(argv[0]); iend = (size_t) FIX2INT(argv[1]); break; case 1: istart = (size_t) FIX2INT(argv[0]); iend = h2->ny; break; case 0: iend = h2->ny; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } h = mygsl_histogram2d_calloc_yproject(h2, istart, iend); return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, h); } static int mygsl_histogram2d_fread2(FILE * stream, gsl_histogram2d * h) { double xmin, xmax, ymin, ymax; int status; status = gsl_block_raw_fread(stream, &xmin, 1, 1); if (status) return status; status = gsl_block_raw_fread(stream, &xmax, 1, 1); if (status) return status; status = gsl_block_raw_fread(stream, &ymin, 1, 1); if (status) return status; status = gsl_block_raw_fread(stream, &ymax, 1, 1); if (status) return status; gsl_histogram2d_set_ranges_uniform(h, xmin, xmax, ymin, ymax); status = gsl_block_raw_fread (stream, h->bin, h->nx*h->ny, 1); if (status) return status; return status; } static int mygsl_histogram2d_fwrite2(FILE * stream, const gsl_histogram2d * h) { int status; status = gsl_block_raw_fwrite (stream, h->xrange, 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->xrange+h->nx, 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->yrange, 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->yrange+h->ny, 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->bin, h->nx*h->ny, 1); return status; } static VALUE rb_gsl_histogram2d_fwrite2(VALUE obj, VALUE io) { gsl_histogram2d *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram2d, h); f = rb_gsl_open_writefile(io, &flag); status = mygsl_histogram2d_fwrite2(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram2d_fread2(VALUE obj, VALUE io) { gsl_histogram2d *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram2d, h); f = rb_gsl_open_readfile(io, &flag); status = mygsl_histogram2d_fread2(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static gsl_histogram2d* mygsl_histogram2d_calloc_integrate(const gsl_histogram2d *h, int flag) { gsl_histogram2d *hi; size_t i, j, k; size_t nx = h->nx, ny = h->ny, n = h->nx*h->ny; hi = gsl_histogram2d_calloc(nx, ny); gsl_histogram2d_set_ranges(hi, h->xrange, nx+1, h->yrange, ny+1); if (flag == -1) { hi->bin[n-1] = h->bin[n-1]; i = nx - 1; for (j = ny-2, k = 0; j >= 0; j--, k++) { hi->bin[n-1-k] = gsl_histogram2d_get(hi, i, j+1) + gsl_histogram2d_get(h, i, j); if (j == 0) break; } j = ny - 1; for (i = nx-2; i >= 0; i--) { hi->bin[i*ny + j] = gsl_histogram2d_get(hi, i+1, j) + gsl_histogram2d_get(h, i, j); if (i == 0) break; } for (i = nx-2; i >= 0; i--) { for (j = ny-2; j >= 0; j--) { hi->bin[i*ny+j] = ((gsl_histogram2d_get(hi, i+1, j) + gsl_histogram2d_get(hi, i, j+1)) - gsl_histogram2d_get(hi, i+1, j+1)) + gsl_histogram2d_get(h, i, j); if (j == 0) break; } if (i == 0) break; } } else { hi->bin[0] = h->bin[0]; for (j = 1; j < ny; j++) hi->bin[j] = gsl_histogram2d_get(hi, 0, j-1) + gsl_histogram2d_get(h, 0, j); for (i = 1; i < nx; i++) hi->bin[i*ny] = gsl_histogram2d_get(hi, i-1, 0) + gsl_histogram2d_get(h, i, 0); for (i = 1; i < nx; i++) { for (j = 1; j < ny; j++) { hi->bin[i*ny+j] = ((gsl_histogram2d_get(hi, i-1, j) + gsl_histogram2d_get(hi, i, j-1)) - gsl_histogram2d_get(hi, i-1, j-1)) + gsl_histogram2d_get(h, i, j); } } } return hi; } static VALUE rb_gsl_histogram2d_integrate(int argc, VALUE *argv, VALUE obj) { gsl_histogram2d *h = NULL, *hi = NULL; int flag; Data_Get_Struct(obj, gsl_histogram2d, h); switch (argc) { case 0: flag = 1; break; case 1: flag = FIX2INT(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } hi = mygsl_histogram2d_calloc_integrate(h, flag); return Data_Wrap_Struct(cgsl_histogram2d_integ, 0, gsl_histogram2d_free, hi); } static VALUE rb_gsl_histogram2d_normalize_bang(VALUE obj) { gsl_histogram2d *h = NULL; double scale; Data_Get_Struct(obj, gsl_histogram2d, h); if (CLASS_OF(obj) == cgsl_histogram2d_integ) scale = 1.0/h->bin[h->nx*h->ny-1]; else scale = 1.0/gsl_histogram2d_sum(h); gsl_histogram2d_scale(h, scale); return obj; } static VALUE rb_gsl_histogram2d_normalize(VALUE obj) { gsl_histogram2d *h = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram2d, h); hnew = gsl_histogram2d_clone(h); return rb_gsl_histogram2d_normalize_bang(Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram2d_free, hnew)); } void Init_gsl_histogram2d(VALUE module) { VALUE cgsl_histogram2d_pdf; cgsl_histogram2d = rb_define_class_under(module, "Histogram2d", cGSL_Object); cgsl_histogram2d_view = rb_define_class_under(cgsl_histogram2d, "View", cgsl_histogram); cgsl_histogram2d_integ = rb_define_class_under(cgsl_histogram2d, "Integral", cgsl_histogram2d); #ifdef GSL_0_9_4_LATER /* rb_define_singleton_method(cgsl_histogram2d, "new", rb_gsl_histogram2d_alloc, -1);*/ rb_define_singleton_method(cgsl_histogram2d, "alloc", rb_gsl_histogram2d_alloc, -1); rb_define_singleton_method(cgsl_histogram2d, "new_uniform", rb_gsl_histogram2d_alloc_uniform, -1); rb_define_singleton_method(cgsl_histogram2d, "alloc_uniform", rb_gsl_histogram2d_alloc_uniform, -1); #endif rb_define_singleton_method(cgsl_histogram2d, "equal_bins_p", rb_gsl_histogram2d_equal_bins_p, 2); rb_define_singleton_method(cgsl_histogram2d, "equal_bins_p?", rb_gsl_histogram2d_equal_bins_p2, 2); rb_define_method(cgsl_histogram2d, "set_ranges", rb_gsl_histogram2d_set_ranges, -1); rb_define_method(cgsl_histogram2d, "set_ranges_uniform", rb_gsl_histogram2d_set_ranges_uniform, -1); rb_define_singleton_method(cgsl_histogram2d, "memcpy", rb_gsl_histogram2d_memcpy, 2); rb_define_method(cgsl_histogram2d, "clone", rb_gsl_histogram2d_clone, 0); rb_define_alias(cgsl_histogram2d, "duplicate", "clone"); rb_define_method(cgsl_histogram2d, "increment", rb_gsl_histogram2d_accumulate, -1); rb_define_alias(cgsl_histogram2d, "fill", "increment"); rb_define_alias(cgsl_histogram2d, "accumulate", "increment"); rb_define_method(cgsl_histogram2d, "increment2", rb_gsl_histogram2d_accumulate2, -1); rb_define_alias(cgsl_histogram2d, "accumulate2", "increment2"); rb_define_alias(cgsl_histogram2d, "fill2", "increment2"); rb_define_method(cgsl_histogram2d, "get", rb_gsl_histogram2d_get, -1); rb_define_alias(cgsl_histogram2d, "[]", "get"); rb_define_method(cgsl_histogram2d, "get_xrange", rb_gsl_histogram2d_get_xrange, 1); rb_define_method(cgsl_histogram2d, "get_yrange", rb_gsl_histogram2d_get_yrange, 1); rb_define_method(cgsl_histogram2d, "xmax", rb_gsl_histogram2d_xmax, 0); rb_define_method(cgsl_histogram2d, "xmin", rb_gsl_histogram2d_xmin, 0); rb_define_method(cgsl_histogram2d, "ymax", rb_gsl_histogram2d_ymax, 0); rb_define_method(cgsl_histogram2d, "ymin", rb_gsl_histogram2d_ymin, 0); rb_define_method(cgsl_histogram2d, "nx", rb_gsl_histogram2d_nx, 0); rb_define_method(cgsl_histogram2d, "ny", rb_gsl_histogram2d_ny, 0); rb_define_method(cgsl_histogram2d, "find", rb_gsl_histogram2d_find, 2); rb_define_method(cgsl_histogram2d, "max_val", rb_gsl_histogram2d_max_val, 0); rb_define_method(cgsl_histogram2d, "max_bin", rb_gsl_histogram2d_max_bin, 0); rb_define_method(cgsl_histogram2d, "min_val", rb_gsl_histogram2d_min_val, 0); rb_define_method(cgsl_histogram2d, "min_bin", rb_gsl_histogram2d_min_bin, 0); #ifdef GSL_1_1_LATER rb_define_method(cgsl_histogram2d, "xmean", rb_gsl_histogram2d_xmean, 0); rb_define_method(cgsl_histogram2d, "ymean", rb_gsl_histogram2d_ymean, 0); rb_define_method(cgsl_histogram2d, "xsigma", rb_gsl_histogram2d_xsigma, 0); rb_define_method(cgsl_histogram2d, "ysigma", rb_gsl_histogram2d_ysigma, 0); rb_define_method(cgsl_histogram2d, "cov", rb_gsl_histogram2d_cov, 0); rb_define_method(cgsl_histogram2d, "sum", rb_gsl_histogram2d_sum, 0); rb_define_alias(cgsl_histogram2d, "integral", "sum"); #endif rb_define_method(cgsl_histogram2d, "add", rb_gsl_histogram2d_add, 1); rb_define_alias(cgsl_histogram2d, "+", "add"); rb_define_method(cgsl_histogram2d, "sub", rb_gsl_histogram2d_sub, 1); rb_define_alias(cgsl_histogram2d, "-", "sub"); rb_define_method(cgsl_histogram2d, "mul", rb_gsl_histogram2d_mul, 1); rb_define_alias(cgsl_histogram2d, "*", "mul"); rb_define_method(cgsl_histogram2d, "div", rb_gsl_histogram2d_div, 1); rb_define_alias(cgsl_histogram2d, "/", "div"); rb_define_method(cgsl_histogram2d, "scale", rb_gsl_histogram2d_scale2, 1); rb_define_method(cgsl_histogram2d, "shift", rb_gsl_histogram2d_shift2, 1); rb_define_method(cgsl_histogram2d, "scale!", rb_gsl_histogram2d_scale, 1); rb_define_method(cgsl_histogram2d, "shift!", rb_gsl_histogram2d_shift, 1); rb_define_method(cgsl_histogram2d, "fwrite", rb_gsl_histogram2d_fwrite, 1); rb_define_method(cgsl_histogram2d, "fread", rb_gsl_histogram2d_fread, 1); rb_define_method(cgsl_histogram2d, "fwrite2", rb_gsl_histogram2d_fwrite2, 1); rb_define_method(cgsl_histogram2d, "fread2", rb_gsl_histogram2d_fread2, 1); rb_define_method(cgsl_histogram2d, "fprintf", rb_gsl_histogram2d_fprintf, -1); rb_define_method(cgsl_histogram2d, "fscanf", rb_gsl_histogram2d_fscanf, 3); cgsl_histogram2d_pdf = rb_define_class_under(cgsl_histogram2d, "Pdf", cGSL_Object); #ifdef GSL_0_9_4_LATER /* rb_define_singleton_method(cgsl_histogram2d_pdf, "new", rb_gsl_histogram2d_pdf_alloc, 2);*/ rb_define_singleton_method(cgsl_histogram2d_pdf, "alloc", rb_gsl_histogram2d_pdf_alloc, 2); rb_define_method(cgsl_histogram2d_pdf, "init", rb_gsl_histogram2d_pdf_init, 1); #else /* rb_define_singleton_method(cgsl_histogram2d_pdf, "new", rb_gsl_histogram2d_pdf_alloc, 1);*/ rb_define_singleton_method(cgsl_histogram2d_pdf, "alloc", rb_gsl_histogram2d_pdf_alloc, 1); #endif rb_define_method(cgsl_histogram2d_pdf, "sample", rb_gsl_histogram2d_pdf_sample, 2); rb_define_method(cgsl_histogram2d, "xrange", rb_gsl_histogram2d_xrange, 0); rb_define_method(cgsl_histogram2d, "yrange", rb_gsl_histogram2d_yrange, 0); rb_define_method(cgsl_histogram2d, "bin", rb_gsl_histogram2d_bin, 0); rb_define_method(cgsl_histogram2d, "reset", rb_gsl_histogram2d_reset, 0); rb_define_method(cgsl_histogram2d, "xproject", rb_gsl_histogram2d_xproject, -1); rb_define_method(cgsl_histogram2d, "yproject", rb_gsl_histogram2d_yproject, -1); rb_define_method(cgsl_histogram2d, "integrate", rb_gsl_histogram2d_integrate, -1); rb_undef_method(cgsl_histogram2d_integ, "integrate"); rb_define_method(cgsl_histogram2d, "normalize", rb_gsl_histogram2d_normalize, 0); rb_define_method(cgsl_histogram2d, "normalize!", rb_gsl_histogram2d_normalize_bang, 0); } #ifdef HISTOGRAM2D_P #undef HISTOGRAM2D_P #endif #ifdef CHECK_HISTOGRAM2D #undef CHECK_HISTOGRAM2D #endif gsl-1.15.3/ext/geometry.c0000644000175000017500000000665512220252463014555 0ustar boutilboutil#include "rb_gsl.h" /*! Counter-clockwise rotation around the X-axis / x' \ / 1 0 0 \ / x \ | y' | = | 0 cos_th -sin_th | | y | \ z' / \ 0 sin_th cos_th / \ z / */ void vector3_rotateX(const double x[3] /*!< Input */, double theta /*!< Rotation angle */, double xout[3] /*!< Output */) { double a, b, c; double costheta, sintheta; costheta = cos(theta); sintheta = sin(theta); a = x[0]; b = x[1]*costheta - x[2]*sintheta; c = x[1]*sintheta + x[2]*costheta; xout[0] = a; xout[1] = b; xout[2] = c; } /*! Counter-clockwise rotation around the Y-axis (Note the sign of the matrix element.) / x' \ / cos_th 0 sin_th \ / x \ | y' | = | 0 1 0 | | y | \ z' / \ -sin_th 0 cos_th / \ z / */ void vector3_rotateY(const double x[3] /*!< Input */, double theta /*!< Rotation angle */, double xout[3] /*!< Output */) { double a, b, c; double costheta, sintheta; costheta = cos(theta); sintheta = sin(theta); a = x[0]*costheta + x[2]*sintheta; b = x[1]; c = -x[0]*sintheta + x[2]*costheta; xout[0] = a; xout[1] = b; xout[2] = c; } /*! Counter-clockwise rotation around the Z-axis / x' \ / cos_th -sin_th 0 \ / x \ | y' | = | sin_th cos_th 0 | | y | \ z' / \ 0 0 1 / \ z / */ void vector3_rotateZ(const double x[3] /*!< Input */, double theta /*!< Rotation angle */, double xout[3] /*!< Output */) { double a, b, c; double costheta, sintheta; costheta = cos(theta); sintheta = sin(theta); a = x[0]*costheta - x[1]*sintheta; b = x[0]*sintheta + x[1]*costheta; c = x[2]; xout[0] = a; xout[1] = b; xout[2] = c; } /*! Rotate a 3-vector. If flag != 1, cos/sin values stored in the static variables are used for efficiency. The input and the output vectors (x, xout) can be the same pointer. / x' \ / cos_phi -sin_phi 0 \ / cos_th 0 sin_th \ / x \ | y' | = | sin_phi cos_phi 0 | | 0 1 | | y | \ z' / \ 0 0 1 / \ -sin_th 0 cos_th / \ z / */ void vector3_rotate(const double x[3], double theta, double phi, double xout[3]) { vector3_rotateY(x, theta,xout); vector3_rotateZ(xout, phi, xout); } static VALUE rb_gsl_vector_rotateX(VALUE obj, VALUE angle) { gsl_vector *v; Data_Get_Struct(obj, gsl_vector, v); vector3_rotateX(v->data, NUM2DBL(angle), v->data); return obj; } static VALUE rb_gsl_vector_rotateY(VALUE obj, VALUE angle) { gsl_vector *v; Data_Get_Struct(obj, gsl_vector, v); vector3_rotateY(v->data, NUM2DBL(angle), v->data); return obj; } static VALUE rb_gsl_vector_rotateZ(VALUE obj, VALUE angle) { gsl_vector *v; Data_Get_Struct(obj, gsl_vector, v); vector3_rotateZ(v->data, NUM2DBL(angle), v->data); return obj; } static VALUE rb_gsl_vector_rotate(VALUE obj, VALUE theta, VALUE phi) { gsl_vector *v; Data_Get_Struct(obj, gsl_vector, v); vector3_rotate(v->data, NUM2DBL(theta), NUM2DBL(phi), v->data); return obj; } void Init_geometry(VALUE module) { rb_define_method(cgsl_vector, "rotateX", rb_gsl_vector_rotateX, 1); rb_define_method(cgsl_vector, "rotateY", rb_gsl_vector_rotateY, 1); rb_define_method(cgsl_vector, "rotateZ", rb_gsl_vector_rotateZ, 1); rb_define_method(cgsl_vector, "rotate", rb_gsl_vector_rotate, 2); } gsl-1.15.3/ext/interp.c0000644000175000017500000003740012220252463014213 0ustar boutilboutil/* interp.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_interp.h" VALUE cgsl_interp_accel; /* this is used also in spline.c */ EXTERN VALUE cgsl_vector, cgsl_matrix; static void rb_gsl_interp_free(rb_gsl_interp *sp); static VALUE rb_gsl_interp_new(int argc, VALUE *argv, VALUE klass) { rb_gsl_interp *sp = NULL; const gsl_interp_type *T = NULL; double *ptrx = NULL, *ptry = NULL; size_t sizex = 0, sizey = 0, size = 0, stride = 1; int i; for (i = 0; i < argc; i++) { switch (TYPE(argv[i])) { case T_STRING: T = get_interp_type(argv[i]); break; case T_FIXNUM: if (T) size = FIX2INT(argv[i]); else T = get_interp_type(argv[i]); break; default: if (ptrx == NULL) { ptrx = get_vector_ptr(argv[i], &stride, &sizex); } else { ptry = get_vector_ptr(argv[i], &stride, &sizey); size = GSL_MIN_INT(sizex, sizey); } break; } } if (size == 0) rb_raise(rb_eRuntimeError, "interp size is not given."); sp = ALLOC(rb_gsl_interp); if (T == NULL) T = gsl_interp_cspline; sp->p = gsl_interp_alloc(T, size); sp->a = gsl_interp_accel_alloc(); if (ptrx && ptry) gsl_interp_init(sp->p, ptrx, ptry, size); return Data_Wrap_Struct(klass, 0, rb_gsl_interp_free, sp); } static void rb_gsl_interp_free(rb_gsl_interp *sp) { gsl_interp_free(sp->p); gsl_interp_accel_free(sp->a); free((rb_gsl_interp *) sp); } static VALUE rb_gsl_interp_init(VALUE obj, VALUE xxa, VALUE yya) { rb_gsl_interp *rgi = NULL; double *ptrx = NULL, *ptry = NULL; size_t size, stride; ptrx = get_vector_ptr(xxa, &stride, &size); ptry = get_vector_ptr(yya, &stride, &size); Data_Get_Struct(obj, rb_gsl_interp, rgi); gsl_interp_init(rgi->p, ptrx, ptry, size); return obj; } static VALUE rb_gsl_interp_name(VALUE obj) { rb_gsl_interp *rgi = NULL; Data_Get_Struct(obj, rb_gsl_interp, rgi); return rb_str_new2(gsl_interp_name(rgi->p)); } static VALUE rb_gsl_interp_min_size(VALUE obj) { rb_gsl_interp *rgi = NULL; Data_Get_Struct(obj, rb_gsl_interp, rgi); return INT2FIX(gsl_interp_min_size(rgi->p)); } static VALUE rb_gsl_interp_bsearch(int argc, VALUE *argv, VALUE obj) { gsl_vector *v = NULL; double x; size_t indexl, indexh; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: CHECK_VECTOR(argv[0]); Need_Float(argv[1]); Data_Get_Struct(argv[0], gsl_vector, v); x = NUM2DBL(argv[1]); indexl = gsl_vector_get(v, 0); indexh = gsl_vector_get(v, v->size-1); break; case 4: CHECK_VECTOR(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); Need_Float(argv[3]); Data_Get_Struct(argv[0], gsl_vector, v); x = NUM2DBL(argv[1]); indexl = NUM2DBL(argv[2]); indexh = NUM2DBL(argv[3]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 4)", argc); break; } break; default: Data_Get_Struct(obj, gsl_vector, v); switch (argc) { case 1: Need_Float(argv[0]); x = NUM2DBL(argv[0]); indexl = gsl_vector_get(v, 0); indexh = gsl_vector_get(v, v->size-1); break; case 3: Need_Float(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); x = NUM2DBL(argv[0]); indexl = NUM2DBL(argv[1]); indexh = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc); break; } break; } return INT2FIX(gsl_interp_bsearch(v->data, x, indexl, indexh)); } static VALUE rb_gsl_interp_accel(VALUE obj) { rb_gsl_interp *rgi = NULL; Data_Get_Struct(obj, rb_gsl_interp, rgi); return Data_Wrap_Struct(cgsl_interp_accel, 0, NULL, rgi->a); } static VALUE rb_gsl_interp_find(VALUE obj, VALUE vv, VALUE xx) { rb_gsl_interp *rgi = NULL; double *ptr = NULL, x; size_t size, stride; Need_Float(xx); Data_Get_Struct(obj, rb_gsl_interp, rgi); ptr = get_vector_ptr(vv, &stride, &size); x = NUM2DBL(xx); return INT2FIX(gsl_interp_accel_find(rgi->a, ptr, size, x)); } static VALUE rb_gsl_interp_accel_find(VALUE obj, VALUE vv, VALUE xx) { gsl_interp_accel *a = NULL; double x, *ptr = NULL; size_t size, stride; Need_Float(xx); Data_Get_Struct(obj, gsl_interp_accel, a); ptr = get_vector_ptr(vv, &stride, &size); Need_Float(xx); x = NUM2DBL(xx); return INT2FIX(gsl_interp_accel_find(a, ptr, size, x)); } static VALUE rb_gsl_interp_evaluate(VALUE obj, VALUE xxa, VALUE yya, VALUE xx, double (*eval)(const gsl_interp *, const double [], const double [], double, gsl_interp_accel *)) { rb_gsl_interp *rgi = NULL; double *ptrx = NULL, *ptry = NULL; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, x; double val; size_t n, i, j, size, stridex, stridey; #ifdef HAVE_NARRAY_H struct NARRAY *na = NULL; double *ptrz = NULL, *ptr = NULL; #endif Data_Get_Struct(obj, rb_gsl_interp, rgi); ptrx = get_vector_ptr(xxa, &stridex, &size); if (size != rgi->p->size ){ rb_raise(rb_eTypeError, "size mismatch (xa:%d != %d)", (int) size, (int) rgi->p->size); } ptry = get_vector_ptr(yya, &stridey, &size); if (size != rgi->p->size ){ rb_raise(rb_eTypeError, "size mismatch (ya:%d != %d)", (int) size, (int) rgi->p->size); } if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: Need_Float(xx); return rb_float_new((*eval)(rgi->p, ptrx, ptry, NUM2DBL(xx), rgi->a)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); val = (*eval)(rgi->p, ptrx, ptry, NUM2DBL(x), rgi->a); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptrz = (double*) na->ptr; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr = NA_PTR_TYPE(ary, double*); for (i = 0; i < na->total; i++) ptr[i] = (*eval)(rgi->p, ptrx, ptry, ptrz[i], rgi->a); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { val = (*eval)(rgi->p, ptrx, ptry, gsl_vector_get(v, i), rgi->a); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { val = (*eval)(rgi->p, ptrx, ptry, gsl_matrix_get(m, i, j), rgi->a); gsl_matrix_set(mnew, i, j, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; } static VALUE rb_gsl_interp_eval(VALUE obj, VALUE xxa, VALUE yya, VALUE xx) { return rb_gsl_interp_evaluate(obj, xxa, yya, xx, gsl_interp_eval); } static VALUE rb_gsl_interp_eval_e(VALUE obj, VALUE xxa, VALUE yya, VALUE xx) { rb_gsl_interp *rgi = NULL; double *ptr1 = NULL, *ptr2 = NULL; size_t size, stridex, stridey; double x, y; int status; Need_Float(xx); Data_Get_Struct(obj, rb_gsl_interp, rgi); ptr1 = get_vector_ptr(xxa, &stridex, &size); ptr2 = get_vector_ptr(yya, &stridey, &size); x = NUM2DBL(xx); status = gsl_interp_eval_e(rgi->p, ptr1, ptr2, x, rgi->a, &y); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_interp_eval_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(y); break; } return Qnil; } static VALUE rb_gsl_interp_eval_deriv(VALUE obj, VALUE xxa, VALUE yya, VALUE xx) { return rb_gsl_interp_evaluate(obj, xxa, yya, xx, gsl_interp_eval_deriv); } static VALUE rb_gsl_interp_eval_deriv_e(VALUE obj, VALUE xxa, VALUE yya, VALUE xx) { rb_gsl_interp *rgi = NULL; double *ptr1 = NULL, *ptr2 = NULL; size_t size, stridex, stridey; double x, y; int status; Need_Float(xx); Data_Get_Struct(obj, rb_gsl_interp, rgi); ptr1 = get_vector_ptr(xxa, &stridex, &size); ptr2 = get_vector_ptr(yya, &stridey, &size); x = NUM2DBL(xx); status = gsl_interp_eval_deriv_e(rgi->p, ptr1, ptr2, x, rgi->a, &y); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_interp_eval_deriv_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(y); break; } return Qnil; } static VALUE rb_gsl_interp_eval_deriv2(VALUE obj, VALUE xxa, VALUE yya, VALUE xx) { return rb_gsl_interp_evaluate(obj, xxa, yya, xx, gsl_interp_eval_deriv2); } static VALUE rb_gsl_interp_eval_deriv2_e(VALUE obj, VALUE xxa, VALUE yya, VALUE xx) { rb_gsl_interp *rgi = NULL; double *ptr1 = NULL, *ptr2 = NULL, x, y; size_t size, stridex, stridey; int status; Need_Float(xx); Data_Get_Struct(obj, rb_gsl_interp, rgi); ptr1 = get_vector_ptr(xxa, &stridex, &size); ptr2 = get_vector_ptr(yya, &stridey, &size); x = NUM2DBL(xx); status = gsl_interp_eval_deriv2_e(rgi->p, ptr1, ptr2, x, rgi->a, &y); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_interp_eval_deriv2_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(y); break; } return Qnil; } static VALUE rb_gsl_interp_eval_integ(VALUE obj, VALUE xxa, VALUE yya, VALUE aa, VALUE bb) { rb_gsl_interp *rgi = NULL; double *ptr1 = NULL, *ptr2 = NULL; size_t size, stridex, stridey; double a, b; Need_Float(aa); Need_Float(bb); Data_Get_Struct(obj, rb_gsl_interp, rgi); ptr1 = get_vector_ptr(xxa, &stridex, &size); ptr2 = get_vector_ptr(yya, &stridey, &size); a = NUM2DBL(aa); b = NUM2DBL(bb); return rb_float_new(gsl_interp_eval_integ(rgi->p, ptr1, ptr2, a, b, rgi->a)); } static VALUE rb_gsl_interp_eval_integ_e(VALUE obj, VALUE xxa, VALUE yya, VALUE aa, VALUE bb) { rb_gsl_interp *rgi = NULL; double *ptr1 = NULL, *ptr2 = NULL; size_t size, stridex, stridey; double y, a, b; int status; Need_Float(aa); Need_Float(bb); Data_Get_Struct(obj, rb_gsl_interp, rgi); ptr1 = get_vector_ptr(xxa, &stridex, &size); ptr2 = get_vector_ptr(yya, &stridey, &size); a = NUM2DBL(aa); b = NUM2DBL(bb); status = gsl_interp_eval_integ_e(rgi->p, ptr1, ptr2, a, b, rgi->a, &y); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_interp_eval_integ_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(y); break; } return Qnil; } /******/ const gsl_interp_type* get_interp_type(VALUE t) { int type; char name[32]; switch (TYPE(t)) { case T_FIXNUM: type = FIX2INT(t); switch (type) { case GSL_INTERP_LINEAR: return gsl_interp_linear; break; #ifdef GSL_1_1_LATER case GSL_INTERP_POLYNOMIAL: return gsl_interp_polynomial; break; #endif case GSL_INTERP_CSPLINE: return gsl_interp_cspline; break; case GSL_INTERP_CSPLINE_PERIODIC: return gsl_interp_cspline_periodic; break; case GSL_INTERP_AKIMA: return gsl_interp_akima; break; case GSL_INTERP_AKIMA_PERIODIC: return gsl_interp_akima_periodic; break; default: rb_raise(rb_eTypeError, "unknown type %d\n", type); break; } break; case T_STRING: strcpy(name, STR2CSTR(t)); if (str_tail_grep(name, "linear") == 0) { return gsl_interp_linear; #ifdef GSL_1_1_LATER } else if (str_tail_grep(name, "polynomial") == 0) { return gsl_interp_polynomial; #endif } else if (str_tail_grep(name, "cspline") == 0) { return gsl_interp_cspline; } else if (str_tail_grep(name, "cspline_periodic") == 0) { return gsl_interp_cspline_periodic; } else if (str_tail_grep(name, "akima") == 0) { return gsl_interp_akima; } else if (str_tail_grep(name, "akima_periodic") == 0) { return gsl_interp_akima_periodic; } else { rb_raise(rb_eTypeError, "Unknown type"); } break; default: rb_raise(rb_eTypeError, "Unknown type"); break; } } static VALUE rb_gsl_interp_info(VALUE obj) { rb_gsl_interp *p; char buf[256]; Data_Get_Struct(obj, rb_gsl_interp, p); sprintf(buf, "Class: %s\n", rb_class2name(CLASS_OF(obj))); #ifdef RUBY_1_9_LATER sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj)))); #else sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super)); #endif sprintf(buf, "%sType: %s\n", buf, gsl_interp_name(p->p)); sprintf(buf, "%sxmin: %f\n", buf, p->p->xmin); sprintf(buf, "%sxmax: %f\n", buf, p->p->xmax); sprintf(buf, "%sSize: %d\n", buf, (int) p->p->size); return rb_str_new2(buf); } static void rb_gsl_interp_define_const(VALUE klass) { rb_define_const(klass, "LINEAR", INT2FIX(GSL_INTERP_LINEAR)); rb_define_const(klass, "CSPLINE", INT2FIX(GSL_INTERP_CSPLINE)); rb_define_const(klass, "CSPLINE_PERIODIC", INT2FIX(GSL_INTERP_CSPLINE_PERIODIC)); rb_define_const(klass, "AKIMA", INT2FIX(GSL_INTERP_AKIMA)); rb_define_const(klass, "AKIMA_PERIODIC", INT2FIX(GSL_INTERP_AKIMA_PERIODIC)); rb_define_const(klass, "Linear", INT2FIX(GSL_INTERP_LINEAR)); #ifdef GSL_1_1_LATER rb_define_const(klass, "POLYNOMIAL", INT2FIX(GSL_INTERP_POLYNOMIAL)); rb_define_const(klass, "Polynomial", INT2FIX(GSL_INTERP_POLYNOMIAL)); #endif rb_define_const(klass, "CSpline", INT2FIX(GSL_INTERP_CSPLINE)); rb_define_const(klass, "CSpline_Periodic", INT2FIX(GSL_INTERP_CSPLINE_PERIODIC)); rb_define_const(klass, "Akima", INT2FIX(GSL_INTERP_AKIMA)); rb_define_const(klass, "Akima_Periodic", INT2FIX(GSL_INTERP_AKIMA_PERIODIC)); } void Init_gsl_interp(VALUE module) { VALUE cgsl_interp; cgsl_interp = rb_define_class_under(module, "Interp", cGSL_Object); cgsl_interp_accel = rb_define_class_under(cgsl_interp, "Accel", cGSL_Object); rb_define_singleton_method(cgsl_interp, "alloc", rb_gsl_interp_new, -1); rb_gsl_interp_define_const(cgsl_interp); /*****/ rb_define_singleton_method(cgsl_interp, "bsearch", rb_gsl_interp_bsearch, -1); rb_define_method(cgsl_vector, "bsearch", rb_gsl_interp_bsearch, -1); rb_define_method(cgsl_interp, "name", rb_gsl_interp_name, 0); rb_define_alias(cgsl_interp, "type", "name"); rb_define_method(cgsl_interp, "min_size", rb_gsl_interp_min_size, 0); rb_define_method(cgsl_interp, "init", rb_gsl_interp_init, 2); rb_define_method(cgsl_interp, "accel", rb_gsl_interp_accel, 0); rb_define_method(cgsl_interp, "eval", rb_gsl_interp_eval, 3); rb_define_alias(cgsl_interp, "[]", "eval"); rb_define_method(cgsl_interp, "eval_e", rb_gsl_interp_eval_e, 3); rb_define_method(cgsl_interp, "eval_deriv", rb_gsl_interp_eval_deriv, 3); rb_define_alias(cgsl_interp, "deriv", "eval_deriv"); rb_define_method(cgsl_interp, "eval_deriv_e", rb_gsl_interp_eval_deriv_e, 3); rb_define_method(cgsl_interp, "eval_deriv2", rb_gsl_interp_eval_deriv2, 3); rb_define_alias(cgsl_interp, "deriv2", "eval_deriv2"); rb_define_method(cgsl_interp, "eval_deriv2_e", rb_gsl_interp_eval_deriv2_e, 3); rb_define_method(cgsl_interp, "eval_integ", rb_gsl_interp_eval_integ, 4); rb_define_alias(cgsl_interp, "integ", "eval_integ"); rb_define_method(cgsl_interp, "eval_integ_e", rb_gsl_interp_eval_integ_e, 4); /*****/ rb_define_method(cgsl_interp_accel, "find", rb_gsl_interp_accel_find, 2); rb_define_method(cgsl_interp, "find", rb_gsl_interp_find, 2); rb_define_alias(cgsl_interp, "accel_find", "find"); rb_define_method(cgsl_interp, "info", rb_gsl_interp_info, 0); } gsl-1.15.3/ext/sf_expint.c0000644000175000017500000001545212220252463014714 0ustar boutilboutil/* sf_expint.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_expint_E1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expint_E1, x); } static VALUE rb_gsl_sf_expint_E1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expint_E1_e, x); } static VALUE rb_gsl_sf_expint_E2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expint_E2, x); } static VALUE rb_gsl_sf_expint_E2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expint_E2_e, x); } static VALUE rb_gsl_sf_expint_Ei(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expint_Ei, x); } static VALUE rb_gsl_sf_expint_Ei_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expint_Ei_e, x); } static VALUE rb_gsl_sf_Shi(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_Shi, x); } static VALUE rb_gsl_sf_Shi_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_Shi_e, x); } static VALUE rb_gsl_sf_Chi(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_Chi, x); } static VALUE rb_gsl_sf_Chi_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_Chi_e, x); } static VALUE rb_gsl_sf_expint_3(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expint_3, x); } static VALUE rb_gsl_sf_expint_3_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expint_3_e, x); } static VALUE rb_gsl_sf_Si(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_Si, x); } static VALUE rb_gsl_sf_Si_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_Si_e, x); } static VALUE rb_gsl_sf_Ci(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_Ci, x); } static VALUE rb_gsl_sf_Ci_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_Ci_e, x); } static VALUE rb_gsl_sf_atanint(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_atanint, x); } static VALUE rb_gsl_sf_atanint_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_atanint_e, x); } #ifdef GSL_1_3_LATER static VALUE rb_gsl_sf_expint_E1_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expint_E1_scaled, x); } static VALUE rb_gsl_sf_expint_E1_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expint_E1_scaled_e, x); } static VALUE rb_gsl_sf_expint_E2_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expint_E2_scaled, x); } static VALUE rb_gsl_sf_expint_E2_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expint_E2_scaled_e, x); } static VALUE rb_gsl_sf_expint_Ei_scaled(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expint_Ei_scaled, x); } static VALUE rb_gsl_sf_expint_Ei_scaled_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expint_Ei_scaled_e, x); } #endif #ifdef GSL_1_10_LATER static VALUE rb_gsl_sf_expint_En(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_expint_En, n, x); } static VALUE rb_gsl_sf_expint_En_e(VALUE obj, VALUE n, VALUE x) { gsl_sf_result *rslt = NULL; VALUE val; val = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); gsl_sf_expint_En_e(FIX2INT(n), NUM2DBL(x), rslt); return val; } #endif void Init_gsl_sf_expint(VALUE module) { VALUE mgsl_sf_expint; rb_define_module_function(module, "expint_E1", rb_gsl_sf_expint_E1, 1); rb_define_module_function(module, "expint_E1_e", rb_gsl_sf_expint_E1_e, 1); rb_define_module_function(module, "expint_E2", rb_gsl_sf_expint_E2, 1); rb_define_module_function(module, "expint_E2_e", rb_gsl_sf_expint_E2_e, 1); rb_define_module_function(module, "expint_Ei", rb_gsl_sf_expint_Ei, 1); rb_define_module_function(module, "expint_Ei_e", rb_gsl_sf_expint_Ei_e, 1); rb_define_module_function(module, "Shi", rb_gsl_sf_Shi, 1); rb_define_module_function(module, "Shi_e", rb_gsl_sf_Shi_e, 1); rb_define_module_function(module, "Chi", rb_gsl_sf_Chi, 1); rb_define_module_function(module, "Chi_e", rb_gsl_sf_Chi_e, 1); rb_define_module_function(module, "expint_3", rb_gsl_sf_expint_3, 1); rb_define_module_function(module, "expint_3_e", rb_gsl_sf_expint_3_e, 1); rb_define_module_function(module, "Si", rb_gsl_sf_Si, 1); rb_define_module_function(module, "Si_e", rb_gsl_sf_Si_e, 1); rb_define_module_function(module, "Ci", rb_gsl_sf_Ci, 1); rb_define_module_function(module, "Ci_e", rb_gsl_sf_Ci_e, 1); rb_define_module_function(module, "atanint", rb_gsl_sf_atanint, 1); rb_define_module_function(module, "atanint_e", rb_gsl_sf_atanint_e, 1); mgsl_sf_expint = rb_define_module_under(module, "Expint"); rb_define_module_function(mgsl_sf_expint, "E1", rb_gsl_sf_expint_E1, 1); rb_define_module_function(mgsl_sf_expint, "E1_e", rb_gsl_sf_expint_E1_e, 1); rb_define_module_function(mgsl_sf_expint, "E2", rb_gsl_sf_expint_E2, 1); rb_define_module_function(mgsl_sf_expint, "E2_e", rb_gsl_sf_expint_E2_e, 1); rb_define_module_function(mgsl_sf_expint, "Ei", rb_gsl_sf_expint_Ei, 1); rb_define_module_function(mgsl_sf_expint, "Ei_e", rb_gsl_sf_expint_Ei_e, 1); rb_define_module_function(mgsl_sf_expint, "three", rb_gsl_sf_expint_3, 1); rb_define_module_function(mgsl_sf_expint, "three_e", rb_gsl_sf_expint_3_e, 1); #ifdef GSL_1_3_LATER rb_define_module_function(module, "expint_E1_scaled", rb_gsl_sf_expint_E1_scaled, 1); rb_define_module_function(module, "expint_E1_scaled_e", rb_gsl_sf_expint_E1_scaled_e, 1); rb_define_module_function(module, "expint_E2_scaled", rb_gsl_sf_expint_E2_scaled, 1); rb_define_module_function(module, "expint_E2_scaled_e", rb_gsl_sf_expint_E2_scaled_e, 1); rb_define_module_function(module, "expint_Ei_scaled", rb_gsl_sf_expint_Ei_scaled, 1); rb_define_module_function(module, "expint_Ei_scaled_e", rb_gsl_sf_expint_Ei_scaled_e, 1); rb_define_module_function(mgsl_sf_expint, "E1_scaled", rb_gsl_sf_expint_E1_scaled, 1); rb_define_module_function(mgsl_sf_expint, "E1_scaled_e", rb_gsl_sf_expint_E1_scaled_e, 1); rb_define_module_function(mgsl_sf_expint, "E2_scaled", rb_gsl_sf_expint_E2_scaled, 1); rb_define_module_function(mgsl_sf_expint, "E2_scaled_e", rb_gsl_sf_expint_E2_scaled_e, 1); rb_define_module_function(mgsl_sf_expint, "Ei_scaled", rb_gsl_sf_expint_Ei_scaled, 1); rb_define_module_function(mgsl_sf_expint, "Ei_scaled_e", rb_gsl_sf_expint_Ei_scaled_e, 1); #endif #ifdef GSL_1_10_LATER rb_define_module_function(module, "expint_En", rb_gsl_sf_expint_En, 2); rb_define_module_function(mgsl_sf_expint, "En", rb_gsl_sf_expint_En, 2); rb_define_module_function(module, "expint_En_e", rb_gsl_sf_expint_En_e, 2); rb_define_module_function(mgsl_sf_expint, "En_e", rb_gsl_sf_expint_En_e, 2); #endif } gsl-1.15.3/ext/nmf.c0000644000175000017500000000704712220252463013476 0ustar boutilboutil/** * NMF: Non-Negative Matrix Factorization * * Written by Roman Shterenzon * (Slightly modified by Y.Tsunesada: just added "const" qualifiers etc.) */ #include #include #include #include /* for multiplication */ #define THRESH 0.000001 #define MAXITER 1000 #undef DEBUG #define mm(a, b) gsl_matrix_mult(a, b) //gsl_matrix * gsl_matrix_mult(gsl_matrix *a, gsl_matrix *b) gsl_matrix * gsl_matrix_mult(const gsl_matrix *a, const gsl_matrix *b) { gsl_matrix *c; c = gsl_matrix_alloc(a->size1, b->size2); gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, a, b, 0.0, c); return c; } // pretty print //void pp(gsl_matrix *m) void pp(const gsl_matrix *m) { int r, c; for(r=0; rsize1; r++) { for(c=0; csize2; c++) { printf(" %.2f", gsl_matrix_get(m, r, c)); } printf("\n"); } } /* Returns a distance cost */ //double difcost(gsl_matrix *a, gsl_matrix *b) double difcost(const gsl_matrix *a, const gsl_matrix *b) { int i, j; double dif=0, d; for (i=0; i < a->size1; i++) { for (j=0; j < a->size2; j++) { d = gsl_matrix_get(a, i, j) - gsl_matrix_get(b, i, j); dif += d*d; // dif += pow(gsl_matrix_get(a, i, j) - gsl_matrix_get(b, i, j), 2); } } return dif; } static void initmatrix(gsl_matrix *m, double min, double max) { int i,j; double val; srand(time(NULL)); for(i=0; i < m->size1; i++) { for(j=0; j < m->size2; j++) { val = min + (int) (max * (rand() / (RAND_MAX + min))); gsl_matrix_set(m, i, j, val); } } } static double update(gsl_matrix *v, gsl_matrix *w, gsl_matrix *h) { double dist = 0; gsl_matrix *wt=NULL, *ht=NULL, *wh=NULL; gsl_matrix *w_h=NULL, *wt_w=NULL; gsl_matrix *wt_v = NULL; gsl_matrix *v_ht=NULL, *wt_w_h=NULL, *w_h_ht=NULL; wt = gsl_matrix_alloc(w->size2, w->size1); gsl_matrix_transpose_memcpy(wt, w); ht = gsl_matrix_alloc(h->size2, h->size1); gsl_matrix_transpose_memcpy(ht, h); // wt * v wt_v = mm(wt, v); // wt * w * h wt_w = mm(wt, w); wt_w_h = mm(wt_w, h); gsl_matrix_free(wt_w); // h = h.mul_elements(wt * v).div_elements(wt * w * h) gsl_matrix_mul_elements(h, wt_v); gsl_matrix_div_elements(h, wt_w_h); gsl_matrix_free(wt_v); gsl_matrix_free(wt_w_h); // v * ht v_ht = mm(v, ht); // w * h * ht w_h = mm(w, h); w_h_ht = mm(w_h, ht); gsl_matrix_free(w_h); // w = w.mul_elements(v * ht).div_elements(w * h * ht) gsl_matrix_mul_elements(w, v_ht); gsl_matrix_div_elements(w, w_h_ht); gsl_matrix_free(v_ht); gsl_matrix_free(w_h_ht); gsl_matrix_free(wt); gsl_matrix_free(ht); wh = mm(w, h); dist = difcost(v, wh); gsl_matrix_free(wh); // w and h were modified in place return dist; } /* The main thing - compute the nmf */ int gsl_matrix_nmf(gsl_matrix *v, int cols, gsl_matrix **w, gsl_matrix **h) { double dist = 1; int iter = 1; double min, max; #ifdef DEBUG printf("\nCols: %d\nv:\n", cols); pp(v); #endif gsl_matrix_minmax(v, &min, &max); #ifdef DEBUG printf("Min: %f, Max: %f\n", min, max); #endif *w = gsl_matrix_alloc(v->size1, cols); initmatrix(*w, min, max/2); // the multiplicative rules tend to increase w *h = gsl_matrix_alloc(cols, v->size2); initmatrix(*h, min, max); while(dist >= THRESH && iter < MAXITER) { dist = update(v, *w, *h); #ifdef DEBUG printf("Iteration: %d, distance: %f\n", iter, dist); printf("\nw:\n"); pp(*w); printf("\nh:\n"); pp(*h); printf("\n"); #endif iter++; } #ifdef DEBUG printf("Ended\n"); #endif return GSL_SUCCESS; } gsl-1.15.3/ext/graph.c0000644000175000017500000013437112220252463014020 0ustar boutilboutil/* graph.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_graph.h" void make_graphcommand(char *command, VALUE hash) { VALUE val; if (TYPE(hash) == T_STRING) { sprintf(command, "graph -T X -g 3 %s", STR2CSTR(hash)); return; } strcpy(command, "graph"); if (TYPE(hash) != T_HASH) rb_raise(rb_eTypeError, "wrong argument type %s (Hash expected)", rb_class2name(CLASS_OF(hash))); if ((val = rb_hash_aref(hash, rb_str_new2("T"))) != Qnil) sprintf(command, "%s -T %s", command, STR2CSTR(val)); else sprintf(command, "%s -T X", command); val = rb_hash_aref(hash, rb_str_new2("C")); if (val == Qtrue) sprintf(command, "%s -C", command); if ((val = rb_hash_aref(hash, rb_str_new2("g"))) != Qnil) sprintf(command, "%s -g %d", command, (int) FIX2INT(val)); else sprintf(command, "%s -g 3", command); if ((val = rb_hash_aref(hash, rb_str_new2("B"))) == Qtrue) sprintf(command, "%s -B", command); if ((val = rb_hash_aref(hash, rb_str_new2("E"))) != Qnil) sprintf(command, "%s -E %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("f"))) != Qnil) sprintf(command, "%s -f %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("F"))) != Qnil) sprintf(command, "%s -F %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("h"))) != Qnil) sprintf(command, "%s -h %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("k"))) != Qnil) sprintf(command, "%s -k %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("K"))) != Qnil) sprintf(command, "%s -K %d", command, (int) FIX2INT(val)); if ((val = rb_hash_aref(hash, rb_str_new2("l"))) != Qnil) { if (str_tail_grep(STR2CSTR(val), "xy") || str_tail_grep(STR2CSTR(val), "x/y")) sprintf(command, "%s -l x -l y", command); else sprintf(command, "%s -l %s", command, STR2CSTR(val)); } if ((val = rb_hash_aref(hash, rb_str_new2("L"))) != Qnil) sprintf(command, "%s -L \"%s\"", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("N"))) != Qnil) sprintf(command, "%s -N %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("r"))) != Qnil) sprintf(command, "%s -r %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("R"))) != Qnil) sprintf(command, "%s -R %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("s"))) == Qtrue) sprintf(command, "%s -s", command); if ((val = rb_hash_aref(hash, rb_str_new2("t"))) == Qtrue) sprintf(command, "%s -t", command); if ((val = rb_hash_aref(hash, rb_str_new2("u"))) != Qnil) sprintf(command, "%s -u %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("w"))) != Qnil) sprintf(command, "%s -w %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("x"))) != Qnil) sprintf(command, "%s -x %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("X"))) != Qnil) sprintf(command, "%s -X \"%s\"", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("y"))) != Qnil) sprintf(command, "%s -y %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("Y"))) != Qnil) sprintf(command, "%s -Y \"%s\"", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("bg-color"))) != Qnil) sprintf(command, "%s --bg-color %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("bitmap-size"))) != Qnil) sprintf(command, "%s --bitmap-size %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("frame-color"))) != Qnil) sprintf(command, "%s --frame-color %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("frame-line-width"))) != Qnil) sprintf(command, "%s --frame-line-width %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("max-line-length"))) != Qnil) sprintf(command, "%s --max-line-length %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("page-size"))) != Qnil) sprintf(command, "%s --page-size %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("pen-colors"))) != Qnil) sprintf(command, "%s --pen-colors %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("rotation"))) != Qnil) sprintf(command, "%s --rotation %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("title-font-name"))) != Qnil) sprintf(command, "%s --title-font-name %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("title-font-size"))) != Qnil) sprintf(command, "%s --title-font-size %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("toggle-rotate-y-label"))) == Qtrue) sprintf(command, "%s --toggle-rotate-y-label", command); if ((val = rb_hash_aref(hash, rb_str_new2("m"))) != Qnil) sprintf(command, "%s -m %d", command, (int) FIX2INT(val)); if ((val = rb_hash_aref(hash, rb_str_new2("S"))) != Qnil) sprintf(command, "%s -S %d", command, (int) FIX2INT(val)); if ((val = rb_hash_aref(hash, rb_str_new2("W"))) != Qnil) sprintf(command, "%s -W %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("q"))) != Qnil) sprintf(command, "%s -q %f", command, NUM2DBL(val)); if ((val = rb_hash_aref(hash, rb_str_new2("symbol-font-name"))) != Qnil) sprintf(command, "%s --symbol-font-name %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("reposition"))) != Qnil) sprintf(command, "%s --reposition %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("blankout"))) != Qnil) sprintf(command, "%s --blankout %s", command, STR2CSTR(val)); if ((val = rb_hash_aref(hash, rb_str_new2("O"))) == Qtrue) sprintf(command, "%s -O", command); } static void gsl_graph_init(gsl_graph *g); gsl_graph* gsl_graph_new() { gsl_graph *g = NULL; g = ALLOC(gsl_graph); gsl_graph_init(g); return g; } static void gsl_graph_init(gsl_graph *g) { g->xdata = Qnil; g->ydata = Qnil; g->T = Qnil; g->E = Qnil; g->f = Qnil; g->F = Qnil; g->g = Qnil; g->h = Qnil; g->k = Qnil; g->K = Qnil; g->l = Qnil; g->L = Qnil; g->N = Qnil; g->r = Qnil; g->R = Qnil; g->u = Qnil; g->w = Qnil; g->x = Qnil; g->y = Qnil; g->X = Qnil; g->Y = Qnil; g->bg = Qnil; g->bitmap_size = Qnil; g->frame = Qnil; g->frame_line_width = Qnil; g->max_line_length = Qnil; g->page_size = Qnil; g->pen_colors = Qnil; g->rotation = Qnil; g->title_font_size = Qnil; g->title_font_name = Qnil; g->rotate_y_label = Qfalse; g->I = Qnil; g->m = Qnil; g->S = Qnil; g->W = Qnil; g->q = Qnil; g->symbol_font_name = Qnil; g->reposition = Qnil; g->blankout = Qnil; g->s = Qfalse; g->t = Qfalse; g->B = Qfalse; g->C = Qfalse; g->O = Qfalse; } static void gsl_graph_mark(gsl_graph *g) { rb_gc_mark(g->xdata); rb_gc_mark(g->ydata); rb_gc_mark(g->T); rb_gc_mark(g->E); rb_gc_mark(g->f); rb_gc_mark(g->F); rb_gc_mark(g->g); rb_gc_mark(g->h); rb_gc_mark(g->k); rb_gc_mark(g->K); rb_gc_mark(g->l); rb_gc_mark(g->L); rb_gc_mark(g->N); rb_gc_mark(g->r); rb_gc_mark(g->R); rb_gc_mark(g->s); rb_gc_mark(g->t); rb_gc_mark(g->u); rb_gc_mark(g->w); rb_gc_mark(g->x); rb_gc_mark(g->y); rb_gc_mark(g->X); rb_gc_mark(g->Y); rb_gc_mark(g->bg); rb_gc_mark(g->bitmap_size); rb_gc_mark(g->frame); rb_gc_mark(g->frame_line_width); rb_gc_mark(g->max_line_length); rb_gc_mark(g->page_size); rb_gc_mark(g->pen_colors); rb_gc_mark(g->rotation); rb_gc_mark(g->title_font_name); rb_gc_mark(g->title_font_size); rb_gc_mark(g->rotate_y_label); rb_gc_mark(g->I); rb_gc_mark(g->B); rb_gc_mark(g->m); rb_gc_mark(g->S); rb_gc_mark(g->W); rb_gc_mark(g->q); rb_gc_mark(g->C); rb_gc_mark(g->symbol_font_name); rb_gc_mark(g->reposition); rb_gc_mark(g->blankout); rb_gc_mark(g->O); } void gsl_graph_free(gsl_graph *g) { free((gsl_graph *) g); } static VALUE rb_gsl_graph_set_xdata(VALUE obj, VALUE xx); static VALUE rb_gsl_graph_set_ydata(VALUE obj, VALUE yy); static VALUE rb_gsl_graph_set_xydata(VALUE obj, VALUE xx, VALUE yy); static VALUE rb_gsl_graph_new(int argc, VALUE *argv, VALUE klass) { gsl_graph *g = NULL; VALUE obj; g = gsl_graph_new(); obj = Data_Wrap_Struct(klass, gsl_graph_mark, gsl_graph_free, g); switch (argc) { case 1: rb_gsl_graph_set_xdata(obj, argv[0]); break; case 2: rb_gsl_graph_set_xydata(obj, argv[0], argv[1]); break; } return obj; } static VALUE rb_gsl_graph_init(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); gsl_graph_init(g); return obj; } static VALUE rb_gsl_graph_xdata(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->xdata; } static VALUE rb_gsl_graph_ydata(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->ydata; } static VALUE rb_gsl_graph_xydata(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return rb_ary_new3(2, g->xdata, g->ydata); } static VALUE rb_gsl_graph_set_xdata(VALUE obj, VALUE xx) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); CHECK_VECTOR(xx); g->xdata = xx; return obj; } static VALUE rb_gsl_graph_set_ydata(VALUE obj, VALUE yy) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); CHECK_VECTOR(yy); g->ydata = yy; return obj; } static VALUE rb_gsl_graph_set_xydata(VALUE obj, VALUE xx, VALUE yy) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); CHECK_VECTOR(xx); CHECK_VECTOR(yy); g->xdata = xx; g->ydata = yy; return obj; } static VALUE rb_gsl_graph_set_T(VALUE obj, VALUE T) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); Check_Type(T, T_STRING); g->T = T; return T; } static VALUE rb_gsl_graph_T(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->T; } static VALUE rb_gsl_graph_set_E(VALUE obj, VALUE E) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); Check_Type(E, T_STRING); g->E = E; return E; } static VALUE rb_gsl_graph_E(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->E; } static VALUE rb_gsl_graph_set_f(VALUE obj, VALUE f) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->f = f; return f; } static VALUE rb_gsl_graph_f(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->f; } static VALUE rb_gsl_graph_set_F(VALUE obj, VALUE F) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->F = F; return F; } static VALUE rb_gsl_graph_F(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->F; } static VALUE rb_gsl_graph_set_g(VALUE obj, VALUE gg) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); Check_Type(gg, T_FIXNUM); g->g = gg; return gg; } static VALUE rb_gsl_graph_g(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->g; } static VALUE rb_gsl_graph_set_h(VALUE obj, VALUE h) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->h = h; return h; } static VALUE rb_gsl_graph_h(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->h; } static VALUE rb_gsl_graph_set_k(VALUE obj, VALUE k) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->k = k; return k; } static VALUE rb_gsl_graph_k(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->k; } static VALUE rb_gsl_graph_set_K(VALUE obj, VALUE K) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->K = K; return K; } static VALUE rb_gsl_graph_K(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->K; } static VALUE rb_gsl_graph_set_l(VALUE obj, VALUE l) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->l = l; return l; } static VALUE rb_gsl_graph_l(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->l; } static VALUE rb_gsl_graph_set_L(VALUE obj, VALUE L) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->L = L; return L; } static VALUE rb_gsl_graph_L(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->L; } static VALUE rb_gsl_graph_set_N(VALUE obj, VALUE N) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->N = N; return N; } static VALUE rb_gsl_graph_N(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->N; } static VALUE rb_gsl_graph_set_r(VALUE obj, VALUE r) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->r = r; return r; } static VALUE rb_gsl_graph_r(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->r; } static VALUE rb_gsl_graph_set_R(VALUE obj, VALUE R) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->R = R; return R; } static VALUE rb_gsl_graph_R(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->R; } static VALUE rb_gsl_graph_set_s(VALUE obj, VALUE s) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->s = s; return s; } static VALUE rb_gsl_graph_s(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->s; } static VALUE rb_gsl_graph_set_t(VALUE obj, VALUE t) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->t = t; return t; } static VALUE rb_gsl_graph_t(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->t; } static VALUE rb_gsl_graph_set_u(VALUE obj, VALUE u) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->u = u; return u; } static VALUE rb_gsl_graph_u(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->u; } static VALUE rb_gsl_graph_set_w(VALUE obj, VALUE w) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->w = w; return w; } static VALUE rb_gsl_graph_w(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->w; } static VALUE rb_gsl_graph_set_x(VALUE obj, VALUE x) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->x = x; return x; } static VALUE rb_gsl_graph_x(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->x; } static VALUE rb_gsl_graph_set_y(VALUE obj, VALUE y) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->y = y; return y; } static VALUE rb_gsl_graph_y(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->y; } static VALUE rb_gsl_graph_set_X(VALUE obj, VALUE X) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); Check_Type(X, T_STRING); g->X = X; return X; } static VALUE rb_gsl_graph_set_Y(VALUE obj, VALUE Y) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); Check_Type(Y, T_STRING); g->Y = Y; return Y; } static VALUE rb_gsl_graph_X(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->X; } static VALUE rb_gsl_graph_Y(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->Y; } static VALUE rb_gsl_graph_set_bg(VALUE obj, VALUE bg) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->bg = bg; return bg; } static VALUE rb_gsl_graph_bg(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->bg; } static VALUE rb_gsl_graph_set_bitmap_size(VALUE obj, VALUE bitmap_size) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->bitmap_size = bitmap_size; return bitmap_size; } static VALUE rb_gsl_graph_bitmap_size(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->bitmap_size; } static VALUE rb_gsl_graph_set_frame(VALUE obj, VALUE frame) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->frame = frame; return frame; } static VALUE rb_gsl_graph_frame(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->frame; } static VALUE rb_gsl_graph_set_frame_line_width(VALUE obj, VALUE frame_line_width) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->frame_line_width = frame_line_width; return frame_line_width; } static VALUE rb_gsl_graph_frame_line_width(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->frame_line_width; } static VALUE rb_gsl_graph_set_max_line_length(VALUE obj, VALUE max_line_length) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->max_line_length = max_line_length; return max_line_length; } static VALUE rb_gsl_graph_max_line_length(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->max_line_length; } static VALUE rb_gsl_graph_set_page_size(VALUE obj, VALUE page_size) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->page_size = page_size; return page_size; } static VALUE rb_gsl_graph_page_size(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->page_size; } static VALUE rb_gsl_graph_set_pen_colors(VALUE obj, VALUE pen_colors) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->pen_colors = pen_colors; return pen_colors; } static VALUE rb_gsl_graph_pen_colors(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->pen_colors; } static VALUE rb_gsl_graph_set_rotation(VALUE obj, VALUE rotation) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->rotation = rotation; return rotation; } static VALUE rb_gsl_graph_rotation(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->rotation; } static VALUE rb_gsl_graph_set_title_font_name(VALUE obj, VALUE title_font_name) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->title_font_name = title_font_name; return title_font_name; } static VALUE rb_gsl_graph_title_font_name(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->title_font_name; } static VALUE rb_gsl_graph_set_title_font_size(VALUE obj, VALUE title_font_size) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->title_font_size = title_font_size; return title_font_size; } static VALUE rb_gsl_graph_title_font_size(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->title_font_size; } static VALUE rb_gsl_graph_set_rotate_y_label(VALUE obj, VALUE rotate_y_label) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->rotate_y_label = rotate_y_label; return rotate_y_label; } static VALUE rb_gsl_graph_rotate_y_label(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->rotate_y_label; } static VALUE rb_gsl_graph_set_I(VALUE obj, VALUE I) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->I = I; return I; } static VALUE rb_gsl_graph_I(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->I; } static VALUE rb_gsl_graph_set_B(VALUE obj, VALUE B) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->B = B; return B; } static VALUE rb_gsl_graph_B(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->B; } static VALUE rb_gsl_graph_set_m(VALUE obj, VALUE m) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->m = m; return m; } static VALUE rb_gsl_graph_m(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->m; } static VALUE rb_gsl_graph_set_S(VALUE obj, VALUE S) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->S = S; return S; } static VALUE rb_gsl_graph_S(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->S; } static VALUE rb_gsl_graph_set_W(VALUE obj, VALUE W) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->W = W; return W; } static VALUE rb_gsl_graph_W(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->W; } static VALUE rb_gsl_graph_set_q(VALUE obj, VALUE q) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->q = q; return q; } static VALUE rb_gsl_graph_q(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->q; } static VALUE rb_gsl_graph_set_C(VALUE obj, VALUE C) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->C = C; return C; } static VALUE rb_gsl_graph_C(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->C; } static VALUE rb_gsl_graph_set_symbol_font_name(VALUE obj, VALUE symbol_font_name) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->symbol_font_name = symbol_font_name; return symbol_font_name; } static VALUE rb_gsl_graph_symbol_font_name(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->symbol_font_name; } static VALUE rb_gsl_graph_set_reposition(VALUE obj, VALUE r) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->reposition = r; return r; } static VALUE rb_gsl_graph_reposition(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->reposition; } static VALUE rb_gsl_graph_set_blankout(VALUE obj, VALUE r) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->blankout = r; return r; } static VALUE rb_gsl_graph_blankout(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->blankout; } static VALUE rb_gsl_graph_set_O(VALUE obj, VALUE O) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); g->O = O; return O; } static VALUE rb_gsl_graph_O(VALUE obj) { gsl_graph *g = NULL; Data_Get_Struct(obj, gsl_graph, g); return g->O; } #ifdef HAVE_GNU_GRAPH static void gsl_graph_set_command(gsl_graph *g, char *command) { char str[256]; size_t i, len; VALUE val; strcpy(command, "graph"); if (g->T == Qnil) sprintf(command, "%s -T X", command); else sprintf(command, "%s -T %s", command, STR2CSTR(g->T)); if (TYPE(g->E) == T_STRING) { strcpy(str, STR2CSTR(g->E)); if (strcmp(str, "x") == 0) sprintf(command, "%s -E x", command); else if (strcmp(str, "y") == 0) sprintf(command, "%s -E y", command); else if (strcmp(str, "xy")*strcmp(str, "x/y") == 0) sprintf(command, "%s -E x -E y", command); else rb_raise(rb_eRuntimeError, "unrecognized -E option %s", str); } if (g->f != Qnil) sprintf(command, "%s -f %f", command, NUM2DBL(g->f)); if (TYPE(g->F) == T_STRING) sprintf(command, "%s -F %s", command, STR2CSTR(g->F)); if (TYPE(g->g) == T_FIXNUM) sprintf(command, "%s -g %d", command, (int) FIX2INT(g->g)); if (g->h != Qnil) sprintf(command, "%s -h %f", command, NUM2DBL(g->h)); if (g->k != Qnil) sprintf(command, "%s -k %f", command, NUM2DBL(g->k)); if (TYPE(g->K) == T_FIXNUM) sprintf(command, "%s -K %d", command, (int) FIX2INT(g->K)); if (TYPE(g->l) == T_STRING) { strcpy(str, STR2CSTR(g->l)); if (strcmp(str, "x") == 0) sprintf(command, "%s -l x", command); else if (strcmp(str, "y") == 0) sprintf(command, "%s -l y", command); else if (strcmp(str, "xy")*strcmp(str, "x/y") == 0) sprintf(command, "%s -l x -l y", command); else rb_raise(rb_eRuntimeError, "unrecognized -l option %s", str); } if (TYPE(g->L) == T_STRING) sprintf(command, "%s -L \"%s\"", command, STR2CSTR(g->L)); if (TYPE(g->N) == T_STRING) { strcpy(str, STR2CSTR(g->N)); if (strcmp(str, "x") == 0) sprintf(command, "%s -N x", command); else if (strcmp(str, "y") == 0) sprintf(command, "%s -N y", command); else if (strcmp(str, "xy")*strcmp(str, "x/y") == 0) sprintf(command, "%s -N x -N y", command); else rb_raise(rb_eRuntimeError, "unrecognized -N option %s", str); } if (g->r != Qnil) sprintf(command, "%s -r %f", command, NUM2DBL(g->r)); if (TYPE(g->R) == T_STRING) { strcpy(str, STR2CSTR(g->R)); if (strcmp(str, "x") == 0) sprintf(command, "%s -R x", command); else if (strcmp(str, "y") == 0) sprintf(command, "%s -R y", command); else if (strcmp(str, "xy")*strcmp(str, "x/y") == 0) sprintf(command, "%s -R x -R y", command); else rb_raise(rb_eRuntimeError, "unrecognized -R option %s", str); } if (g->u != Qnil) sprintf(command, "%s -u %f", command, NUM2DBL(g->u)); if (g->w != Qnil) sprintf(command, "%s -w %f", command, NUM2DBL(g->w)); switch (TYPE(g->x)) { case T_STRING: sprintf(command, "%s -x %s", command, STR2CSTR(g->x)); break; case T_ARRAY: sprintf(command, "%s -x", command); // len = RARRAY(g->x)->len; len = RARRAY_LEN(g->x); for (i = 0; i < len; i++) { val = rb_ary_entry(g->x, i); Need_Float(val); sprintf(command, "%s %f", command, NUM2DBL(val)); } break; default: /* do nothing */ break; } switch (TYPE(g->y)) { case T_STRING: sprintf(command, "%s -y %s", command, STR2CSTR(g->y)); break; case T_ARRAY: sprintf(command, "%s -y", command); // len = RARRAY(g->y)->len; len = RARRAY_LEN(g->y); for (i = 0; i < len; i++) { val = rb_ary_entry(g->y, i); Need_Float(val); sprintf(command, "%s %f", command, NUM2DBL(val)); } break; default: /* do nothing */ break; } if (g->X != Qnil) sprintf(command, "%s -X \"%s\"", command, STR2CSTR(g->X)); if (g->Y != Qnil) sprintf(command, "%s -Y \"%s\"", command, STR2CSTR(g->Y)); if (TYPE(g->bg) == T_STRING) sprintf(command, "%s --bg-color %s", command, STR2CSTR(g->bg)); if (TYPE(g->bitmap_size) == T_STRING) sprintf(command, "%s --bitmap-size %s", command, STR2CSTR(g->bitmap_size)); if (TYPE(g->frame) == T_STRING) sprintf(command, "%s --frame-color %s", command, STR2CSTR(g->frame)); if (g->frame_line_width != Qnil) sprintf(command, "%s --frame-line-width %f", command, NUM2DBL(g->frame_line_width)); if (g->max_line_length != Qnil) sprintf(command, "%s --max_line_length %d", command, (int) FIX2INT(g->max_line_length)); if (g->page_size != Qnil) sprintf(command, "%s --page-size %s", command, STR2CSTR(g->page_size)); if (g->pen_colors != Qnil) sprintf(command, "%s --pen-colors %s", command, STR2CSTR(g->pen_colors)); if (g->rotation != Qnil) sprintf(command, "%s --rotation %d", command, (int) FIX2INT(g->rotation)); if (g->title_font_name != Qnil) sprintf(command, "%s --title-font-name %s", command, STR2CSTR(g->title_font_name)); if (g->title_font_size != Qnil) sprintf(command, "%s --title-font-size %f", command, NUM2DBL(g->title_font_size)); if (g->rotate_y_label == Qtrue) sprintf(command, "%s --toggle-rotate-y-label", command); if (g->I != Qnil) sprintf(command, "%s -I %s", command, STR2CSTR(g->I)); if (g->s == Qtrue) sprintf(command, "%s -s", command); if (g->t == Qtrue) sprintf(command, "%s -t", command); if (g->B == Qtrue) sprintf(command, "%s -B", command); if (g->m != Qnil) sprintf(command, "%s -m %d", command, (int) FIX2INT(g->m)); switch (TYPE(g->S)) { case T_STRING: sprintf(command, "%s -S %s", command, STR2CSTR(g->S)); break; case T_ARRAY: // if (RARRAY(g->S)->len == 2) if (RARRAY_LEN(g->S) == 2) sprintf(command, "%s -S %d %f", command, (int) FIX2INT(rb_ary_entry(g->S, 0)), NUM2DBL(rb_ary_entry(g->S, 1))); break; default: /* do nothing */ break; } if (g->W != Qnil) sprintf(command, "%s -W %f", command, NUM2DBL(g->W)); if (g->q != Qnil) sprintf(command, "%s -q %f", command, NUM2DBL(g->q)); if (g->C == Qtrue) sprintf(command, "%s -C", command); if (g->symbol_font_name != Qnil) sprintf(command, "%s --symbol_font_name %s", command, STR2CSTR(g->symbol_font_name)); switch (TYPE(g->reposition)) { case T_STRING: sprintf(command, "%s --reposition %s", command, STR2CSTR(g->reposition)); break; case T_ARRAY: sprintf(command, "%s --reposition", command); // len = RARRAY(g->reposition)->len; len = RARRAY_LEN(g->reposition); for (i = 0; i reposition, i); Need_Float(val); sprintf(command, "%s %f", command, NUM2DBL(val)); } break; default: /* do nothing */ break; } if (g->blankout != Qnil) sprintf(command, "%s --blankout %f", command, NUM2DBL(g->blankout)); if (g->O == Qtrue) sprintf(command, "%s -O", command); } #endif static VALUE rb_gsl_graph_graph(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH gsl_graph *g = NULL; gsl_histogram *h = NULL; gsl_vector *x = NULL, *y = NULL; size_t i, size; FILE *fp; char command[1024]; Data_Get_Struct(obj, gsl_graph, g); gsl_graph_set_command(g, command); switch (argc) { case 3: Check_Type(argv[2], T_STRING); sprintf(command, "%s %s", command, STR2CSTR(argv[2])); /* no break */ case 2: if (TYPE(argv[1]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[1])); } else if (VECTOR_P(argv[1])) { g->ydata = argv[1]; } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or String expected)", rb_class2name(CLASS_OF(argv[1]))); } /* no break */ case 1: if (TYPE(argv[0]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[0])); } else if (VECTOR_P(argv[0])) { g->xdata = argv[0]; } else if (HISTOGRAM_P(argv[0])) { Data_Get_Struct(argv[0], gsl_histogram, h); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or String expected)", rb_class2name(CLASS_OF(argv[0]))); } break; default: rb_raise(rb_eArgError, "wrong number of argumeuts (%d for 1-3)", argc); break; } if (VECTOR_P(g->xdata)) Data_Get_Struct(g->xdata, gsl_vector, x); if (VECTOR_P(g->ydata)) Data_Get_Struct(g->ydata, gsl_vector, y); if (x == NULL && h == NULL) rb_raise(rb_eRuntimeError, "data is not given"); if (h) size = h->n; else size = x->size; fp = popen(command, "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); for (i = 0; i < size; i++) { if (h) fprintf(fp, "%g %g\n%g %g\n", h->range[i], h->bin[i], h->range[i+1], h->bin[i]); else if (y == NULL) fprintf(fp, "%d %g\n", (int) i, gsl_vector_get(x, i)); else fprintf(fp, "%g %g\n", gsl_vector_get(x, i), gsl_vector_get(y, i)); } fflush(fp); pclose(fp); fp = NULL; return Qtrue; #else rb_raise(rb_eNoMethodError, "GNU plotutils required"); return Qfalse; #endif } static VALUE rb_gsl_graph_step(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH gsl_graph *g = NULL; gsl_vector *x = NULL, *y = NULL; size_t i, size; FILE *fp; char command[1024]; Data_Get_Struct(obj, gsl_graph, g); gsl_graph_set_command(g, command); switch (argc) { case 3: Check_Type(argv[2], T_STRING); sprintf(command, "%s %s", command, STR2CSTR(argv[2])); /* no break */ case 2: if (TYPE(argv[1]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[1])); } else if (VECTOR_P(argv[1])) { g->ydata = argv[1]; } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or String expected)", rb_class2name(CLASS_OF(argv[1]))); } /* no break */ case 1: if (TYPE(argv[0]) == T_STRING) { sprintf(command, "%s %s", command, STR2CSTR(argv[0])); } else if (VECTOR_P(argv[0])) { g->xdata = argv[0]; } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or String expected)", rb_class2name(CLASS_OF(argv[0]))); } break; default: rb_raise(rb_eArgError, "wrong number of argumeuts (%d for 1-3)", argc); break; } if (VECTOR_P(g->xdata)) Data_Get_Struct(g->xdata, gsl_vector, x); if (VECTOR_P(g->ydata)) Data_Get_Struct(g->ydata, gsl_vector, y); if (x == NULL) rb_raise(rb_eRuntimeError, "data is not given"); size = x->size; fp = popen(command, "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); for (i = 0; i < size; i++) { if (y == NULL) { fprintf(fp, "%d %g\n%d %g\n", (int) i, gsl_vector_get(x, i), (int) (i+1), gsl_vector_get(x, i)); } else { if (i != size-1) fprintf(fp, "%g %g\n%g %g\n", gsl_vector_get(x, i), gsl_vector_get(y, i), gsl_vector_get(x, i+1), gsl_vector_get(y, i)); else fprintf(fp, "%g %g\n%g %g", gsl_vector_get(x, i), gsl_vector_get(y, i), 2.0*gsl_vector_get(x, i)-gsl_vector_get(x, i-1), gsl_vector_get(y, i)); } } fflush(fp); pclose(fp); fp = NULL; return Qtrue; #else rb_raise(rb_eNoMethodError, "GNU plotutils required"); return Qfalse; #endif } void Init_gsl_graph(VALUE module) { VALUE cgsl_graph; cgsl_graph = rb_define_class_under(module, "Graph", cGSL_Object); rb_define_singleton_method(cgsl_graph, "new", rb_gsl_graph_new, -1); rb_define_singleton_method(cgsl_graph, "alloc", rb_gsl_graph_new, -1); /*****/ rb_define_method(cgsl_graph, "init", rb_gsl_graph_init, 0); rb_define_method(cgsl_graph, "set_xdata", rb_gsl_graph_set_xdata, 1); rb_define_method(cgsl_graph, "set_ydata", rb_gsl_graph_set_ydata, 1); rb_define_method(cgsl_graph, "set_xydata", rb_gsl_graph_set_xydata, 2); rb_define_method(cgsl_graph, "xdata", rb_gsl_graph_xdata, 0); rb_define_method(cgsl_graph, "ydata", rb_gsl_graph_ydata, 0); rb_define_method(cgsl_graph, "xydata", rb_gsl_graph_xydata, 0); rb_define_method(cgsl_graph, "graph", rb_gsl_graph_graph, -1); rb_define_alias(cgsl_graph, "draw", "graph"); rb_define_alias(cgsl_graph, "plot", "graph"); rb_define_method(cgsl_graph, "graph_step", rb_gsl_graph_step, -1); rb_define_alias(cgsl_graph, "step", "graph_step"); /*****/ rb_define_method(cgsl_graph, "set_T", rb_gsl_graph_set_T, 1); rb_define_alias(cgsl_graph, "T=", "set_T"); rb_define_alias(cgsl_graph, "display_type=", "set_T"); rb_define_method(cgsl_graph, "T", rb_gsl_graph_T, 0); rb_define_alias(cgsl_graph, "display_type", "T"); rb_define_method(cgsl_graph, "set_E", rb_gsl_graph_set_E, 1); rb_define_alias(cgsl_graph, "E=", "set_E"); rb_define_alias(cgsl_graph, "axis_end=", "set_E"); rb_define_alias(cgsl_graph, "toggle_axis_end=", "set_E"); rb_define_method(cgsl_graph, "E", rb_gsl_graph_E, 0); rb_define_alias(cgsl_graph, "axis_end", "E"); rb_define_alias(cgsl_graph, "toggle_axis_end", "E"); rb_define_method(cgsl_graph, "set_f", rb_gsl_graph_set_f, 1); rb_define_alias(cgsl_graph, "f=", "set_f"); rb_define_alias(cgsl_graph, "font_size=", "set_f"); rb_define_method(cgsl_graph, "f", rb_gsl_graph_f, 0); rb_define_alias(cgsl_graph, "font_size", "f"); rb_define_method(cgsl_graph, "set_F", rb_gsl_graph_set_F, 1); rb_define_alias(cgsl_graph, "F=", "set_F"); rb_define_alias(cgsl_graph, "font_name=", "set_F"); rb_define_method(cgsl_graph, "F", rb_gsl_graph_F, 0); rb_define_alias(cgsl_graph, "font_name", "F"); rb_define_method(cgsl_graph, "set_g", rb_gsl_graph_set_g, 1); rb_define_alias(cgsl_graph, "g=", "set_g"); rb_define_alias(cgsl_graph, "grid_style=", "set_g"); rb_define_method(cgsl_graph, "g", rb_gsl_graph_g, 0); rb_define_alias(cgsl_graph, "grid_style", "g"); rb_define_method(cgsl_graph, "set_h", rb_gsl_graph_set_h, 1); rb_define_alias(cgsl_graph, "h=", "set_h"); rb_define_alias(cgsl_graph, "height=", "set_h"); rb_define_alias(cgsl_graph, "height_of_plot=", "set_h"); rb_define_method(cgsl_graph, "h", rb_gsl_graph_h, 0); rb_define_alias(cgsl_graph, "height", "h"); rb_define_alias(cgsl_graph, "height_of_plot", "h"); rb_define_method(cgsl_graph, "set_k", rb_gsl_graph_set_k, 1); rb_define_alias(cgsl_graph, "k=", "set_k"); rb_define_alias(cgsl_graph, "tick_size=", "set_k"); rb_define_method(cgsl_graph, "k", rb_gsl_graph_k, 0); rb_define_alias(cgsl_graph, "tick_size", "k"); rb_define_method(cgsl_graph, "set_K", rb_gsl_graph_set_K, 1); rb_define_alias(cgsl_graph, "K=", "set_K"); rb_define_alias(cgsl_graph, "clip_mode=", "set_K"); rb_define_method(cgsl_graph, "K", rb_gsl_graph_K, 0); rb_define_alias(cgsl_graph, "clip_mode", "K"); rb_define_method(cgsl_graph, "set_l", rb_gsl_graph_set_l, 1); rb_define_alias(cgsl_graph, "l=", "set_l"); rb_define_alias(cgsl_graph, "log_axis=", "set_l"); rb_define_alias(cgsl_graph, "toggle_log_axis=", "set_l"); rb_define_method(cgsl_graph, "l", rb_gsl_graph_l, 0); rb_define_alias(cgsl_graph, "log_axis", "l"); rb_define_alias(cgsl_graph, "toggle_log_axis", "l"); rb_define_method(cgsl_graph, "set_L", rb_gsl_graph_set_L, 1); rb_define_alias(cgsl_graph, "L=", "set_L"); rb_define_alias(cgsl_graph, "top_label=", "set_L"); rb_define_method(cgsl_graph, "L", rb_gsl_graph_L, 0); rb_define_alias(cgsl_graph, "top_label", "L"); rb_define_method(cgsl_graph, "set_N", rb_gsl_graph_set_N, 1); rb_define_alias(cgsl_graph, "N=", "set_N"); rb_define_alias(cgsl_graph, "no_tics=", "set_N"); rb_define_alias(cgsl_graph, "toggle_no_tics=", "set_N"); rb_define_method(cgsl_graph, "N", rb_gsl_graph_N, 0); rb_define_alias(cgsl_graph, "no_tics", "N"); rb_define_alias(cgsl_graph, "toggle_no_tics", "N"); rb_define_method(cgsl_graph, "set_r", rb_gsl_graph_set_r, 1); rb_define_alias(cgsl_graph, "r=", "set_r"); rb_define_alias(cgsl_graph, "right_shift=", "set_r"); rb_define_method(cgsl_graph, "r", rb_gsl_graph_r, 0); rb_define_alias(cgsl_graph, "right_shift", "r"); rb_define_method(cgsl_graph, "set_R", rb_gsl_graph_set_R, 1); rb_define_alias(cgsl_graph, "R=", "set_R"); rb_define_alias(cgsl_graph, "round-to-next-tick=", "set_R"); rb_define_alias(cgsl_graph, "toggle_round-to-next-tick=", "set_R"); rb_define_method(cgsl_graph, "R", rb_gsl_graph_R, 0); rb_define_alias(cgsl_graph, "round-to-next-tick", "R"); rb_define_alias(cgsl_graph, "toggle_round-to-next-tick", "R"); rb_define_method(cgsl_graph, "set_s", rb_gsl_graph_set_s, 1); rb_define_alias(cgsl_graph, "s=", "set_s"); rb_define_alias(cgsl_graph, "save_screen=", "set_s"); rb_define_method(cgsl_graph, "s", rb_gsl_graph_s, 0); rb_define_alias(cgsl_graph, "save_screen", "s"); rb_define_method(cgsl_graph, "set_t", rb_gsl_graph_set_t, 1); rb_define_alias(cgsl_graph, "t=", "set_t"); rb_define_alias(cgsl_graph, "transpose_axes=", "set_t"); rb_define_alias(cgsl_graph, "toggle_transpose_axes=", "set_t"); rb_define_method(cgsl_graph, "t", rb_gsl_graph_t, 0); rb_define_alias(cgsl_graph, "transpose_axes", "t"); rb_define_alias(cgsl_graph, "toggle_transpose_axes", "t"); rb_define_method(cgsl_graph, "set_u", rb_gsl_graph_set_u, 1); rb_define_alias(cgsl_graph, "u=", "set_u"); rb_define_alias(cgsl_graph, "upward_shift=", "set_u"); rb_define_method(cgsl_graph, "u", rb_gsl_graph_u, 0); rb_define_alias(cgsl_graph, "upward_shift", "u"); rb_define_method(cgsl_graph, "set_w", rb_gsl_graph_set_w, 1); rb_define_alias(cgsl_graph, "w=", "set_w"); rb_define_alias(cgsl_graph, "width=", "set_w"); rb_define_alias(cgsl_graph, "width_of_plot=", "set_w"); rb_define_method(cgsl_graph, "w", rb_gsl_graph_w, 0); rb_define_alias(cgsl_graph, "width", "w"); rb_define_alias(cgsl_graph, "width_of_plot", "w"); rb_define_method(cgsl_graph, "set_x", rb_gsl_graph_set_x, 1); rb_define_alias(cgsl_graph, "x=", "set_x"); rb_define_alias(cgsl_graph, "x_limits=", "set_x"); rb_define_method(cgsl_graph, "x", rb_gsl_graph_x, 0); rb_define_alias(cgsl_graph, "x_limits", "x"); rb_define_method(cgsl_graph, "set_y", rb_gsl_graph_set_y, 1); rb_define_alias(cgsl_graph, "y=", "set_y"); rb_define_alias(cgsl_graph, "y_limits=", "set_y"); rb_define_method(cgsl_graph, "y", rb_gsl_graph_y, 0); rb_define_alias(cgsl_graph, "y_limits", "y"); rb_define_method(cgsl_graph, "set_X", rb_gsl_graph_set_X, 1); rb_define_alias(cgsl_graph, "X=", "set_X"); rb_define_alias(cgsl_graph, "x_label=", "set_X"); rb_define_method(cgsl_graph, "X", rb_gsl_graph_X, 0); rb_define_alias(cgsl_graph, "x_label", "X"); rb_define_method(cgsl_graph, "set_Y", rb_gsl_graph_set_Y, 1); rb_define_alias(cgsl_graph, "Y=", "set_Y"); rb_define_alias(cgsl_graph, "y_label=", "set_Y"); rb_define_method(cgsl_graph, "Y", rb_gsl_graph_Y, 0); rb_define_alias(cgsl_graph, "y_label", "Y"); rb_define_method(cgsl_graph, "set_bg", rb_gsl_graph_set_bg, 1); rb_define_alias(cgsl_graph, "bg=", "set_bg"); rb_define_alias(cgsl_graph, "bg_color=", "set_bg"); rb_define_alias(cgsl_graph, "set_bg_color", "set_bg"); rb_define_method(cgsl_graph, "bg", rb_gsl_graph_bg, 0); rb_define_alias(cgsl_graph, "bg_color", "bg"); rb_define_method(cgsl_graph, "set_bitmap_size", rb_gsl_graph_set_bitmap_size, 1); rb_define_alias(cgsl_graph, "bitmap_size=", "set_bitmap_size"); rb_define_alias(cgsl_graph, "set_bitmap_size", "set_bitmap_size"); rb_define_method(cgsl_graph, "bitmap_size", rb_gsl_graph_bitmap_size, 0); rb_define_method(cgsl_graph, "set_frame", rb_gsl_graph_set_frame, 1); rb_define_alias(cgsl_graph, "frame=", "set_frame"); rb_define_alias(cgsl_graph, "frame_color=", "set_frame"); rb_define_alias(cgsl_graph, "set_frame_color", "set_frame"); rb_define_method(cgsl_graph, "frame", rb_gsl_graph_frame, 0); rb_define_alias(cgsl_graph, "frame_color", "frame"); rb_define_method(cgsl_graph, "set_frame_line_width", rb_gsl_graph_set_frame_line_width, 1); rb_define_alias(cgsl_graph, "frame_line_width=", "set_frame_line_width"); rb_define_method(cgsl_graph, "frame_line_width", rb_gsl_graph_frame_line_width, 0); rb_define_method(cgsl_graph, "set_max_line_length", rb_gsl_graph_set_max_line_length, 1); rb_define_alias(cgsl_graph, "max_line_length=", "set_max_line_length"); rb_define_method(cgsl_graph, "max_line_length", rb_gsl_graph_max_line_length, 0); rb_define_method(cgsl_graph, "set_page_size", rb_gsl_graph_set_page_size, 1); rb_define_alias(cgsl_graph, "page_size=", "set_page_size"); rb_define_method(cgsl_graph, "page_size", rb_gsl_graph_page_size, 0); rb_define_method(cgsl_graph, "set_pen_colors", rb_gsl_graph_set_pen_colors, 1); rb_define_alias(cgsl_graph, "pen_colors=", "set_pen_colors"); rb_define_alias(cgsl_graph, "pen=", "set_pen_colors"); rb_define_method(cgsl_graph, "pen_colors", rb_gsl_graph_pen_colors, 0); rb_define_alias(cgsl_graph, "pen", "pen_colors"); rb_define_method(cgsl_graph, "set_rotation", rb_gsl_graph_set_rotation, 1); rb_define_alias(cgsl_graph, "rotation=", "set_rotation"); rb_define_method(cgsl_graph, "rotation", rb_gsl_graph_rotation, 0); rb_define_method(cgsl_graph, "set_title_font_name", rb_gsl_graph_set_title_font_name, 1); rb_define_alias(cgsl_graph, "title_font_name=", "set_title_font_name"); rb_define_method(cgsl_graph, "title_font_name", rb_gsl_graph_title_font_name, 0); rb_define_method(cgsl_graph, "set_title_font_size", rb_gsl_graph_set_title_font_size, 1); rb_define_alias(cgsl_graph, "title_font_size=", "set_title_font_size"); rb_define_method(cgsl_graph, "title_font_size", rb_gsl_graph_title_font_size, 0); rb_define_method(cgsl_graph, "set_rotate_y_label", rb_gsl_graph_set_rotate_y_label, 1); rb_define_alias(cgsl_graph, "rotate_y_label=", "set_rotate_y_label"); rb_define_alias(cgsl_graph, "toggle_rotate_y_label=", "set_rotate_y_label"); rb_define_method(cgsl_graph, "rotate_y_label", rb_gsl_graph_rotate_y_label, 0); rb_define_alias(cgsl_graph, "toggle_rotate_y_label", "rotate_y_label"); rb_define_method(cgsl_graph, "set_B", rb_gsl_graph_set_B, 1); rb_define_alias(cgsl_graph, "B=", "set_B"); rb_define_alias(cgsl_graph, "auto_dump=", "set_B"); rb_define_alias(cgsl_graph, "toggle_auto_dump=", "set_B"); rb_define_method(cgsl_graph, "B", rb_gsl_graph_B, 0); rb_define_alias(cgsl_graph, "auto_dump", "B"); rb_define_alias(cgsl_graph, "toggle_auto_dump", "B"); rb_define_method(cgsl_graph, "set_I", rb_gsl_graph_set_I, 1); rb_define_alias(cgsl_graph, "I=", "set_I"); rb_define_alias(cgsl_graph, "input_format=", "set_I"); rb_define_method(cgsl_graph, "I", rb_gsl_graph_I, 0); rb_define_alias(cgsl_graph, "input_format", "I"); rb_define_method(cgsl_graph, "set_m", rb_gsl_graph_set_m, 1); rb_define_alias(cgsl_graph, "m=", "set_m"); rb_define_alias(cgsl_graph, "line_mode=", "set_m"); rb_define_method(cgsl_graph, "m", rb_gsl_graph_m, 0); rb_define_alias(cgsl_graph, "line_mode", "m"); rb_define_method(cgsl_graph, "set_S", rb_gsl_graph_set_S, 1); rb_define_alias(cgsl_graph, "S=", "set_S"); rb_define_alias(cgsl_graph, "symbol=", "set_S"); rb_define_method(cgsl_graph, "S", rb_gsl_graph_S, 0); rb_define_alias(cgsl_graph, "symbol", "S"); rb_define_method(cgsl_graph, "set_W", rb_gsl_graph_set_W, 1); rb_define_alias(cgsl_graph, "W=", "set_W"); rb_define_alias(cgsl_graph, "line_width=", "set_W"); rb_define_method(cgsl_graph, "W", rb_gsl_graph_W, 0); rb_define_alias(cgsl_graph, "line_width", "W"); rb_define_method(cgsl_graph, "set_q", rb_gsl_graph_set_q, 1); rb_define_alias(cgsl_graph, "q=", "set_q"); rb_define_alias(cgsl_graph, "fill_fraction=", "set_q"); rb_define_method(cgsl_graph, "q", rb_gsl_graph_q, 0); rb_define_alias(cgsl_graph, "fill_fraction", "q"); rb_define_method(cgsl_graph, "set_C", rb_gsl_graph_set_C, 1); rb_define_alias(cgsl_graph, "C=", "set_C"); rb_define_alias(cgsl_graph, "use_color=", "set_C"); rb_define_alias(cgsl_graph, "toggle_use_color=", "set_C"); rb_define_method(cgsl_graph, "C", rb_gsl_graph_C, 0); rb_define_alias(cgsl_graph, "use_color", "C"); rb_define_alias(cgsl_graph, "toggle_use_color", "C"); rb_define_method(cgsl_graph, "set_symbol_font_name", rb_gsl_graph_set_symbol_font_name, 1); rb_define_alias(cgsl_graph, "symbol_font_name=", "set_symbol_font_name"); rb_define_method(cgsl_graph, "symbol_font_name", rb_gsl_graph_symbol_font_name, 0); rb_define_method(cgsl_graph, "set_reposition", rb_gsl_graph_set_reposition, 1); rb_define_alias(cgsl_graph, "reposition=", "set_reposition"); rb_define_method(cgsl_graph, "reposition", rb_gsl_graph_reposition, 0); rb_define_method(cgsl_graph, "set_blankout", rb_gsl_graph_set_blankout, 1); rb_define_alias(cgsl_graph, "blankout=", "set_blankout"); rb_define_method(cgsl_graph, "blankout", rb_gsl_graph_blankout, 0); rb_define_method(cgsl_graph, "set_O", rb_gsl_graph_set_O, 1); rb_define_alias(cgsl_graph, "O=", "set_O"); rb_define_alias(cgsl_graph, "portable_output=", "set_O"); rb_define_method(cgsl_graph, "O", rb_gsl_graph_O, 0); rb_define_alias(cgsl_graph, "portable_output", "O"); } gsl-1.15.3/ext/matrix_int.c0000644000175000017500000001657512220252463015102 0ustar boutilboutil/* matrix_int.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_complex.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif int gsl_linalg_matmult_int(const gsl_matrix_int *A, const gsl_matrix_int *B, gsl_matrix_int *C); VALUE rb_gsl_matrix_to_i(VALUE obj); static VALUE rb_gsl_matrix_int_to_i(VALUE obj) { return obj; } VALUE rb_gsl_matrix_int_to_f(VALUE obj) { gsl_matrix_int *m; gsl_matrix *mnew; size_t i, j; Data_Get_Struct(obj, gsl_matrix_int, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (double) gsl_matrix_int_get(m, i, j)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } static VALUE rb_gsl_matrix_int_to_complex(VALUE obj) { gsl_matrix_int *m; gsl_matrix_complex *mnew; gsl_complex z; size_t i, j; Data_Get_Struct(obj, gsl_matrix_int, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { GSL_SET_REAL(&z, (double) gsl_matrix_int_get(m, i, j)); GSL_SET_IMAG(&z, 0.0); gsl_matrix_complex_set(mnew, i, j, z); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } static VALUE rb_gsl_matrix_int_coerce(VALUE obj, VALUE other) { return rb_ary_new3(2, other, rb_gsl_matrix_int_to_f(obj)); } enum { GSL_MATRIX_INT_ADD, GSL_MATRIX_INT_SUB, GSL_MATRIX_INT_MUL, GSL_MATRIX_INT_DIV, }; static VALUE rb_gsl_matrix_int_operation1(VALUE obj, VALUE other, int flag) { gsl_matrix_int *a, *anew, *b; gsl_vector_int *vi, *vinew; double bval; // local variable "result" declared and set, but never used //int result; Data_Get_Struct(obj, gsl_matrix_int, a); switch (TYPE(other)) { case T_FIXNUM: case T_FLOAT: bval = NUM2INT(other); anew = make_matrix_int_clone(a); switch (flag) { case GSL_MATRIX_INT_ADD: /*result =*/ gsl_matrix_int_add_constant(anew, bval); break; case GSL_MATRIX_INT_SUB: /*result =*/ gsl_matrix_int_add_constant(anew, -bval); break; case GSL_MATRIX_INT_MUL: /*result =*/ gsl_matrix_int_scale(anew, bval); break; case GSL_MATRIX_INT_DIV: /*result =*/ gsl_matrix_int_scale(anew, 1.0/bval); break; default: break; } break; default: if (MATRIX_P(other)) other = rb_gsl_matrix_to_i(other); if (VECTOR_P(other)) other = rb_gsl_vector_to_i(other); if (MATRIX_INT_P(other)) { anew = make_matrix_int_clone(a); Data_Get_Struct(other, gsl_matrix_int, b); switch (flag) { case GSL_MATRIX_INT_ADD: /*result =*/ gsl_matrix_int_add(anew, b); break; case GSL_MATRIX_INT_SUB: /*result =*/ gsl_matrix_int_sub(anew, b); break; case GSL_MATRIX_INT_MUL: /*result =*/ gsl_matrix_int_mul_elements(anew, b); break; case GSL_MATRIX_INT_DIV: /*result =*/ gsl_matrix_int_div_elements(anew, b); break; default: break; } } else if (VECTOR_INT_COL_P(other)) { switch (flag) { case GSL_MATRIX_INT_MUL: Data_Get_Struct(other, gsl_vector_int, vi); vinew = gsl_vector_int_alloc(vi->size); gsl_matrix_int_mul_vector(vinew, a, vi); return Data_Wrap_Struct(cgsl_vector_int_col, 0, gsl_vector_int_free, vinew); break; default: rb_raise(rb_eRuntimeError, "Operation not defined"); } } else { rb_raise(rb_eTypeError, "Operation not defined with %s", rb_class2name(CLASS_OF(other))); } break; } return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, anew); } static VALUE rb_gsl_matrix_int_add(VALUE obj, VALUE other) { return rb_gsl_matrix_int_operation1(obj, other, GSL_MATRIX_INT_ADD); } static VALUE rb_gsl_matrix_int_sub(VALUE obj, VALUE other) { return rb_gsl_matrix_int_operation1(obj, other, GSL_MATRIX_INT_SUB); } static VALUE rb_gsl_matrix_int_mul(VALUE obj, VALUE other) { return rb_gsl_matrix_int_operation1(obj, other, GSL_MATRIX_INT_MUL); } static VALUE rb_gsl_matrix_int_div(VALUE obj, VALUE other) { return rb_gsl_matrix_int_operation1(obj, other, GSL_MATRIX_INT_DIV); } static VALUE rb_gsl_matrix_int_matrix_mul(VALUE obj, VALUE bb) { gsl_matrix_int *m = NULL, *b = NULL, *mnew = NULL; gsl_vector_int *vi, *vinew; Data_Get_Struct(obj, gsl_matrix_int, m); if (MATRIX_INT_P(bb)) { Data_Get_Struct(bb, gsl_matrix_int, b); mnew = gsl_matrix_int_alloc(m->size1, b->size2); gsl_linalg_matmult_int(m, b, mnew); return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, mnew); } else { if (VECTOR_INT_COL_P(bb)) { Data_Get_Struct(bb, gsl_vector_int, vi); vinew = gsl_vector_int_alloc(vi->size); gsl_matrix_int_mul_vector(vinew, m, vi); return Data_Wrap_Struct(cgsl_vector_int_col, 0, gsl_vector_int_free, vinew); } switch (TYPE(bb)) { case T_FIXNUM: return rb_gsl_matrix_int_mul(obj, bb); /* return rb_gsl_matrix_int_power(obj, bb);*/ break; default: rb_raise(rb_eTypeError, "wrong argument type %s (Matrix::Int, Vector::Int::Col or Fixnum expected)", rb_class2name(CLASS_OF(bb))); break; } } } int gsl_linalg_matmult_int(const gsl_matrix_int *A, const gsl_matrix_int *B, gsl_matrix_int *C) { if (A->size2 != B->size1 || A->size1 != C->size1 || B->size2 != C->size2) { GSL_ERROR ("matrix sizes are not conformant", GSL_EBADLEN); } else { int a, b; int temp; size_t i, j, k; for (i = 0; i < C->size1; i++) { for (j = 0; j < C->size2; j++) { a = gsl_matrix_int_get(A, i, 0); b = gsl_matrix_int_get(B, 0, j); temp = a * b; for (k = 1; k < A->size2; k++) { a = gsl_matrix_int_get(A, i, k); b = gsl_matrix_int_get(B, k, j); temp += a * b; } gsl_matrix_int_set(C, i, j, temp); } } return GSL_SUCCESS; } } void Init_gsl_matrix_int_init(VALUE module); void Init_gsl_matrix_int(VALUE module) { Init_gsl_matrix_int_init(module); /*****/ rb_define_method(cgsl_matrix_int, "to_f", rb_gsl_matrix_int_to_f, 0); rb_define_method(cgsl_matrix_int, "to_i", rb_gsl_matrix_int_to_i, 0); rb_define_method(cgsl_matrix_int, "to_complex", rb_gsl_matrix_int_to_complex, 0); /*****/ rb_define_method(cgsl_matrix_int, "coerce", rb_gsl_matrix_int_coerce, 1); /*****/ rb_define_method(cgsl_matrix_int, "add", rb_gsl_matrix_int_add, 1); rb_define_alias(cgsl_matrix_int, "+", "add"); rb_define_method(cgsl_matrix_int, "sub", rb_gsl_matrix_int_sub, 1); rb_define_alias(cgsl_matrix_int, "-", "sub"); rb_define_method(cgsl_matrix_int, "mul", rb_gsl_matrix_int_mul, 1); /* rb_define_alias(cgsl_matrix_int, "*", "mul");*/ rb_define_method(cgsl_matrix_int, "div", rb_gsl_matrix_int_div, 1); rb_define_alias(cgsl_matrix_int, "/", "div"); rb_define_method(cgsl_matrix_int, "matrix_mul", rb_gsl_matrix_int_matrix_mul, 1); rb_define_alias(cgsl_matrix_int, "*", "matrix_mul"); /*****/ } gsl-1.15.3/ext/extconf.rb0000644000175000017500000001774012220252463014546 0ustar boutilboutilrequire 'mkmf' module GSL class Version def initialize(str) @str = str @ary = str.split(".").collect { |elm| elm.to_i } end def to_s; @str; end def inspect; @str; end def >=(ver) ary2 = ver.split(".").collect { |elm| elm.to_i } if @ary[0] > ary2[0]; return true; end if @ary[0] < ary2[0]; return false; end if @ary[1] > ary2[1]; return true; end if @ary[1] < ary2[1]; return false; end if @ary.size < ary2.size; return false; end if @ary.size == 3 and ary2.size == 3 if @ary[2] < ary2[2]; return false; end end return true end def <(ver) ary2 = ver.split(".").collect { |elm| elm.to_i } if @ary[0] >= ary2[0]; return false; end if @ary[0] >= ary2[0]; return false; end return true end end end if /mingw/ =~ RUBY_PLATFORM GSL_CONFIG = "sh gsl-config" else GSL_CONFIG = "gsl-config" end def gsl_config() print("checking gsl cflags... ") IO.popen("#{GSL_CONFIG} --cflags") do |f| cflags = f.gets.chomp puts(cflags) $CFLAGS += " " + cflags end IO.popen("#{GSL_CONFIG} --libs") do |f| libs = f.gets.chomp dir_config("cblas") dir_config("atlas") if have_library("cblas") and have_library("atlas") libs.gsub!("-lgslcblas", "-lcblas -latlas") $LOCAL_LIBS += " " + libs.gsub(" -lgslcblas", "") print("checking gsl libs... ") puts(libs) else print("checking gsl libs... ") puts(libs) $LOCAL_LIBS += " " + libs end end end def check_version(configfile) print("checking gsl version... ") IO.popen("#{GSL_CONFIG} --version") do |f| ver = GSL::Version.new(f.gets.chomp) puts(ver) configfile.printf("#ifndef GSL_VERSION\n#define GSL_VERSION \"#{ver}\"\n#endif\n") if ver >= "0.9.4" configfile.printf("#ifndef GSL_0_9_4_LATER\n#define GSL_0_9_4_LATER\n#endif\n") else configfile.close raise("Ruby/GSL requires gsl-0.9.4 or later.") end if ver >= "1.0" configfile.printf("#ifndef GSL_1_0_LATER\n#define GSL_1_0_LATER\n#endif\n") end if ver >= "1.1" configfile.printf("#ifndef GSL_1_1_LATER\n#define GSL_1_1_LATER\n#endif\n") end if ver >= "1.1.1" configfile.printf("#ifndef GSL_1_1_1_LATER\n#define GSL_1_1_1_LATER\n#endif\n") end if ver >= "1.2" configfile.printf("#ifndef GSL_1_2_LATER\n#define GSL_1_2_LATER\n#endif\n") end if ver >= "1.3" configfile.printf("#ifndef GSL_1_3_LATER\n#define GSL_1_3_LATER\n#endif\n") end if ver >= "1.4" configfile.printf("#ifndef GSL_1_4_LATER\n#define GSL_1_4_LATER\n#endif\n") end if ver >= "1.4.90" configfile.printf("#ifndef GSL_1_4_9_LATER\n#define GSL_1_4_9_LATER\n#endif\n") end if ver >= "1.5.90" configfile.printf("#ifndef GSL_1_6_LATER\n#define GSL_1_6_LATER\n#endif\n") end if ver >= "1.7.90" configfile.printf("#ifndef GSL_1_8_LATER\n#define GSL_1_8_LATER\n#endif\n") end if ver >= "1.8.90" configfile.printf("#ifndef GSL_1_9_LATER\n#define GSL_1_9_LATER\n#endif\n") end if ver >= "1.9.90" configfile.printf("#ifndef GSL_1_10_LATER\n#define GSL_1_10_LATER\n#endif\n") end if ver < "1.4" configfile.printf("#ifndef GSL_CONST_OLD\n#define GSL_CONST_OLD\n#endif\n") end if ver >= "1.11" configfile.printf("#ifndef GSL_1_11_LATER\n#define GSL_1_11_LATER\n#endif\n") end if ver >= "1.12.90" configfile.printf("#ifndef GSL_1_13_LATER\n#define GSL_1_13_LATER\n#endif\n") end if ver >= "1.14" configfile.printf("#ifndef GSL_1_14_LATER\n#define GSL_1_14_LATER\n#endif\n") end if ver >= "1.15" configfile.printf("#ifndef GSL_1_15_LATER\n#define GSL_1_15_LATER\n#endif\n") end end end ##### $CFLAGS ||= '' $CFLAGS += " -Wall -I../include " begin RB_GSL_CONFIG = File.open("../include/rb_gsl_config.h", "w") RB_GSL_CONFIG.printf("#ifndef ___RB_GSL_CONFIG_H___\n") RB_GSL_CONFIG.printf("#define ___RB_GSL_CONFIG_H___\n\n") check_version(RB_GSL_CONFIG) gsl_config() have_func("round") # Check GSL extensions if have_header("rngextra/rngextra.h") have_library("rngextra") end if have_header("qrngextra/qrngextra.h") have_library("qrngextra") end if have_header("ool/ool_version.h") have_library("ool") end if have_header("tensor/tensor.h") have_library("tensor") end if have_header("jacobi.h") have_library("jacobi") end if have_header("gsl/gsl_cqp.h") have_library("cqp") end if have_header("gsl/gsl_multimin_fsdf.h") have_library("bundle_method") end if have_library("gsl", "gsl_poly_solve_quartic") RB_GSL_CONFIG.printf("#ifndef HAVE_POLY_SOLVE_QUARTIC\n#define HAVE_POLY_SOLVE_QUARTIC\n#endif\n") end if have_library("gsl", "gsl_eigen_francis") RB_GSL_CONFIG.printf("#ifndef HAVE_EIGEN_FRANCIS\n#define HAVE_EIGEN_FRANCIS\n#endif\n") end if have_header("ndlinear/gsl_multifit_ndlinear.h") have_library("ndlinear") end # Added 2009/Apr/20 if have_header("alf/alf.h") have_library("alf") end begin print("checking rb-gsl version...") IO.popen("cat ../VERSION") do |f| ver = GSL::Version.new(f.gets.chomp) puts(ver) RB_GSL_CONFIG.printf("#ifndef RUBY_GSL_VERSION\n#define RUBY_GSL_VERSION \"#{ver}\"\n#endif\n") end end RUBY_VERSION2 = GSL::Version.new(RUBY_VERSION) puts("checking ruby version... #{RUBY_VERSION2}") if RUBY_VERSION2 >= "1.8" RB_GSL_CONFIG.printf("#ifndef RUBY_1_8_LATER\n#define RUBY_1_8_LATER\n#endif\n") if find_executable("graph") RB_GSL_CONFIG.printf("#ifndef HAVE_GNU_GRAPH\n#define HAVE_GNU_GRAPH\n#endif\n") end else path = (path || ENV['PATH']).split(File::PATH_SEPARATOR) flag = 0 print("checking for GNU graph... ") path.each do |dir| if File.executable?(file = File.join(dir, "graph")) puts("yes") RB_GSL_CONFIG.printf("#ifndef HAVE_GNU_GRAPH\n#define HAVE_GNU_GRAPH\n#endif\n") flag = 1 break end end puts("no") if flag == 0 end if RUBY_VERSION2 >= "1.9" RB_GSL_CONFIG.printf("#ifndef RUBY_1_9_LATER\n#define RUBY_1_9_LATER\n#endif\n") # Added 2010/Sep/29 if RUBY_VERSION2 >= "1.9.2" RB_GSL_CONFIG.printf("#ifndef RUBY_1_9_2_LATER\n#define RUBY_1_9_2_LATER\n#endif\n") end end RB_GSL_CONFIG.printf("\n#endif\n") RB_GSL_CONFIG.close rescue raise("Check GSL>=0.9.4 is installed, and the command \"gsl-config\" is in search path.") end #narray_config = dir_config("narray") narray_config = dir_config('narray',$sitearchdir,$sitearchdir) # Try to find narray with RubyGems begin require 'rubygems' na_gemspec=Gem::Specification.find_by_path('narray.h') if na_gemspec narray_config = File.join(na_gemspec.full_gem_path, na_gemspec.require_path) $CPPFLAGS = " -I#{narray_config} "+$CPPFLAGS end rescue LoadError end have_narray_h = have_header("narray.h") if narray_config if RUBY_PLATFORM =~ /cygwin|mingw/ # have_library("narray") || raise("ERROR: narray import library is not found") have_library("narray") end end tamu_anova_config = dir_config('tamu_anova',$sitearchdir,$sitearchdir) have_tamu_anova_h = have_header("tamu_anova/tamu_anova.h") if tamu_anova_config have_library("tamuanova") # if RUBY_PLATFORM =~ /cygwin|mingw/ # have_library("tamuanova") || raise("ERROR: tamu_anova import library is not found") # end end File.open("../lib/gsl.rb", "w") do |file| if have_narray_h file.print("require('narray')\n") end # file.print("require('rb_gsl')\ninclude GSL\n") file.print("require('rb_gsl')\n") file.print("require('gsl/oper.rb')\n") end File.open("../lib/rbgsl.rb", "w") do |file| if have_narray_h file.print("require('narray')\n") end file.print("require('rb_gsl')\n") file.print("require('gsl/oper.rb')\n") end srcs = Dir.glob("*.c") - ["vector_source.c", "matrix_source.c", "tensor_source.c", "poly_source.c", "block_source.c"] $objs = srcs.collect { |f| f.sub(".c", ".o") } create_makefile("rb_gsl") gsl-1.15.3/ext/deriv.c0000644000175000017500000001316012220252463014020 0ustar boutilboutil/* deriv.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #ifdef GSL_1_4_9_LATER #include "rb_gsl_common.h" #include "rb_gsl_function.h" #include #include #define RB_GSL_DERIV_H_DEFAULT (1e-8) #ifdef HAVE_NARRAY_H #include "narray.h" #endif static int get_func2(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx, VALUE *hh) { switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc == 3) { CHECK_FUNCTION(argv[0]); Need_Float(argv[2]); *ff = argv[0]; *xx = argv[1]; *hh = argv[2]; } else if (argc == 2) { CHECK_FUNCTION(argv[0]); *ff = argv[0]; *xx = argv[1]; *hh = rb_float_new(RB_GSL_DERIV_H_DEFAULT); } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); } break; default: if (argc == 2) { Need_Float(argv[1]); *ff = obj; *xx = argv[0]; *hh = argv[1]; } else if (argc == 1) { *ff = obj; *xx = argv[0]; *hh = rb_float_new(RB_GSL_DERIV_H_DEFAULT); } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } break; } return 0; } #ifdef RB_GSL_DERIV_H_DEFAULT #undef RB_GSL_DERIV_H_DEFAULT #endif static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh, int (*deriv)(const gsl_function *, double, double, double *, double *)) { gsl_function *f = NULL; double result, abserr, h; VALUE x, ary, aerr; gsl_vector *v = NULL, *vnew = NULL, *verr = NULL; gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL; size_t n, i, j; int status; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2, *ptr3; VALUE ary2, ary3; #endif Need_Float(hh); Data_Get_Struct(obj, gsl_function, f); h = NUM2DBL(hh); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: status = (*deriv)(f, NUM2DBL(xx), h, &result, &abserr); return rb_ary_new3(3, rb_float_new(result), rb_float_new(abserr), INT2FIX(status)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); aerr = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); (*deriv)(f, NUM2DBL(x), h, &result, &abserr); rb_ary_store(ary, i, rb_float_new(result)); rb_ary_store(aerr, i, rb_float_new(abserr)); } return rb_ary_new3(2, ary, aerr); break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); n = na->total; ptr1 = (double*) na->ptr; ary2 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ary3 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary2, double*); ptr3 = NA_PTR_TYPE(ary3, double*); for (i = 0; i < n; i++) { (*deriv)(f, ptr1[i], h, &result, &abserr); ptr2[i] = result; ptr3[i] = abserr; } return rb_ary_new3(2, ary2, ary3); } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); verr = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { (*deriv)(f, gsl_vector_get(v, i), h, &result, &abserr); gsl_vector_set(vnew, i, result); gsl_vector_set(verr, i, abserr); } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr)); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); merr = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { (*deriv)(f, gsl_matrix_get(m, i, j), h, &result, &abserr); gsl_matrix_set(mnew, i, j, result); gsl_matrix_set(merr, i, j, abserr); } } return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew), Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr)); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_deriv_central(int argc, VALUE *argv, VALUE obj) { VALUE ff, xx, hh; get_func2(argc, argv, obj, &ff, &xx, &hh); return rb_gsl_deriv_eval(ff, xx, hh, gsl_deriv_central); } static VALUE rb_gsl_deriv_forward(int argc, VALUE *argv, VALUE obj) { VALUE ff, xx, hh; get_func2(argc, argv, obj, &ff, &xx, &hh); return rb_gsl_deriv_eval(ff, xx, hh, gsl_deriv_forward); } static VALUE rb_gsl_deriv_backward(int argc, VALUE *argv, VALUE obj) { VALUE ff, xx, hh; get_func2(argc, argv, obj, &ff, &xx, &hh); return rb_gsl_deriv_eval(ff, xx, hh, gsl_deriv_backward); } void Init_gsl_deriv(VALUE module) { VALUE mgsl_deriv; mgsl_deriv = rb_define_module_under(module, "Deriv"); rb_define_method(cgsl_function, "deriv_central", rb_gsl_deriv_central, -1); rb_define_method(cgsl_function, "deriv_forward", rb_gsl_deriv_forward, -1); rb_define_method(cgsl_function, "deriv_backward", rb_gsl_deriv_backward, -1); rb_define_singleton_method(mgsl_deriv, "central", rb_gsl_deriv_central, -1); rb_define_singleton_method(mgsl_deriv, "forward", rb_gsl_deriv_forward, -1); rb_define_singleton_method(mgsl_deriv, "backward", rb_gsl_deriv_backward, -1); } #endif gsl-1.15.3/ext/ntuple.c0000644000175000017500000003314112220252463014217 0ustar boutilboutil/* ntuple.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #include "rb_gsl_histogram.h" #include static VALUE cgsl_ntuple; static VALUE cgsl_ntuple_select_fn; static VALUE cgsl_ntuple_value_fn; static VALUE rb_gsl_ntuple_new(int argc, VALUE *argv, VALUE klass) { gsl_vector *v = NULL; gsl_matrix *m = NULL; gsl_ntuple *n = NULL; double *data = NULL; size_t size; switch (argc) { case 2: case 3: if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[1], gsl_vector, v); data = v->data; size = v->size; } else if (MATRIX_P(argv[1])) { Data_Get_Struct(argv[1], gsl_matrix, m); data = m->data; size = m->size1*m->size2; } else { rb_raise(rb_eTypeError, "Vector or Matrix expected"); } if (argc == 3) size = FIX2INT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } n = gsl_ntuple_create(STR2CSTR(argv[0]), data, size*sizeof(double)); return Data_Wrap_Struct(klass, 0, gsl_ntuple_close, n); } VALUE rb_gsl_ntuple_open(int argc, VALUE *argv, VALUE klass) { gsl_vector *v = NULL; gsl_matrix *m = NULL; gsl_ntuple *n = NULL; double *data = NULL; size_t size; switch (argc) { case 2: case 3: if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[1], gsl_vector, v); data = v->data; size = v->size; } else if (MATRIX_P(argv[1])) { Data_Get_Struct(argv[1], gsl_matrix, m); data = m->data; size = m->size1*m->size2; } else { rb_raise(rb_eTypeError, "Vector or Matrix expected"); } if (argc == 3) size = FIX2INT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } n = gsl_ntuple_open(STR2CSTR(argv[0]), data, size*sizeof(double)); return Data_Wrap_Struct(klass, 0, gsl_ntuple_close, n); } VALUE rb_gsl_ntuple_write(VALUE obj) { gsl_ntuple *n = NULL; Data_Get_Struct(obj, gsl_ntuple, n); gsl_ntuple_write(n); return obj; } VALUE rb_gsl_ntuple_bookdata(VALUE obj) { gsl_ntuple *n = NULL; Data_Get_Struct(obj, gsl_ntuple, n); gsl_ntuple_bookdata(n); return obj; } VALUE rb_gsl_ntuple_read(VALUE obj) { gsl_ntuple *n = NULL; Data_Get_Struct(obj, gsl_ntuple, n); gsl_ntuple_read(n); return obj; } VALUE rb_gsl_ntuple_close(VALUE klass, VALUE obj) { gsl_ntuple *n = NULL; Data_Get_Struct(obj, gsl_ntuple, n); gsl_ntuple_close(n); return Qnil; } VALUE rb_gsl_ntuple_size(VALUE klass, VALUE obj) { gsl_ntuple *n = NULL; Data_Get_Struct(obj, gsl_ntuple, n); return INT2FIX(n->size); } VALUE rb_gsl_ntuple_data(VALUE obj) { gsl_ntuple *n = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_ntuple, n); v = gsl_vector_view_alloc(); v->vector.size = n->size; v->vector.data = n->ntuple_data; return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, v); } /***** select_fn *****/ static gsl_ntuple_select_fn* gsl_ntuple_select_fn_alloc(); static void gsl_ntuple_select_fn_free(gsl_ntuple_select_fn *ptr); int rb_gsl_ntuple_select_fn_f(void *data, void *p); static void gsl_ntuple_select_fn_mark(gsl_ntuple_select_fn *ptr); static gsl_ntuple_select_fn* gsl_ntuple_select_fn_alloc() { gsl_ntuple_select_fn *ptr = NULL; ptr = ALLOC(gsl_ntuple_select_fn); if (ptr == NULL) rb_raise(rb_eRuntimeError, "malloc failed"); ptr->function = &rb_gsl_ntuple_select_fn_f; /* (VALUE) ptr->params = rb_ary_new2(3);*/ ptr->params = (void *) rb_ary_new2(3); rb_ary_store((VALUE) ptr->params, 1, Qnil); return ptr; } static void gsl_ntuple_select_fn_free(gsl_ntuple_select_fn *ptr) { free((gsl_ntuple_select_fn *) ptr); } static void gsl_ntuple_select_fn_mark(gsl_ntuple_select_fn *ptr) { rb_gc_mark((VALUE) ptr->params); } static VALUE rb_gsl_ntuple_select_fn_set_f(int argc, VALUE *argv, VALUE obj) { gsl_ntuple_select_fn *F = NULL; VALUE ary, ary2; size_t i; Data_Get_Struct(obj, gsl_ntuple_select_fn, F); if (F->params == NULL) { ary = rb_ary_new2(3); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 1, Qnil); switch (argc) { case 0: break; case 1: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); break; case 2: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); break; default: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); ary2 = rb_ary_new2(argc-1); for (i = 1; i < argc; i++) rb_ary_store(ary2, i-1, argv[i]); rb_ary_store(ary, 1, ary2); break; } if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); return obj; } int rb_gsl_ntuple_select_fn_f(void *data, void *p) { VALUE result, ary, proc, params, vv; gsl_vector_view vtmp; size_t size; ary = (VALUE) p; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); size = FIX2INT(rb_ary_entry(ary, 2)); vtmp.vector.data = (double *) data; vtmp.vector.size = size; vtmp.vector.stride = 1; vv = Data_Wrap_Struct(cgsl_vector_view, 0, NULL, &vtmp); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, vv); else result = rb_funcall(proc, RBGSL_ID_call, 2, vv, params); return FIX2INT(result); } static VALUE rb_gsl_ntuple_select_fn_params(VALUE obj) { gsl_ntuple_select_fn *F = NULL; Data_Get_Struct(obj, gsl_ntuple_select_fn, F); return rb_ary_entry((VALUE) F->params, 1); } static VALUE rb_gsl_ntuple_select_fn_set_params(int argc, VALUE *argv, VALUE obj) { gsl_ntuple_select_fn *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_ntuple_select_fn, F); ary = (VALUE) F->params; if (argc == 1) { rb_ary_store(ary, 1, argv[0]); } else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 1, ary2); } return obj; } static VALUE rb_gsl_ntuple_select_fn_new(int argc, VALUE *argv, VALUE klass) { gsl_ntuple_select_fn *F = NULL; VALUE ff; F = gsl_ntuple_select_fn_alloc(); ff = Data_Wrap_Struct(klass, gsl_ntuple_select_fn_mark, gsl_ntuple_select_fn_free, F); rb_gsl_ntuple_select_fn_set_f(argc, argv, ff); return ff; } /***** value_fn *****/ static gsl_ntuple_value_fn* gsl_ntuple_value_fn_alloc(); static void gsl_ntuple_value_fn_free(gsl_ntuple_value_fn *ptr); static double rb_gsl_ntuple_value_fn_f(void *data, void *p); static void gsl_ntuple_value_fn_mark(gsl_ntuple_value_fn *ptr); static gsl_ntuple_value_fn* gsl_ntuple_value_fn_alloc() { gsl_ntuple_value_fn *ptr = NULL; ptr = ALLOC(gsl_ntuple_value_fn); if (ptr == NULL) rb_raise(rb_eRuntimeError, "malloc failed"); ptr->function = &rb_gsl_ntuple_value_fn_f; /* (VALUE) ptr->params = rb_ary_new2(3);*/ ptr->params = (void *) rb_ary_new2(3); rb_ary_store((VALUE) ptr->params, 1, Qnil); return ptr; } static void gsl_ntuple_value_fn_mark(gsl_ntuple_value_fn *ptr) { rb_gc_mark((VALUE) ptr->params); } static void gsl_ntuple_value_fn_free(gsl_ntuple_value_fn *ptr) { free((gsl_ntuple_value_fn *) ptr); } static VALUE rb_gsl_ntuple_value_fn_set_f(int argc, VALUE *argv, VALUE obj) { gsl_ntuple_value_fn *F = NULL; VALUE ary, ary2; size_t i; Data_Get_Struct(obj, gsl_ntuple_value_fn, F); if (F->params == NULL) { ary = rb_ary_new2(3); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 1, Qnil); switch (argc) { case 0: break; case 1: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); break; case 2: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); break; default: CHECK_PROC(argv[0]); rb_ary_store(ary, 0, argv[0]); ary2 = rb_ary_new2(argc-1); for (i = 1; i < argc; i++) rb_ary_store(ary2, i-1, argv[i]); rb_ary_store(ary, 1, ary2); break; } if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); return obj; } static double rb_gsl_ntuple_value_fn_f(void *data, void *p) { VALUE result, ary, proc, params, vv; gsl_vector_view vtmp; ary = (VALUE) p; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); vtmp.vector.data = (double *) data; vtmp.vector.size = FIX2INT(rb_ary_entry(ary, 2)); vtmp.vector.stride = 1; vv = Data_Wrap_Struct(cgsl_vector_view, 0, NULL, &vtmp); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, vv); else result = rb_funcall(proc, RBGSL_ID_call, 2, vv, params); return NUM2DBL(result); } static VALUE rb_gsl_ntuple_value_fn_params(VALUE obj) { gsl_ntuple_value_fn *F = NULL; Data_Get_Struct(obj, gsl_ntuple_value_fn, F); return rb_ary_entry((VALUE) F->params, 1); } static VALUE rb_gsl_ntuple_value_fn_set_params(int argc, VALUE *argv, VALUE obj) { gsl_ntuple_value_fn *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_ntuple_value_fn, F); ary = (VALUE) F->params; if (argc == 1) { rb_ary_store(ary, 1, argv[0]); } else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 1, ary2); } return obj; } static VALUE rb_gsl_ntuple_value_fn_new(int argc, VALUE *argv, VALUE klass) { gsl_ntuple_value_fn *F = NULL; VALUE ff; F = gsl_ntuple_value_fn_alloc(); ff = Data_Wrap_Struct(klass, gsl_ntuple_value_fn_mark, gsl_ntuple_value_fn_free, F); rb_gsl_ntuple_value_fn_set_f(argc, argv, ff); return ff; } /* singleton method */ static VALUE rb_gsl_ntuple_project(VALUE obj, VALUE hh, VALUE nn, VALUE vvfn, VALUE vsfn) { gsl_histogram *h = NULL; gsl_ntuple *n = NULL; gsl_ntuple_value_fn *vfn = NULL; gsl_ntuple_select_fn *sfn = NULL; int status; size_t size; if (!rb_obj_is_kind_of(hh, cgsl_histogram)) rb_raise(rb_eTypeError, "argument 1: Histogram expected"); Data_Get_Struct(hh, gsl_histogram, h); if (!rb_obj_is_kind_of(nn, cgsl_ntuple)) rb_raise(rb_eTypeError, "argument 2: Ntuple expected"); Data_Get_Struct(nn, gsl_ntuple, n); if (!rb_obj_is_kind_of(vvfn, cgsl_ntuple_value_fn)) rb_raise(rb_eTypeError, "argument 3: Ntuple::ValueFn expected"); Data_Get_Struct(vvfn, gsl_ntuple_value_fn, vfn); if (!rb_obj_is_kind_of(vsfn, cgsl_ntuple_select_fn)) rb_raise(rb_eTypeError, "argument 4: Ntuple::SelectFn expected"); Data_Get_Struct(vsfn, gsl_ntuple_select_fn, sfn); size = n->size/sizeof(double); rb_ary_store((VALUE) vfn->params, 2, INT2FIX(size)); rb_ary_store((VALUE) sfn->params, 2, INT2FIX(size)); status = gsl_ntuple_project(h, n, vfn, sfn); return INT2FIX(status); } /* method */ static VALUE rb_gsl_ntuple_project2(VALUE obj, VALUE hh, VALUE vvfn, VALUE vsfn) { gsl_histogram *h = NULL; gsl_ntuple *n = NULL; gsl_ntuple_value_fn *vfn = NULL; gsl_ntuple_select_fn *sfn = NULL; int status; size_t size; CHECK_HISTOGRAM(hh); Data_Get_Struct(obj, gsl_ntuple, n); Data_Get_Struct(hh, gsl_histogram, h); if (!rb_obj_is_kind_of(vvfn, cgsl_ntuple_value_fn)) rb_raise(rb_eTypeError, "argument 2: Ntuple::ValueFn expected"); Data_Get_Struct(vvfn, gsl_ntuple_value_fn, vfn); if (!rb_obj_is_kind_of(vsfn, cgsl_ntuple_select_fn)) rb_raise(rb_eTypeError, "argument 3: Ntuple::SelectFn expected"); Data_Get_Struct(vsfn, gsl_ntuple_select_fn, sfn); size = n->size/sizeof(double); rb_ary_store((VALUE) vfn->params, 2, INT2FIX(size)); rb_ary_store((VALUE) sfn->params, 2, INT2FIX(size)); status = gsl_ntuple_project(h, n, vfn, sfn); return INT2FIX(status); } void Init_gsl_ntuple(VALUE module) { cgsl_ntuple = rb_define_class_under(module, "Ntuple", cGSL_Object); cgsl_ntuple_select_fn = rb_define_class_under(cgsl_ntuple, "SelectFn", cGSL_Object); cgsl_ntuple_value_fn = rb_define_class_under(cgsl_ntuple, "ValueFn", cGSL_Object); rb_define_singleton_method(cgsl_ntuple, "create", rb_gsl_ntuple_new, -1); rb_define_singleton_method(cgsl_ntuple, "alloc", rb_gsl_ntuple_new, -1); rb_define_singleton_method(cgsl_ntuple, "open", rb_gsl_ntuple_open, -1); rb_define_singleton_method(cgsl_ntuple, "close", rb_gsl_ntuple_close, 0); rb_define_method(cgsl_ntuple, "size", rb_gsl_ntuple_size, 0); rb_define_method(cgsl_ntuple, "write", rb_gsl_ntuple_write, 0); rb_define_method(cgsl_ntuple, "bookdata", rb_gsl_ntuple_bookdata, 0); rb_define_method(cgsl_ntuple, "read", rb_gsl_ntuple_read, 0); rb_define_method(cgsl_ntuple, "data", rb_gsl_ntuple_data, 0); rb_define_alias(cgsl_ntuple, "get_data", "data"); rb_define_alias(cgsl_ntuple, "ntuple_data", "data"); rb_define_singleton_method(cgsl_ntuple_select_fn, "alloc", rb_gsl_ntuple_select_fn_new, -1); rb_define_method(cgsl_ntuple_select_fn, "set", rb_gsl_ntuple_select_fn_set_f, -1); rb_define_method(cgsl_ntuple_select_fn, "set_params", rb_gsl_ntuple_select_fn_set_params, -1); rb_define_method(cgsl_ntuple_select_fn, "params", rb_gsl_ntuple_select_fn_params, 0); rb_define_singleton_method(cgsl_ntuple_value_fn, "alloc", rb_gsl_ntuple_value_fn_new, -1); rb_define_method(cgsl_ntuple_value_fn, "set", rb_gsl_ntuple_value_fn_set_f, -1); rb_define_method(cgsl_ntuple_value_fn, "set_params", rb_gsl_ntuple_value_fn_set_params, -1); rb_define_method(cgsl_ntuple_value_fn, "params", rb_gsl_ntuple_value_fn_params, 0); rb_define_singleton_method(cgsl_ntuple, "project", rb_gsl_ntuple_project, 4); rb_define_method(cgsl_ntuple, "project", rb_gsl_ntuple_project2, 3); } gsl-1.15.3/ext/sf_transport.c0000644000175000017500000000522012220252463015431 0ustar boutilboutil/* sf_transport.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_transport_2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_transport_2, x); } static VALUE rb_gsl_sf_transport_2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_transport_2_e, x); } static VALUE rb_gsl_sf_transport_3(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_transport_3, x); } static VALUE rb_gsl_sf_transport_3_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_transport_3_e, x); } static VALUE rb_gsl_sf_transport_4(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_transport_4, x); } static VALUE rb_gsl_sf_transport_4_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_transport_4_e, x); } static VALUE rb_gsl_sf_transport_5(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_transport_5, x); } static VALUE rb_gsl_sf_transport_5_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_transport_5_e, x); } void Init_gsl_sf_transport(VALUE module) { VALUE mgsl_sf_trans; rb_define_module_function(module, "transport_2", rb_gsl_sf_transport_2, 1); rb_define_module_function(module, "transport_2_e", rb_gsl_sf_transport_2_e, 1); rb_define_module_function(module, "transport_3", rb_gsl_sf_transport_3, 1); rb_define_module_function(module, "transport_3_e", rb_gsl_sf_transport_3_e, 1); rb_define_module_function(module, "transport_4", rb_gsl_sf_transport_4, 1); rb_define_module_function(module, "transport_4_e", rb_gsl_sf_transport_4_e, 1); rb_define_module_function(module, "transport_5", rb_gsl_sf_transport_5, 1); rb_define_module_function(module, "transport_5_e", rb_gsl_sf_transport_5_e, 1); mgsl_sf_trans = rb_define_module_under(module, "Transport"); rb_define_module_function(mgsl_sf_trans, "two", rb_gsl_sf_transport_2, 1); rb_define_module_function(mgsl_sf_trans, "two_e", rb_gsl_sf_transport_2_e, 1); rb_define_module_function(mgsl_sf_trans, "three", rb_gsl_sf_transport_3, 1); rb_define_module_function(mgsl_sf_trans, "three_e", rb_gsl_sf_transport_3_e, 1); rb_define_module_function(mgsl_sf_trans, "four", rb_gsl_sf_transport_4, 1); rb_define_module_function(mgsl_sf_trans, "four_e", rb_gsl_sf_transport_4_e, 1); rb_define_module_function(mgsl_sf_trans, "five", rb_gsl_sf_transport_5, 1); rb_define_module_function(mgsl_sf_trans, "fine_e", rb_gsl_sf_transport_5_e, 1); } gsl-1.15.3/ext/sf_gegenbauer.c0000644000175000017500000000735112220252463015510 0ustar boutilboutil/* sf_gegenbauer.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_gegenpoly_1(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_gegenpoly_1, lambda, x); } static VALUE rb_gsl_sf_gegenpoly_1_e(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_gegenpoly_1_e, lambda, x); } static VALUE rb_gsl_sf_gegenpoly_2(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_gegenpoly_2, lambda, x); } static VALUE rb_gsl_sf_gegenpoly_2_e(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_gegenpoly_2_e, lambda, x); } static VALUE rb_gsl_sf_gegenpoly_3(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_gegenpoly_3, lambda, x); } static VALUE rb_gsl_sf_gegenpoly_3_e(VALUE obj, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_gegenpoly_3_e, lambda, x); } static VALUE rb_gsl_sf_gegenpoly_n(VALUE obj, VALUE n, VALUE lambda, VALUE x) { return rb_gsl_sf_eval_int_double_double(gsl_sf_gegenpoly_n, n, lambda, x); } static VALUE rb_gsl_sf_gegenpoly_n_e(VALUE obj, VALUE n, VALUE lambda, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(n); Need_Float(lambda); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_gegenpoly_n_e(FIX2INT(n), NUM2DBL(lambda), NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_gegenpoly_array(VALUE obj, VALUE nmax, VALUE lambda, VALUE x) { gsl_vector *v = NULL; CHECK_FIXNUM(nmax); Need_Float(lambda); Need_Float(x); v = gsl_vector_alloc(nmax); gsl_sf_gegenpoly_array(FIX2INT(nmax), NUM2DBL(lambda), NUM2DBL(x), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } void Init_gsl_sf_gegenbauer(VALUE module) { VALUE mgsl_sf_gegenpoly; rb_define_module_function(module, "gegenpoly_1", rb_gsl_sf_gegenpoly_1, 2); rb_define_module_function(module, "gegenpoly_1_e", rb_gsl_sf_gegenpoly_1_e, 2); rb_define_module_function(module, "gegenpoly_2", rb_gsl_sf_gegenpoly_2, 2); rb_define_module_function(module, "gegenpoly_2_e", rb_gsl_sf_gegenpoly_2_e, 2); rb_define_module_function(module, "gegenpoly_3", rb_gsl_sf_gegenpoly_3, 2); rb_define_module_function(module, "gegenpoly_3_e", rb_gsl_sf_gegenpoly_3_e, 2); rb_define_module_function(module, "gegenpoly_n", rb_gsl_sf_gegenpoly_n, 3); rb_define_module_function(module, "gegenpoly_n_e", rb_gsl_sf_gegenpoly_n_e, 3); rb_define_module_function(module, "gegenpoly_array", rb_gsl_sf_gegenpoly_array, 3); mgsl_sf_gegenpoly = rb_define_module_under(module, "Gegenpoly"); rb_define_module_function(mgsl_sf_gegenpoly, "one", rb_gsl_sf_gegenpoly_1, 2); rb_define_module_function(mgsl_sf_gegenpoly, "one_e", rb_gsl_sf_gegenpoly_1_e, 2); rb_define_module_function(mgsl_sf_gegenpoly, "two", rb_gsl_sf_gegenpoly_2, 2); rb_define_module_function(mgsl_sf_gegenpoly, "two_e", rb_gsl_sf_gegenpoly_2_e, 2); rb_define_module_function(mgsl_sf_gegenpoly, "three", rb_gsl_sf_gegenpoly_3, 2); rb_define_module_function(mgsl_sf_gegenpoly, "three_e", rb_gsl_sf_gegenpoly_3_e, 2); rb_define_module_function(mgsl_sf_gegenpoly, "n", rb_gsl_sf_gegenpoly_n, 3); rb_define_module_function(mgsl_sf_gegenpoly, "n_e", rb_gsl_sf_gegenpoly_n_e, 3); rb_define_module_function(mgsl_sf_gegenpoly, "array", rb_gsl_sf_gegenpoly_array, 3); } gsl-1.15.3/ext/spline.c0000644000175000017500000002621312220252463014204 0ustar boutilboutil/* spline.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_interp.h" EXTERN VALUE cgsl_interp_accel; /* defined in interp.c */ static void rb_gsl_spline_free(rb_gsl_spline *sp); static VALUE rb_gsl_spline_new(int argc, VALUE *argv, VALUE klass) { rb_gsl_spline *sp = NULL; const gsl_interp_type *T = NULL; double *ptrx = NULL, *ptry = NULL; size_t sizex = 0, sizey = 0, size = 0, stride = 1; int i; for (i = 0; i < argc; i++) { switch (TYPE(argv[i])) { case T_STRING: T = get_interp_type(argv[i]); break; case T_FIXNUM: if (T) size = FIX2INT(argv[i]); else T = get_interp_type(argv[i]); break; default: if (ptrx == NULL) { ptrx = get_vector_ptr(argv[i], &stride, &sizex); } else { ptry = get_vector_ptr(argv[i], &stride, &sizey); size = GSL_MIN_INT(sizex, sizey); } break; } } if (size == 0) rb_raise(rb_eRuntimeError, "spline size is not given."); sp = ALLOC(rb_gsl_spline); if (T == NULL) T = gsl_interp_cspline; sp->s = gsl_spline_alloc(T, size); sp->a = gsl_interp_accel_alloc(); if (ptrx && ptry) gsl_spline_init(sp->s, ptrx, ptry, size); return Data_Wrap_Struct(klass, 0, rb_gsl_spline_free, sp); } static void rb_gsl_spline_free(rb_gsl_spline *sp) { gsl_spline_free(sp->s); gsl_interp_accel_free(sp->a); free((rb_gsl_spline *) sp); } static VALUE rb_gsl_spline_init(VALUE obj, VALUE xxa, VALUE yya) { rb_gsl_spline *sp = NULL; gsl_spline *p = NULL; gsl_vector *xa = NULL, *ya = NULL; size_t i, size; int flagx = 0, flagy = 0; double *ptr1 = NULL, *ptr2 = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *nax = NULL, *nay = NULL; #endif Data_Get_Struct(obj, rb_gsl_spline, sp); p = sp->s; if (TYPE(xxa) == T_ARRAY) { // size = RARRAY(xxa)->len; size = RARRAY_LEN(xxa); xa = gsl_vector_alloc(size); for (i = 0; i < size; i++) gsl_vector_set(xa, i, NUM2DBL(rb_ary_entry(xxa, i))); ptr1 = xa->data; flagx = 1; } else if (VECTOR_P(xxa)) { Data_Get_Struct(xxa, gsl_vector, xa); size = xa->size; ptr1 = xa->data; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(xxa)) { GetNArray(xxa, nax); size = nax->total; ptr1 = (double *) nax->ptr; #endif } else { rb_raise(rb_eTypeError, "not a vector"); } if (TYPE(yya) == T_ARRAY) { ya = gsl_vector_alloc(size); for (i = 0; i < size; i++) gsl_vector_set(ya, i, NUM2DBL(rb_ary_entry(yya, i))); ptr2 = ya->data; flagy = 1; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(yya)) { GetNArray(yya, nay); ptr2 = (double *) nay->ptr; #endif } else if (VECTOR_P(yya)) { Data_Get_Struct(yya, gsl_vector, ya); ptr2 = ya->data; } else { rb_raise(rb_eTypeError, "not a vector"); } gsl_spline_init(p, ptr1, ptr2, size); if (flagx == 1) gsl_vector_free(xa); if (flagy == 1) gsl_vector_free(ya); return obj; } static VALUE rb_gsl_spline_accel(VALUE obj) { rb_gsl_spline *rgi = NULL; Data_Get_Struct(obj, rb_gsl_spline, rgi); return Data_Wrap_Struct(cgsl_interp_accel, 0, NULL, rgi->a); } static VALUE rb_gsl_spline_evaluate(VALUE obj, VALUE xx, double (*eval)(const gsl_spline *, double, gsl_interp_accel *)) { rb_gsl_spline *rgs = NULL; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, x; double val; size_t n, i, j; #ifdef HAVE_NARRAY_H double *ptr1 = NULL, *ptr2 = NULL; struct NARRAY *na = NULL; #endif Data_Get_Struct(obj, rb_gsl_spline, rgs); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: Need_Float(xx); return rb_float_new((*eval)(rgs->s, NUM2DBL(xx), rgs->a)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); val = (*eval)(rgs->s, NUM2DBL(x), rgs->a); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double *) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*eval)(rgs->s, ptr1[i], rgs->a); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { val = (*eval)(rgs->s, gsl_vector_get(v, i), rgs->a); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { val = (*eval)(rgs->s, gsl_matrix_get(m, i, j), rgs->a); gsl_matrix_set(mnew, i, j, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; } static VALUE rb_gsl_spline_eval(VALUE obj, VALUE xx) { return rb_gsl_spline_evaluate(obj, xx, gsl_spline_eval); } static VALUE rb_gsl_spline_eval_deriv(VALUE obj, VALUE xx) { return rb_gsl_spline_evaluate(obj, xx, gsl_spline_eval_deriv); } static VALUE rb_gsl_spline_eval_deriv2(VALUE obj, VALUE xx) { return rb_gsl_spline_evaluate(obj, xx, gsl_spline_eval_deriv2); } static VALUE rb_gsl_spline_eval_integ(VALUE obj, VALUE aa, VALUE bb) { rb_gsl_spline *sp = NULL; gsl_spline *s = NULL; gsl_interp_accel *acc = NULL; double a, b; Need_Float(aa); Need_Float(bb); Data_Get_Struct(obj, rb_gsl_spline, sp); s = sp->s; acc = sp->a; a = NUM2DBL(aa); b = NUM2DBL(bb); return rb_float_new(gsl_spline_eval_integ(s, a, b, acc)); } static VALUE rb_gsl_spline_find(VALUE obj, VALUE vv, VALUE xx) { rb_gsl_spline *sp = NULL; double *ptr = NULL, x; size_t size, stride; Data_Get_Struct(obj, rb_gsl_spline, sp); ptr = get_vector_ptr(vv, &stride, &size); // x = RFLOAT(xx)->value; x = NUM2DBL(xx); return INT2FIX(gsl_interp_accel_find(sp->a, ptr, size, x)); } static VALUE rb_gsl_spline_eval_e(VALUE obj, VALUE xx) { rb_gsl_spline *rgs = NULL; double val; int status; Data_Get_Struct(obj, rb_gsl_spline, rgs); Need_Float(xx); status = gsl_spline_eval_e(rgs->s, NUM2DBL(xx), rgs->a, &val); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_spline_eval_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(val); break; } return Qnil; } static VALUE rb_gsl_spline_eval_deriv_e(VALUE obj, VALUE xx) { rb_gsl_spline *rgs = NULL; double val; int status; Data_Get_Struct(obj, rb_gsl_spline, rgs); Need_Float(xx); status = gsl_spline_eval_deriv_e(rgs->s, NUM2DBL(xx), rgs->a, &val); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_spline_eval_deriv_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(val); break; } return Qnil; } static VALUE rb_gsl_spline_eval_deriv2_e(VALUE obj, VALUE xx) { rb_gsl_spline *rgs = NULL; double val; int status; Data_Get_Struct(obj, rb_gsl_spline, rgs); Need_Float(xx); status = gsl_spline_eval_deriv2_e(rgs->s, NUM2DBL(xx), rgs->a, &val); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_spline_eval_deriv2_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(val); break; } return Qnil; } static VALUE rb_gsl_spline_eval_integ_e(VALUE obj, VALUE a, VALUE b) { rb_gsl_spline *rgs = NULL; double val; int status; Data_Get_Struct(obj, rb_gsl_spline, rgs); Need_Float(a); Need_Float(b); status = gsl_spline_eval_integ_e(rgs->s, NUM2DBL(a), NUM2DBL(b), rgs->a, &val); switch (status) { case GSL_EDOM: rb_gsl_error_handler("gsl_spline_eval_integ_e error", __FILE__, __LINE__, status); break; default: return rb_float_new(val); break; } return Qnil; } static VALUE rb_gsl_spline_info(VALUE obj) { rb_gsl_spline *p = NULL; char buf[256]; Data_Get_Struct(obj, rb_gsl_spline, p); sprintf(buf, "Class: %s\n", rb_class2name(CLASS_OF(obj))); // sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super)); sprintf(buf, "%sType: %s\n", buf, gsl_interp_name(p->s->interp)); sprintf(buf, "%sxmin: %f\n", buf, p->s->interp->xmin); sprintf(buf, "%sxmax: %f\n", buf, p->s->interp->xmax); sprintf(buf, "%sSize: %d\n", buf, (int) p->s->size); return rb_str_new2(buf); } #ifdef GSL_1_8_LATER static VALUE rb_gsl_spline_name(VALUE obj) { rb_gsl_spline *p = NULL; Data_Get_Struct(obj, rb_gsl_spline, p); return rb_str_new2(gsl_spline_name(p->s)); } static VALUE rb_gsl_spline_min_size(VALUE obj) { rb_gsl_spline *sp = NULL; Data_Get_Struct(obj, rb_gsl_spline, sp); return UINT2NUM(gsl_spline_min_size(sp->s)); } #else static VALUE rb_gsl_spline_name(VALUE obj) { rb_gsl_spline *sp = NULL; Data_Get_Struct(obj, rb_gsl_spline, sp); return rb_str_new2(gsl_interp_name(sp->s->interp)); } #endif void Init_gsl_spline(VALUE module) { VALUE cgsl_spline; cgsl_spline = rb_define_class_under(module, "Spline", cGSL_Object); rb_define_singleton_method(cgsl_spline, "alloc", rb_gsl_spline_new, -1); /*****/ rb_define_method(cgsl_spline, "init", rb_gsl_spline_init, 2); rb_define_method(cgsl_spline, "accel", rb_gsl_spline_accel, 0); rb_define_method(cgsl_spline, "eval", rb_gsl_spline_eval, 1); rb_define_alias(cgsl_spline, "[]", "eval"); rb_define_method(cgsl_spline, "eval_deriv", rb_gsl_spline_eval_deriv, 1); rb_define_alias(cgsl_spline, "deriv", "eval_deriv"); rb_define_method(cgsl_spline, "eval_deriv2", rb_gsl_spline_eval_deriv2, 1); rb_define_alias(cgsl_spline, "deriv2", "eval_deriv2"); rb_define_method(cgsl_spline, "eval_integ", rb_gsl_spline_eval_integ, 2); rb_define_alias(cgsl_spline, "integ", "eval_integ"); rb_define_method(cgsl_spline, "name", rb_gsl_spline_name, 0); rb_define_alias(cgsl_spline, "type", "name"); rb_define_method(cgsl_spline, "find", rb_gsl_spline_find, 2); rb_define_alias(cgsl_spline, "accel_find", "find"); rb_define_method(cgsl_spline, "eval_e", rb_gsl_spline_eval_e, 1); rb_define_method(cgsl_spline, "eval_deriv_e", rb_gsl_spline_eval_deriv_e, 1); rb_define_alias(cgsl_spline, "deriv_e", "eval_deriv_e"); rb_define_method(cgsl_spline, "eval_deriv2_e", rb_gsl_spline_eval_deriv2_e, 1); rb_define_alias(cgsl_spline, "deri2v_e", "eval_deriv2_e"); rb_define_method(cgsl_spline, "eval_integ_e", rb_gsl_spline_eval_integ_e, 1); rb_define_alias(cgsl_spline, "integ_e", "eval_integ_e"); rb_define_method(cgsl_spline, "info", rb_gsl_spline_info, 0); #ifdef GSL_1_8_LATER rb_define_method(cgsl_spline, "min_size", rb_gsl_spline_min_size, 0); #endif } gsl-1.15.3/ext/oper_complex_source.c0000644000175000017500000001361712220252463016772 0ustar boutilboutil/* matrix/oper_complex_source.c * * Copyright (C) 1996, 1997, 1998, 1999, 2000 Brian Gough * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or (at * your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "rb_gsl_config.h" #ifndef GSL_1_2_LATER #include #include #include #include #include #define BASE_GSL_COMPLEX #include "templates_on.h" int FUNCTION (gsl_matrix, add) (GSL_TYPE (gsl_matrix) * a, const GSL_TYPE (gsl_matrix) * b) { const size_t M = a->size1; const size_t N = a->size2; if (b->size1 != M || b->size2 != N) { GSL_ERROR ("matrices must have same dimensions", GSL_EBADLEN); } else { const size_t tda_a = a->tda; const size_t tda_b = b->tda; size_t i, j; for (i = 0; i < M; i++) { for (j = 0; j < N; j++) { const size_t aij = 2 * (i * tda_a + j); const size_t bij = 2 * (i * tda_b + j); a->data[aij] += b->data[bij]; a->data[aij + 1] += b->data[bij + 1]; } } return GSL_SUCCESS; } } int FUNCTION (gsl_matrix, sub) (GSL_TYPE (gsl_matrix) * a, const GSL_TYPE (gsl_matrix) * b) { const size_t M = a->size1; const size_t N = a->size2; if (b->size1 != M || b->size2 != N) { GSL_ERROR ("matrices must have same dimensions", GSL_EBADLEN); } else { const size_t tda_a = a->tda; const size_t tda_b = b->tda; size_t i, j; for (i = 0; i < M; i++) { for (j = 0; j < N; j++) { const size_t aij = 2 * (i * tda_a + j); const size_t bij = 2 * (i * tda_b + j); a->data[aij] -= b->data[bij]; a->data[aij + 1] -= b->data[bij + 1]; } } return GSL_SUCCESS; } } int FUNCTION (gsl_matrix, mul_elements) (GSL_TYPE (gsl_matrix) * a, const GSL_TYPE (gsl_matrix) * b) { const size_t M = a->size1; const size_t N = a->size2; if (b->size1 != M || b->size2 != N) { GSL_ERROR ("matrices must have same dimensions", GSL_EBADLEN); } else { const size_t tda_a = a->tda; const size_t tda_b = b->tda; size_t i, j; for (i = 0; i < M; i++) { for (j = 0; j < N; j++) { const size_t aij = 2 * (i * tda_a + j); const size_t bij = 2 * (i * tda_b + j); ATOMIC ar = a->data[aij]; ATOMIC ai = a->data[aij + 1]; ATOMIC br = b->data[bij]; ATOMIC bi = b->data[bij + 1]; a->data[aij] = ar * br - ai * bi; a->data[aij + 1] = ar * bi + ai * br; } } return GSL_SUCCESS; } } int FUNCTION (gsl_matrix, div_elements) (GSL_TYPE (gsl_matrix) * a, const GSL_TYPE (gsl_matrix) * b) { const size_t M = a->size1; const size_t N = a->size2; if (b->size1 != M || b->size2 != N) { GSL_ERROR ("matrices must have same dimensions", GSL_EBADLEN); } else { const size_t tda_a = a->tda; const size_t tda_b = b->tda; size_t i, j; for (i = 0; i < M; i++) { for (j = 0; j < N; j++) { const size_t aij = 2 * (i * tda_a + j); const size_t bij = 2 * (i * tda_b + j); ATOMIC ar = a->data[aij]; ATOMIC ai = a->data[aij + 1]; ATOMIC br = b->data[bij]; ATOMIC bi = b->data[bij + 1]; ATOMIC s = 1.0 / hypot(br, bi); ATOMIC sbr = s * br; ATOMIC sbi = s * bi; a->data[aij] = (ar * sbr + ai * sbi) * s; a->data[aij + 1] = (ai * sbr - ar * sbi) * s; } } return GSL_SUCCESS; } } int FUNCTION (gsl_matrix, scale) (GSL_TYPE (gsl_matrix) * a, const BASE x) { const size_t M = a->size1; const size_t N = a->size2; const size_t tda = a->tda; size_t i, j; ATOMIC xr = GSL_REAL(x); ATOMIC xi = GSL_IMAG(x); for (i = 0; i < M; i++) { for (j = 0; j < N; j++) { const size_t aij = 2 * (i * tda + j); ATOMIC ar = a->data[aij]; ATOMIC ai = a->data[aij + 1]; a->data[aij] = ar * xr - ai * xi; a->data[aij + 1] = ar * xi + ai * xr; } } return GSL_SUCCESS; } int FUNCTION (gsl_matrix, add_constant) (GSL_TYPE (gsl_matrix) * a, const BASE x) { const size_t M = a->size1; const size_t N = a->size2; const size_t tda = a->tda; size_t i, j; for (i = 0; i < M; i++) { for (j = 0; j < N; j++) { a->data[2 * (i * tda + j)] += GSL_REAL (x); a->data[2 * (i * tda + j) + 1] += GSL_IMAG (x); } } return GSL_SUCCESS; } int FUNCTION (gsl_matrix, add_diagonal) (GSL_TYPE (gsl_matrix) * a, const BASE x) { const size_t M = a->size1; const size_t N = a->size2; const size_t tda = a->tda; const size_t loop_lim = (M < N ? M : N); size_t i; for (i = 0; i < loop_lim; i++) { a->data[2 * (i * tda + i)] += GSL_REAL (x); a->data[2 * (i * tda + i) + 1] += GSL_IMAG (x); } return GSL_SUCCESS; } #include "templates_off.h" #undef BASE_GSL_COMPLEX #endif gsl-1.15.3/ext/histogram.c0000644000175000017500000016357212220252463014721 0ustar boutilboutil/* histogram.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_histogram.h" #include "rb_gsl_array.h" #include #include #include VALUE cgsl_histogram; VALUE cgsl_histogram_range; VALUE cgsl_histogram_bin; static VALUE cgsl_histogram_integ; static VALUE rb_gsl_histogram_alloc_from_file(VALUE klass, VALUE name); #ifdef GSL_0_9_4_LATER static VALUE rb_gsl_histogram_alloc(int argc, VALUE *argv, VALUE klass) { gsl_histogram *h = NULL; gsl_vector *v; double min, max; size_t n, size; switch (argc) { case 1: switch (TYPE(argv[0])) { case T_FIXNUM: n = FIX2INT(argv[0]); h = gsl_histogram_alloc(n); break; case T_ARRAY: v = make_cvector_from_rarray(argv[0]); h = gsl_histogram_alloc(v->size-1); gsl_histogram_set_ranges(h, v->data, v->size); gsl_vector_free(v); break; case T_STRING: return rb_gsl_histogram_alloc_from_file(klass, argv[0]); break; default: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, v); h = gsl_histogram_alloc(v->size-1); gsl_histogram_set_ranges(h, v->data, v->size); break; } return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); break; case 3: CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); n = FIX2INT(argv[0]); min = NUM2DBL(argv[1]); max = NUM2DBL(argv[2]); h = gsl_histogram_calloc(n); gsl_histogram_set_ranges_uniform(h, min, max); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); break; case 2: switch (TYPE(argv[0])) { case T_FIXNUM: CHECK_FIXNUM(argv[0]); if (TYPE(argv[1]) != T_ARRAY) { rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[1]))); } n = FIX2INT(argv[0]); min = NUM2DBL(rb_ary_entry(argv[1], 0)); max = NUM2DBL(rb_ary_entry(argv[1], 1)); h = gsl_histogram_calloc(n); gsl_histogram_set_ranges_uniform(h, min, max); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); break; case T_ARRAY: CHECK_FIXNUM(argv[1]); v = make_cvector_from_rarray(argv[0]); size = FIX2INT(argv[1]); h = gsl_histogram_calloc(size-1); gsl_histogram_set_ranges(h, v->data, size); gsl_vector_free(v); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); break; default: CHECK_VECTOR(argv[0]); CHECK_FIXNUM(argv[1]); Data_Get_Struct(argv[0], gsl_vector, v); size = FIX2INT(argv[1]); h = gsl_histogram_calloc(size-1); gsl_histogram_set_ranges(h, v->data, size); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1, 2, 3)", argc); break; } } static VALUE rb_gsl_histogram_alloc_from_file(VALUE klass, VALUE name) { char filename[1024], buf[1024]; gsl_histogram *h; int nn; size_t n, i; FILE *fp = NULL; double upper; strcpy(filename, STR2CHARPTR(name)); sprintf(buf, "wc %s", filename); fp = popen(buf, "r"); if (fp == NULL) rb_raise(rb_eIOError, "popen failed."); fgets(buf, 1024, fp); pclose(fp); sscanf(buf, "%d", &nn); n = (size_t) nn; /* vector length */ fp = fopen(filename, "r"); if (fp == NULL) rb_raise(rb_eIOError, "cannot open file %s.", filename); h = gsl_histogram_alloc(n); i = 0; while (fgets(buf, 1024, fp)) { sscanf(buf, "%lg %lg %lg", h->range+i, &upper, h->bin+i); i++; } h->range[n] = upper; fclose(fp); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); } /* initialization + set uniform ranges (equal spacing from min to max) */ static VALUE rb_gsl_histogram_alloc_uniform(int argc, VALUE *argv, VALUE klass) { gsl_histogram *h = NULL; double min, max, tmp; size_t n; switch (argc) { case 3: CHECK_FIXNUM(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); n = FIX2INT(argv[0]); min = NUM2DBL(argv[1]); max = NUM2DBL(argv[2]); break; case 2: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); Check_Type(argv[1], T_ARRAY); min = NUM2DBL(rb_ary_entry(argv[1], 0)); max = NUM2DBL(rb_ary_entry(argv[1], 1)); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } if (min > max) { tmp = min; min = max; max = tmp; } h = gsl_histogram_alloc(n); gsl_histogram_set_ranges_uniform(h, min, max); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); } /* initialization + set ranges with a given spacing from min to max */ static VALUE rb_gsl_histogram_alloc_with_min_max_step(VALUE klass, VALUE vmin, VALUE vmax, VALUE ss) { gsl_histogram *h = NULL; gsl_vector *v = NULL; double min, max, tmp, step; size_t i, n; Need_Float(vmin); Need_Float(vmax); Need_Float(ss); min = NUM2DBL(vmin); max = NUM2DBL(vmax); step = NUM2DBL(ss); if (min > max) { tmp = min; min = max; max = tmp; } n = (int) ((max - min)/step); h = gsl_histogram_alloc(n); v = gsl_vector_alloc(n + 1); for (i = 0; i < n + 1; i++) gsl_vector_set(v, i, min + step*i); gsl_histogram_set_ranges(h, v->data, v->size); gsl_vector_free(v); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); } #endif static VALUE rb_gsl_histogram_calloc(VALUE klass, VALUE nn) { gsl_histogram *h = NULL; CHECK_FIXNUM(nn); h = gsl_histogram_calloc(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); } static VALUE rb_gsl_histogram_calloc_range(int argc, VALUE *argv, VALUE klass) { gsl_histogram *h = NULL; gsl_vector *v = NULL; size_t n; switch (argc) { case 1: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, v); n = v->size; break; case 2: CHECK_FIXNUM(argv[0]); CHECK_VECTOR(argv[1]); n = FIX2INT(argv[0]); Data_Get_Struct(argv[1], gsl_vector, v); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } h = gsl_histogram_calloc_range(n, v->data); return Data_Wrap_Struct(klass, 0, gsl_histogram_free, h); } static VALUE rb_gsl_histogram_bins(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return INT2FIX(gsl_histogram_bins(h)); } static VALUE rb_gsl_histogram_set_ranges(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; gsl_vector *v = NULL; size_t size; Data_Get_Struct(obj, gsl_histogram, h); if (argc != 1 && argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); if (TYPE(argv[0]) == T_ARRAY) { v = make_cvector_from_rarray(argv[0]); if (argc == 1) size = v->size; else size = FIX2INT(argv[1]); gsl_histogram_set_ranges(h, v->data, size); gsl_vector_free(v); } else { CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, v); if (argc == 1) size = v->size; else size = FIX2INT(argv[1]); gsl_histogram_set_ranges(h, v->data, size); } return obj; } static VALUE rb_gsl_histogram_range(VALUE obj) { gsl_histogram *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_histogram, h); v = gsl_vector_view_alloc(); v->vector.data = h->range; v->vector.size = h->n + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_range, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram_bin(VALUE obj) { gsl_histogram *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_histogram, h); v = gsl_vector_view_alloc(); v->vector.data = h->bin; v->vector.size = h->n; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_bin, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram_set_ranges_uniform(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; double xmin, xmax; switch (argc) { case 1: Check_Type(argv[0], T_ARRAY); xmin = NUM2DBL(rb_ary_entry(argv[0], 0)); xmax = NUM2DBL(rb_ary_entry(argv[0], 1)); break; case 2: xmin = NUM2DBL(argv[0]); xmax = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Struct(obj, gsl_histogram, h); gsl_histogram_set_ranges_uniform(h, xmin, xmax); return obj; } /* singleton */ static VALUE rb_gsl_histogram_memcpy(VALUE obj, VALUE vhdest, VALUE vhsrc) { gsl_histogram *hdest = NULL, *hsrc = NULL; CHECK_HISTOGRAM(vhdest); CHECK_HISTOGRAM(vhsrc); Data_Get_Struct(vhdest, gsl_histogram, hdest); Data_Get_Struct(vhsrc, gsl_histogram, hsrc); gsl_histogram_memcpy(hdest, hsrc); return vhdest; } static VALUE rb_gsl_histogram_clone(VALUE obj) { gsl_histogram *hsrc = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram, hsrc); hnew = gsl_histogram_clone(hsrc); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew); } static VALUE rb_gsl_histogram_accumulate(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; gsl_vector *v; gsl_vector_int *vi; size_t i; double weight = 1; #ifdef HAVE_NARRAY_H double *ptr; size_t size, stride; #endif switch (argc) { case 2: Need_Float(argv[1]); weight = NUM2DBL(argv[1]); break; case 1: weight = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Struct(obj, gsl_histogram, h); if (TYPE(argv[0]) == T_ARRAY) { // for (i = 0; i < RARRAY(argv[0])->len; i++) for (i = 0; i < RARRAY_LEN(argv[0]); i++) gsl_histogram_accumulate(h, NUM2DBL(rb_ary_entry(argv[0], i)), weight); } else if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, v); for (i = 0; i < v->size; i++) gsl_histogram_accumulate(h, gsl_vector_get(v, i), weight); } else if (VECTOR_INT_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector_int, vi); for (i = 0; i < vi->size; i++) gsl_histogram_accumulate(h, (double)gsl_vector_int_get(vi, i), weight); #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[0])) { ptr = get_vector_ptr(argv[0], &stride, &size); for (i = 0; i < size; i++) gsl_histogram_accumulate(h, ptr[i], weight); #endif } else { gsl_histogram_accumulate(h, NUM2DBL(argv[0]), weight); } return argv[0]; } static VALUE rb_gsl_histogram_accumulate2(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; double weight = 1; double x; switch (argc) { case 2: Need_Float(argv[1]); weight = NUM2DBL(argv[1]); /* no break; */ case 1: Need_Float(argv[0]); x = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Struct(obj, gsl_histogram, h); if (x < h->range[0]) x = h->range[0] + 4*GSL_DBL_EPSILON; if (x > h->range[h->n]) x = h->range[h->n] - 4*GSL_DBL_EPSILON; gsl_histogram_accumulate(h, x, weight); return argv[0]; } static VALUE rb_gsl_histogram_get(VALUE obj, VALUE i) { gsl_histogram *h = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(gsl_histogram_get(h, FIX2INT(i))); } static VALUE rb_gsl_histogram_get_range(VALUE obj, VALUE i) { gsl_histogram *h = NULL; double lower, upper; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_histogram, h); gsl_histogram_get_range(h, FIX2INT(i), &lower, &upper); return rb_ary_new3(2, rb_float_new(lower), rb_float_new(upper)); } static VALUE rb_gsl_histogram_max(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(gsl_histogram_max(h)); } static VALUE rb_gsl_histogram_min(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(gsl_histogram_min(h)); } static VALUE rb_gsl_histogram_reset(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); gsl_histogram_reset(h); return obj; } static VALUE rb_gsl_histogram_find(VALUE obj, VALUE x) { gsl_histogram *h = NULL; size_t i; Need_Float(x); Data_Get_Struct(obj, gsl_histogram, h); gsl_histogram_find(h, NUM2DBL(x), &i); return INT2FIX(i); } static VALUE rb_gsl_histogram_max_val(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(gsl_histogram_max_val(h)); } static VALUE rb_gsl_histogram_max_bin(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return INT2FIX(gsl_histogram_max_bin(h)); } static VALUE rb_gsl_histogram_min_val(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(gsl_histogram_min_val(h)); } static VALUE rb_gsl_histogram_min_bin(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return INT2FIX(gsl_histogram_min_bin(h)); } static VALUE rb_gsl_histogram_mean(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(gsl_histogram_mean(h)); } static VALUE rb_gsl_histogram_sigma(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(gsl_histogram_sigma(h)); } #ifndef GSL_1_1_LATER double gsl_histogram_sum(const gsl_histogram * h) { double sum=0; size_t i=0, n; n=h->n; while(i < n) sum += h->bin[i++]; return sum; } #endif static VALUE rb_gsl_histogram_sum(VALUE obj) { gsl_histogram *h = NULL; Data_Get_Struct(obj, gsl_histogram, h); if (CLASS_OF(obj) == cgsl_histogram_integ) return rb_float_new(gsl_histogram_get(h, h->n-1)); else return rb_float_new(gsl_histogram_sum(h)); } static VALUE rb_gsl_histogram_normalize_bang(VALUE obj) { gsl_histogram *h = NULL; double scale; Data_Get_Struct(obj, gsl_histogram, h); if (CLASS_OF(obj) == cgsl_histogram_integ) scale = 1.0/gsl_histogram_get(h, h->n-1); else scale = 1.0/gsl_histogram_sum(h); gsl_histogram_scale(h, scale); return obj; } static VALUE rb_gsl_histogram_normalize(VALUE obj) { gsl_histogram *h = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram, h); hnew = gsl_histogram_clone(h); return rb_gsl_histogram_normalize_bang(Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew)); } static VALUE rb_gsl_histogram_integral(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; size_t istart = 0, iend, i = 0; double sum = 0.0; Data_Get_Struct(obj, gsl_histogram, h); switch (argc) { case 0: return rb_gsl_histogram_sum(obj); break; case 1: CHECK_FIXNUM(argv[0]); istart = 0; iend = FIX2INT(argv[0]); break; case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); istart = FIX2INT(argv[0]); iend = FIX2INT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } if (iend >= h->n) iend = h->n - 1; i = istart; while (i <= iend) sum += h->bin[i++]; return rb_float_new(sum); } static VALUE rb_gsl_histogram_equal_bins_p(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h1 = NULL, *h2 = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_HISTOGRAM(argv[0]); CHECK_HISTOGRAM(argv[1]); Data_Get_Struct(argv[0], gsl_histogram, h1); Data_Get_Struct(argv[1], gsl_histogram, h2); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Data_Get_Struct(obj, gsl_histogram, h1); CHECK_HISTOGRAM(argv[0]); Data_Get_Struct(argv[0], gsl_histogram, h2); break; } return INT2FIX(gsl_histogram_equal_bins_p(h1, h2)); } static VALUE rb_gsl_histogram_equal_bins_p2(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h1 = NULL, *h2 = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_HISTOGRAM(argv[0]); CHECK_HISTOGRAM(argv[1]); Data_Get_Struct(argv[0], gsl_histogram, h1); Data_Get_Struct(argv[1], gsl_histogram, h2); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Data_Get_Struct(obj, gsl_histogram, h1); CHECK_HISTOGRAM(argv[0]); Data_Get_Struct(argv[0], gsl_histogram, h2); break; } if (gsl_histogram_equal_bins_p(h1, h2)) return Qtrue; else return Qfalse; } static VALUE rb_gsl_histogram_add(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram, h1); hnew = gsl_histogram_clone(h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_add(hnew, h2); } else { Need_Float(hh2); gsl_histogram_shift(hnew, NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew); } static VALUE rb_gsl_histogram_add2(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL; Data_Get_Struct(obj, gsl_histogram, h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_add(h1, h2); } else { Need_Float(hh2); gsl_histogram_shift(h1, NUM2DBL(hh2)); } return obj; } static VALUE rb_gsl_histogram_sub(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram, h1); hnew = gsl_histogram_clone(h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_sub(hnew, h2); } else { Need_Float(hh2); gsl_histogram_shift(hnew, -NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew); } static VALUE rb_gsl_histogram_sub2(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL; Data_Get_Struct(obj, gsl_histogram, h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_sub(h1, h2); } else { Need_Float(hh2); gsl_histogram_shift(h1, -NUM2DBL(hh2)); } return obj; } static VALUE rb_gsl_histogram_mul(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram, h1); hnew = gsl_histogram_clone(h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_mul(hnew, h2); } else { Need_Float(hh2); gsl_histogram_scale(hnew, NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew); } static VALUE rb_gsl_histogram_mul2(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL; Data_Get_Struct(obj, gsl_histogram, h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_mul(h1, h2); } else { Need_Float(hh2); gsl_histogram_scale(h1, NUM2DBL(hh2)); } return obj; } static VALUE rb_gsl_histogram_div(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL, *hnew = NULL; Data_Get_Struct(obj, gsl_histogram, h1); hnew = gsl_histogram_clone(h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_div(hnew, h2); } else { Need_Float(hh2); gsl_histogram_scale(hnew, 1.0/NUM2DBL(hh2)); } return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew); } static VALUE rb_gsl_histogram_div2(VALUE obj, VALUE hh2) { gsl_histogram *h1 = NULL, *h2 = NULL; Data_Get_Struct(obj, gsl_histogram, h1); if (HISTOGRAM_P(hh2)) { Data_Get_Struct(hh2, gsl_histogram, h2); mygsl_histogram_div(h1, h2); } else { Need_Float(hh2); gsl_histogram_scale(h1, 1.0/NUM2DBL(hh2)); } return obj; } static VALUE rb_gsl_histogram_scale_bang(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; double scale; Data_Get_Struct(obj, gsl_histogram, h); switch (argc) { case 0: if (CLASS_OF(obj) == cgsl_histogram_integ) scale = 1.0/h->bin[h->n-1]; else scale = 1.0/gsl_histogram_sum(h); break; case 1: scale = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } gsl_histogram_scale(h, scale); return obj; } static VALUE rb_gsl_histogram_scale(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL, *hnew = NULL; double scale; Data_Get_Struct(obj, gsl_histogram, h); switch (argc) { case 0: if (CLASS_OF(obj) == cgsl_histogram_integ) scale = 1.0/h->bin[h->n-1]; else scale = 1.0/gsl_histogram_sum(h); break; case 1: scale = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } hnew = gsl_histogram_clone(h); gsl_histogram_scale(hnew, scale); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew); } static VALUE rb_gsl_histogram_shift(VALUE obj, VALUE shift) { gsl_histogram *h = NULL; Need_Float(shift); Data_Get_Struct(obj, gsl_histogram, h); gsl_histogram_shift(h, NUM2DBL(shift)); return obj; } static VALUE rb_gsl_histogram_shift2(VALUE obj, VALUE shift) { gsl_histogram *h = NULL, *hnew = NULL; Need_Float(shift); Data_Get_Struct(obj, gsl_histogram, h); hnew = gsl_histogram_clone(h); gsl_histogram_shift(hnew, NUM2DBL(shift)); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_histogram_free, hnew); } static VALUE rb_gsl_histogram_fwrite(VALUE obj, VALUE io) { gsl_histogram *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram, h); f = rb_gsl_open_writefile(io, &flag); status = gsl_histogram_fwrite(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram_fread(VALUE obj, VALUE io) { gsl_histogram *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_histogram_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram_fprintf(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; FILE *fp; int status, flag = 0; if (argc != 1 && argc != 3) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc); } Data_Get_Struct(obj, gsl_histogram, h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 3) { Check_Type(argv[1], T_STRING); Check_Type(argv[2], T_STRING); status = gsl_histogram_fprintf(fp, h, STR2CSTR(argv[1]), STR2CSTR(argv[2])); } else { status = gsl_histogram_fprintf(fp, h, "%g", "%g"); } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_histogram_printf(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; int status; Data_Get_Struct(obj, gsl_histogram, h); if (argc == 2) { Check_Type(argv[0], T_STRING); Check_Type(argv[1], T_STRING); status = gsl_histogram_fprintf(stdout, h, STR2CSTR(argv[0]), STR2CSTR(argv[1])); } else { status = gsl_histogram_fprintf(stdout, h, "%g", "%g"); } return INT2FIX(status); } static VALUE rb_gsl_histogram_fscanf(VALUE obj, VALUE io) { gsl_histogram *h = NULL; FILE *fp; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram, h); fp = rb_gsl_open_readfile(io, &flag); status = gsl_histogram_fscanf(fp, h); if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_histogram_print(VALUE obj) { gsl_histogram *h = NULL; int status; Data_Get_Struct(obj, gsl_histogram, h); status = gsl_histogram_fprintf(stdout, h, "%g", "%g"); return INT2FIX(status); } static VALUE rb_gsl_histogram_pdf_alloc(VALUE klass, VALUE nn) { gsl_histogram_pdf *h = NULL; gsl_histogram *h0 = NULL; #ifdef GSL_0_9_4_LATER if (rb_obj_is_kind_of(nn, cgsl_histogram)) { Data_Get_Struct(nn, gsl_histogram, h0); h = gsl_histogram_pdf_alloc(h0->n); gsl_histogram_pdf_init(h, h0); } else { CHECK_FIXNUM(nn); h = gsl_histogram_pdf_alloc(FIX2INT(nn)); } #else gsl_histogram *hh = NULL; Data_Get_Struct(nn, gsl_histogram, hh); h = gsl_histogram_pdf_alloc(hh); #endif return Data_Wrap_Struct(klass, 0, gsl_histogram_pdf_free, h); } #ifdef GSL_0_9_4_LATER static VALUE rb_gsl_histogram_pdf_init(VALUE obj, VALUE hh) { gsl_histogram_pdf *p = NULL; gsl_histogram *h = NULL; CHECK_HISTOGRAM(hh); Data_Get_Struct(obj, gsl_histogram_pdf, p); Data_Get_Struct(hh, gsl_histogram, h); gsl_histogram_pdf_init(p, h); return obj; } #endif static VALUE rb_gsl_histogram_pdf_sample(VALUE obj, VALUE r) { gsl_histogram_pdf *p = NULL; Need_Float(r); Data_Get_Struct(obj, gsl_histogram_pdf, p); return rb_float_new(gsl_histogram_pdf_sample(p, NUM2DBL(r))); } static VALUE rb_gsl_histogram_pdf_range(VALUE obj) { gsl_histogram_pdf *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_histogram_pdf, h); v = gsl_vector_view_alloc(h->n); v->vector.data = h->range; v->vector.size = h->n + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_histogram_range, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram_pdf_sum(VALUE obj) { gsl_histogram_pdf *h = NULL; gsl_vector_view *v = NULL; Data_Get_Struct(obj, gsl_histogram_pdf, h); v = gsl_vector_view_alloc(h->n); v->vector.data = h->sum; v->vector.size = h->n + 1; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_vector_view_ro, 0, gsl_vector_view_free, v); } static VALUE rb_gsl_histogram_graph(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH gsl_histogram *v = NULL; FILE *fp = NULL; size_t i; char command[1024]; Data_Get_Struct(obj, gsl_histogram, v); switch (argc) { case 0: strcpy(command, "graph -T X -g 3"); break; case 1: make_graphcommand(command, argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } fp = popen(command, "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); for (i = 0; i < v->n; i++) { fprintf(fp, "%e %e\n%e %e\n", v->range[i], v->bin[i], v->range[i+1], v->bin[i]); } fflush(fp); pclose(fp); fp = NULL; return Qtrue; #else rb_raise(rb_eNoMethodError, "not implemented"); return Qfalse; #endif } static VALUE rb_gsl_histogram_plot(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH gsl_histogram *v = NULL; FILE *fp = NULL; size_t i; Data_Get_Struct(obj, gsl_histogram, v); switch (argc) { case 0: fp = popen("gnuplot -persist", "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); fprintf(fp, "plot '-' with fsteps\n"); break; case 1: fp = popen("gnuplot -persist", "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); if (TYPE(argv[0]) == T_STRING) fprintf(fp, "plot '-' %s\n", STR2CSTR(argv[0])); else fprintf(fp, "plot '-' with fsteps\n"); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } for (i = 0; i < v->n; i++) { fprintf(fp, "%e %e\n", v->range[i], v->bin[i]); } fprintf(fp, "e\n"); fflush(fp); pclose(fp); fp = NULL; return Qtrue; #else rb_raise(rb_eNoMethodError, "not implemented"); return Qfalse; #endif } struct fit_histogram { gsl_histogram *h; size_t binstart, binend; }; static VALUE rb_gsl_histogram_fit_exponential(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h; gsl_vector *x, *lny, *w; size_t binstart = 0, binend, n, p = 2, dof, i; double c0, c1, cov00, cov01, cov11, sumsq, xl, xh; Data_Get_Struct(obj, gsl_histogram, h); binstart = 0; binend = h->n - 1; switch (argc) { case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); binstart = FIX2INT(argv[0]); binend = FIX2INT(argv[1]); if (binend >= h->n) binend = h->n - 1; break; case 0: break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 2)", argc); break; } n = binend - binstart + 1; dof = n - p; x = gsl_vector_alloc(n); w = gsl_vector_alloc(n); lny = gsl_vector_alloc(n); for (i = 0; i < n; i++) { if (gsl_histogram_get_range(h, i+binstart, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); gsl_vector_set(x, i, (xl+xh)/2.0); gsl_vector_set(lny, i, log(h->bin[i+binstart])); gsl_vector_set(w, i, h->bin[i+binstart]); } gsl_fit_wlinear(x->data, 1, w->data, 1, lny->data, 1, n, &c0, &c1, &cov00, &cov01, &cov11, &sumsq); gsl_vector_free(lny); gsl_vector_free(w); gsl_vector_free(x); c0 = exp(c0); return rb_ary_new3(6, rb_float_new(c0), rb_float_new(c1), rb_float_new(c0*sqrt(cov00)), rb_float_new(sqrt(cov11)), rb_float_new(sumsq), INT2FIX(dof)); } static VALUE rb_gsl_histogram_fit_power(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h; gsl_vector *lnx, *lny, *w; size_t binstart = 0, binend, n, p = 2, dof, i; double c0, c1, cov00, cov01, cov11, sumsq, xl, xh; Data_Get_Struct(obj, gsl_histogram, h); binstart = 0; binend = h->n - 1; switch (argc) { case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); binstart = FIX2INT(argv[0]); binend = FIX2INT(argv[1]); if (binend >= h->n) binend = h->n - 1; break; case 0: break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 2)", argc); break; } n = binend - binstart + 1; dof = n - p; lnx = gsl_vector_alloc(n); w = gsl_vector_alloc(n); lny = gsl_vector_alloc(n); for (i = 0; i < n; i++) { if (gsl_histogram_get_range(h, i+binstart, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); gsl_vector_set(lnx, i, (log(xl)+log(xh))/2.0); gsl_vector_set(lny, i, log(h->bin[i+binstart])); gsl_vector_set(w, i, h->bin[i+binstart]); } gsl_fit_wlinear(lnx->data, 1, w->data, 1, lny->data, 1, n, &c0, &c1, &cov00, &cov01, &cov11, &sumsq); gsl_vector_free(lny); gsl_vector_free(w); gsl_vector_free(lnx); c0 = exp(c0); return rb_ary_new3(6, rb_float_new(c0), rb_float_new(c1), rb_float_new(c0*sqrt(cov00)), rb_float_new(sqrt(cov11)), rb_float_new(sumsq), INT2FIX(dof)); } static int Gaussian_f(const gsl_vector *v, void *params, gsl_vector *f); static int Gaussian_df(const gsl_vector *v, void *params, gsl_matrix * J); static int Gaussian_f(const gsl_vector *v, void *params, gsl_vector *f) { struct fit_histogram *hh; gsl_histogram *h = NULL; double amp, mu, var, xl, xh, xi, yi, sqw; size_t i, binstart, binend; hh = (struct fit_histogram *) params; h = hh->h; binstart = hh->binstart; binend = hh->binend; var = gsl_vector_get(v, 0); mu = gsl_vector_get(v, 1); amp = gsl_vector_get(v, 2); for (i = binstart; i <= binend; i++) { if (gsl_histogram_get_range(h, i, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); xi = (xl + xh)/2.0; yi = h->bin[i]; // sqw = sqrt(yi); if (yi >= 1.0) sqw = 1.0/sqrt(yi); else sqw = 1.0; gsl_vector_set(f, i-binstart, (amp*exp(-(xi - mu)*(xi - mu)/var/2.0) - yi)*sqw); } return GSL_SUCCESS; } static int Gaussian_df(const gsl_vector *v, void *params, gsl_matrix *J) { struct fit_histogram *hh; gsl_histogram *h = NULL; double amp, mu, var, xl, xh, xi, yi, y, sqw; size_t i, binstart, binend; hh = (struct fit_histogram *) params; h = hh->h; binstart = hh->binstart; binend = hh->binend; var = gsl_vector_get(v, 0); mu = gsl_vector_get(v, 1); amp = gsl_vector_get(v, 2); for (i = binstart; i <= binend; i++) { if (gsl_histogram_get_range(h, i, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); xi = (xl + xh)/2.0; yi = h->bin[i]; // sqw = sqrt(yi); if (yi >= 1.0) sqw = 1.0/sqrt(yi); else sqw = 1.0; y = exp(-(xi - mu)*(xi - mu)/var/2.0); gsl_matrix_set(J, i-binstart, 0, amp*y*(xi - mu)*(xi - mu)/2/var/var*sqw); gsl_matrix_set(J, i-binstart, 1, amp*y*(xi - mu)/var*sqw); gsl_matrix_set(J, i-binstart, 2, y*sqw); } return GSL_SUCCESS; } static int Gaussian_fdf(const gsl_vector *v, void *params, gsl_vector *f, gsl_matrix *J) { Gaussian_f(v, params, f); Gaussian_df(v, params, J); return GSL_SUCCESS; } static VALUE rb_gsl_histogram_fit_gaussian(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; struct fit_histogram hh; const gsl_multifit_fdfsolver_type *T; gsl_multifit_fdfsolver *s; int status; size_t iter = 0, binstart, binend; size_t n, dof; /* # of data points */ size_t p = 3; /* # of fitting parameters */ gsl_multifit_function_fdf f; gsl_matrix *covar = NULL; gsl_vector *x = NULL; double sigma, mean, height, errs, errm, errh, chi2; Data_Get_Struct(obj, gsl_histogram, h); binstart = 0; binend = h->n - 1; switch (argc) { case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); binstart = FIX2INT(argv[0]); binend = FIX2INT(argv[1]); if (binend >= h->n) binend = h->n - 1; break; case 0: break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 2)", argc); break; } x = gsl_vector_alloc(p); gsl_vector_set(x, 0, gsl_pow_2(gsl_histogram_sigma(h))); /* initial values, var = 1 */ gsl_vector_set(x, 1, gsl_histogram_mean(h)); /* mu = 0 */ gsl_vector_set(x, 2, gsl_histogram_max_val(h)); /* amp = 1 */ hh.h = h; hh.binstart = binstart; hh.binend = binend; n = binend - binstart + 1; covar = gsl_matrix_alloc(p, p); f.f = Gaussian_f; f.df = Gaussian_df; f.fdf = Gaussian_fdf; f.n = n; f.p = p; f.params = &hh; T = gsl_multifit_fdfsolver_lmsder; s = gsl_multifit_fdfsolver_alloc(T, n, p); gsl_multifit_fdfsolver_set(s, &f, x); do { iter++; status = gsl_multifit_fdfsolver_iterate(s); if (status) break; status = gsl_multifit_test_delta(s->dx, s->x, 1e-4, 1e-4); } while (status == GSL_CONTINUE); sigma = sqrt(gsl_vector_get(s->x, 0)); mean = gsl_vector_get(s->x, 1); height = gsl_vector_get(s->x, 2)*sigma*sqrt(2*M_PI); gsl_multifit_covar(s->J, 0.0, covar); chi2 = gsl_pow_2(gsl_blas_dnrm2(s->f)); /* not reduced chi-square */ dof = n - p; errs = sqrt(chi2/dof*gsl_matrix_get(covar, 0, 0))/sigma/2; errm = sqrt(chi2/dof*gsl_matrix_get(covar, 1, 1)); errh = sqrt(chi2/dof*gsl_matrix_get(covar, 2, 2)); gsl_multifit_fdfsolver_free(s); gsl_vector_free(x); gsl_matrix_free(covar); return rb_ary_new3(8, rb_float_new(sigma), rb_float_new(mean), rb_float_new(height), rb_float_new(errs), rb_float_new(errm), rb_float_new(errh), rb_float_new(chi2), INT2FIX(dof)); } static int Rayleigh_f(const gsl_vector *v, void *params, gsl_vector *f); static int Rayleigh_df(const gsl_vector *v, void *params, gsl_matrix * J); static int Rayleigh_f(const gsl_vector *v, void *params, gsl_vector *f) { struct fit_histogram *hh; gsl_histogram *h = NULL; double amp, var, xl, xh, xi, yi, sqw; size_t i, binstart, binend; hh = (struct fit_histogram *) params; h = hh->h; binstart = hh->binstart; binend = hh->binend; var = gsl_vector_get(v, 0); amp = gsl_vector_get(v, 1); for (i = binstart; i <= binend; i++) { if (gsl_histogram_get_range(h, i, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); xi = (xl + xh)/2.0; yi = h->bin[i]; sqw = sqrt(yi); gsl_vector_set(f, i-binstart, (amp*xi*exp(-xi*xi/var/2.0) - yi)*sqw); } return GSL_SUCCESS; } static int Rayleigh_df(const gsl_vector *v, void *params, gsl_matrix *J) { struct fit_histogram *hh; gsl_histogram *h = NULL; double amp, var, xl, xh, xi, yi, y, sqw; size_t i, binstart, binend; hh = (struct fit_histogram *) params; h = hh->h; binstart = hh->binstart; binend = hh->binend; var = gsl_vector_get(v, 0); amp = gsl_vector_get(v, 1); for (i = binstart; i <= binend; i++) { if (gsl_histogram_get_range(h, i, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); xi = (xl + xh)/2.0; yi = h->bin[i]; sqw = sqrt(yi); y = xi*exp(-xi*xi/var/2.0); gsl_matrix_set(J, i-binstart, 0, amp*y*xi*xi/2/var/var*sqw); gsl_matrix_set(J, i-binstart, 1, y*sqw); } return GSL_SUCCESS; } static int Rayleigh_fdf(const gsl_vector *v, void *params, gsl_vector *f, gsl_matrix *J) { Rayleigh_f(v, params, f); Rayleigh_df(v, params, J); return GSL_SUCCESS; } static VALUE rb_gsl_histogram_fit_rayleigh(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; struct fit_histogram hh; const gsl_multifit_fdfsolver_type *T; gsl_multifit_fdfsolver *s; int status; size_t iter = 0, binstart, binend; size_t n, dof; /* # of data points */ size_t p = 2; /* # of fitting parameters */ gsl_multifit_function_fdf f; gsl_matrix *covar = NULL; gsl_vector *x = NULL; double sigma, height, errs, errh, chi2; Data_Get_Struct(obj, gsl_histogram, h); binstart = 0; binend = h->n - 1; switch (argc) { case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); binstart = FIX2INT(argv[0]); binend = FIX2INT(argv[1]); if (binend >= h->n) binend = h->n - 1; break; case 0: break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 2)", argc); break; } x = gsl_vector_alloc(p); gsl_vector_set(x, 0, gsl_pow_2(gsl_histogram_sigma(h))); /* initial values, var = 1 */ gsl_vector_set(x, 1, gsl_histogram_max_val(h)); hh.h = h; hh.binstart = binstart; hh.binend = binend; n = binend - binstart + 1; covar = gsl_matrix_alloc(p, p); f.f = Rayleigh_f; f.df = Rayleigh_df; f.fdf = Rayleigh_fdf; f.n = n; f.p = p; f.params = &hh; T = gsl_multifit_fdfsolver_lmsder; s = gsl_multifit_fdfsolver_alloc(T, n, p); gsl_multifit_fdfsolver_set(s, &f, x); do { iter++; status = gsl_multifit_fdfsolver_iterate(s); if (status) break; status = gsl_multifit_test_delta(s->dx, s->x, 1e-4, 1e-4); } while (status == GSL_CONTINUE); sigma = sqrt(gsl_vector_get(s->x, 0)); height = gsl_vector_get(s->x, 1)*sigma*sigma; gsl_multifit_covar(s->J, 0.0, covar); chi2 = gsl_pow_2(gsl_blas_dnrm2(s->f)); /* not reduced chi-square */ dof = n - p; errs = sqrt(chi2/dof*gsl_matrix_get(covar, 0, 0))/sigma/2; errh = sqrt(chi2/dof*gsl_matrix_get(covar, 1, 1)); gsl_multifit_fdfsolver_free(s); gsl_vector_free(x); gsl_matrix_free(covar); return rb_ary_new3(6, rb_float_new(sigma), rb_float_new(height), rb_float_new(errs), rb_float_new(errh), rb_float_new(chi2), INT2FIX(dof)); } /* * y(x) = Amp*exp(-a*x) */ static int xExponential_f(const gsl_vector *v, void *params, gsl_vector *f); static int xExponential_df(const gsl_vector *v, void *params, gsl_matrix * J); static int xExponential_f(const gsl_vector *v, void *params, gsl_vector *f) { struct fit_histogram *hh; gsl_histogram *h = NULL; double amp, b, xl, xh, xi, yi, sqw; size_t i, binstart, binend; hh = (struct fit_histogram *) params; h = hh->h; binstart = hh->binstart; binend = hh->binend; b = gsl_vector_get(v, 0); amp = gsl_vector_get(v, 1); for (i = binstart; i <= binend; i++) { if (gsl_histogram_get_range(h, i, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); xi = (xl + xh)/2.0; yi = h->bin[i]; sqw = sqrt(yi); gsl_vector_set(f, i-binstart, (amp*xi*exp(-b*xi) - yi)*sqw); } return GSL_SUCCESS; } static int xExponential_df(const gsl_vector *v, void *params, gsl_matrix *J) { struct fit_histogram *hh; gsl_histogram *h = NULL; double amp, b, xl, xh, xi, yi, y, sqw; size_t i, binstart, binend; hh = (struct fit_histogram *) params; h = hh->h; binstart = hh->binstart; binend = hh->binend; b = gsl_vector_get(v, 0); amp = gsl_vector_get(v, 1); for (i = binstart; i <= binend; i++) { if (gsl_histogram_get_range(h, i, &xl, &xh)) rb_raise(rb_eIndexError, "wrong index"); xi = (xl + xh)/2.0; yi = h->bin[i]; sqw = sqrt(yi); y = xi*exp(-b*xi); gsl_matrix_set(J, i-binstart, 0, -amp*y*xi*sqw); gsl_matrix_set(J, i-binstart, 1, y*sqw); } return GSL_SUCCESS; } static int xExponential_fdf(const gsl_vector *v, void *params, gsl_vector *f, gsl_matrix *J) { xExponential_f(v, params, f); xExponential_df(v, params, J); return GSL_SUCCESS; } static VALUE rb_gsl_histogram_fit_xexponential(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h = NULL; struct fit_histogram hh; const gsl_multifit_fdfsolver_type *T; gsl_multifit_fdfsolver *s; int status; size_t iter = 0, binstart, binend; size_t n, dof; /* # of data points */ size_t p = 2; /* # of fitting parameters */ gsl_multifit_function_fdf f; gsl_matrix *covar = NULL; gsl_vector *x = NULL; double b, height, errs, errh, chi2; Data_Get_Struct(obj, gsl_histogram, h); binstart = 0; binend = h->n - 1; switch (argc) { case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); binstart = FIX2INT(argv[0]); binend = FIX2INT(argv[1]); if (binend >= h->n) binend = h->n - 1; break; case 0: break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 2)", argc); break; } x = gsl_vector_alloc(p); gsl_vector_set(x, 0, gsl_histogram_sigma(h)); /* initial values, var = 1 */ gsl_vector_set(x, 1, gsl_histogram_max_val(h)); hh.h = h; hh.binstart = binstart; hh.binend = binend; n = binend - binstart + 1; covar = gsl_matrix_alloc(p, p); f.f = xExponential_f; f.df = xExponential_df; f.fdf = xExponential_fdf; f.n = n; f.p = p; f.params = &hh; T = gsl_multifit_fdfsolver_lmsder; s = gsl_multifit_fdfsolver_alloc(T, n, p); gsl_multifit_fdfsolver_set(s, &f, x); do { iter++; status = gsl_multifit_fdfsolver_iterate(s); if (status) break; status = gsl_multifit_test_delta(s->dx, s->x, 1e-4, 1e-4); } while (status == GSL_CONTINUE); b = gsl_vector_get(s->x, 0); height = gsl_vector_get(s->x, 1); gsl_multifit_covar(s->J, 0.0, covar); chi2 = gsl_pow_2(gsl_blas_dnrm2(s->f)); /* not reduced chi-square */ dof = n - p; errs = sqrt(chi2/dof*gsl_matrix_get(covar, 0, 0)); errh = sqrt(chi2/dof*gsl_matrix_get(covar, 1, 1)); gsl_multifit_fdfsolver_free(s); gsl_vector_free(x); gsl_matrix_free(covar); return rb_ary_new3(6, rb_float_new(b), rb_float_new(height), rb_float_new(errs), rb_float_new(errh), rb_float_new(chi2), INT2FIX(dof)); } static VALUE rb_gsl_histogram_fit(int argc, VALUE *argv, VALUE obj) { char fittype[32]; if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); Check_Type(argv[0], T_STRING); strcpy(fittype, STR2CSTR(argv[0])); if (str_head_grep(fittype, "exp") == 0) { return rb_gsl_histogram_fit_exponential(argc-1, argv+1, obj); } else if (str_head_grep(fittype, "power") == 0) { return rb_gsl_histogram_fit_power(argc-1, argv+1, obj); } else if (str_head_grep(fittype, "gaus") == 0) { return rb_gsl_histogram_fit_gaussian(argc-1, argv+1, obj); } else if (str_head_grep(fittype, "rayleigh") == 0) { return rb_gsl_histogram_fit_rayleigh(argc-1, argv+1, obj); } else if (str_head_grep(fittype, "xexp") == 0) { return rb_gsl_histogram_fit_xexponential(argc-1, argv+1, obj); } else { rb_raise(rb_eRuntimeError, "unknown fitting type %s (exp, power, gaus expected)", fittype); } return Qnil; } /* Integrate histogram: the two histograms must have the same range and bins. */ void mygsl_histogram_integrate(const gsl_histogram *h, gsl_histogram *hi, size_t istart, size_t iend) { size_t i; if (iend >= istart) { if (istart < 0) istart = 0; if (iend >= h->n) iend = h->n-1; hi->bin[istart] = h->bin[istart]; for (i = istart+1; i <= iend; i++) hi->bin[i] = hi->bin[i-1] + h->bin[i]; } else { if (istart >= h->n) istart = h->n-1; if (iend < 0) iend = 0; hi->bin[istart] = h->bin[istart]; for (i = istart-1; i >= iend; i--) { hi->bin[i] = hi->bin[i+1] + h->bin[i]; if (i == 0) break; } } } void mygsl_histogram_differentiate(const gsl_histogram *hi, gsl_histogram *h) { size_t i; h->bin[0] = hi->bin[0]; for (i = 1; i < hi->n; i++) h->bin[i] = hi->bin[i] - hi->bin[i-1]; } /* Create a histogram integrating the given histogram h */ gsl_histogram* mygsl_histogram_calloc_integrate(const gsl_histogram *h, size_t istart, size_t iend) { gsl_histogram *hi = NULL; hi = gsl_histogram_calloc_range(h->n, h->range); mygsl_histogram_integrate(h, hi, istart, iend); return hi; } gsl_histogram* mygsl_histogram_calloc_differentiate(const gsl_histogram *hi) { gsl_histogram *h = NULL; h = gsl_histogram_calloc_range(hi->n, hi->range); mygsl_histogram_differentiate(hi, h); return h; } static VALUE rb_gsl_histogram_integrate(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h, *hi; size_t istart, iend; int itmp; Data_Get_Struct(obj, gsl_histogram, h); switch (argc) { case 2: istart = FIX2INT(argv[0]); iend = FIX2INT(argv[1]); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: istart = FIX2INT(rb_ary_entry(argv[0], 0)); iend = FIX2INT(rb_ary_entry(argv[0], 1)); break; case T_FIXNUM: itmp = FIX2INT(argv[0]); if (itmp == -1) { istart = h->n - 1; iend = 0; } else { istart = 0; iend = h->n - 1; } break; default: rb_raise(rb_eArgError, "wrong argument type %s (Arran or Fixnum expected)", rb_class2name(CLASS_OF(argv[0]))); break; } break; case 0: istart = 0; iend = h->n - 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } hi = mygsl_histogram_calloc_integrate(h, istart, iend); return Data_Wrap_Struct(cgsl_histogram_integ, 0, gsl_histogram_free, hi); } static VALUE rb_gsl_histogram_differentiate(VALUE obj) { gsl_histogram *h, *hi; Data_Get_Struct(obj, gsl_histogram, hi); h = mygsl_histogram_calloc_differentiate(hi); return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, h); } static gsl_histogram* mygsl_histogram_rebin(const gsl_histogram *h, size_t m) { gsl_histogram *hnew; double w; size_t n, i, j, k; if (m > h->n) m = h->n; n = (size_t) h->n/m; if (n*m != h->n) n += 1; w = (h->range[h->n] - h->range[0])/h->n; hnew = gsl_histogram_alloc(n); for (i = 0, j = 0; i <= n; i++) { if (i*m <= h->n) hnew->range[i] = h->range[i*m]; else hnew->range[i] = w*m*i; } for (i = 0, j = 0; i < n; i++) { hnew->bin[i] = 0; for (k = 0; k < m && j < h->n; k++) hnew->bin[i] += h->bin[j++]; } return hnew; } static VALUE rb_gsl_histogram_rebin(int argc, VALUE *argv, VALUE obj) { gsl_histogram *h, *hnew; size_t m = 2; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); m = (size_t) FIX2INT(argv[0]); break; case 0: m = 2; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } Data_Get_Struct(obj, gsl_histogram, h); hnew = mygsl_histogram_rebin(h, m); return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, hnew); } static int mygsl_histogram_fread2(FILE * stream, gsl_histogram * h) { double min, max; int status; status = gsl_block_raw_fread(stream, &min, 1, 1); if (status) return status; status = gsl_block_raw_fread(stream, &max, 1, 1); if (status) return status; gsl_histogram_set_ranges_uniform(h, min, max); status = gsl_block_raw_fread (stream, h->bin, h->n, 1); if (status) return status; return status; } static int mygsl_histogram_fwrite2(FILE * stream, const gsl_histogram * h) { int status; status = gsl_block_raw_fwrite (stream, h->range, 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->range+h->n, 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->bin, h->n, 1); return status; } static VALUE rb_gsl_histogram_fwrite2(VALUE obj, VALUE io) { gsl_histogram *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram, h); f = rb_gsl_open_writefile(io, &flag); status = mygsl_histogram_fwrite2(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_histogram_fread2(VALUE obj, VALUE io) { gsl_histogram *h = NULL; FILE *f; int status, flag = 0; Data_Get_Struct(obj, gsl_histogram, h); f = rb_gsl_open_readfile(io, &flag); status = mygsl_histogram_fread2(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static gsl_histogram* mygsl_histogram_calloc_reverse(const gsl_histogram *h) { gsl_histogram *hnew; size_t i, n; hnew = gsl_histogram_alloc(h->n); n = h->n; for (i = 0; i <= n; i++) hnew->range[i] = h->range[n-i]; for (i = 0; i < n; i++) hnew->bin[i] = h->bin[n-1-i]; return hnew; } static VALUE rb_gsl_histogram_reverse(VALUE obj) { gsl_histogram *h, *hnew; Data_Get_Struct(obj, gsl_histogram, h); hnew = mygsl_histogram_calloc_reverse(h); return Data_Wrap_Struct(cgsl_histogram, 0, gsl_histogram_free, hnew); } /* The functions below are not included in GSL */ /* * Returns an x value at which the histogram integration * reaches the given percentile. The x value is calculated * by an interpolation between the ranges in which the percentile * is found. */ static double histogram_percentile(const gsl_histogram *h, double f) { double sum = gsl_histogram_sum(h), sf; double val, s = 0, x; double ri, ri1; size_t i; sf = sum * f; for (i = 0; i < h->n; i++) { val = gsl_histogram_get(h, i); if ((s+val) > sf) break; s += val; } ri = h->range[i]; ri1 = h->range[i+1]; x = (sf - s)*(ri1 - ri)/val + ri; return x; } static double histogram_median(const gsl_histogram *h) { return histogram_percentile(h, 0.5); } static VALUE rb_gsl_histogram_percentile(VALUE obj, VALUE f) { gsl_histogram *h; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(histogram_percentile(h, NUM2DBL(f))); } static VALUE rb_gsl_histogram_median(VALUE obj) { gsl_histogram *h; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(histogram_median(h)); } static double histogram_percentile_inv(const gsl_histogram *h, double x) { double sum = gsl_histogram_sum(h); double val, s = 0; double ri, ri1, q; size_t i; for (i = 0; i < h->n; i++) { val = gsl_histogram_get(h, i); if (h->range[i+1] > x) break; s += val; } ri = h->range[i]; ri1 = h->range[i+1]; q = s + val/(ri1 - ri)*(x - ri); return q/sum; } static VALUE rb_gsl_histogram_percentile_inv(VALUE obj, VALUE x) { gsl_histogram *h; Data_Get_Struct(obj, gsl_histogram, h); return rb_float_new(histogram_percentile_inv(h, NUM2DBL(x))); } void Init_gsl_histogram(VALUE module) { VALUE cgsl_histogram_pdf; cgsl_histogram = rb_define_class_under(module, "Histogram", cGSL_Object); cgsl_histogram_range = rb_define_class_under(cgsl_histogram, "Range", cgsl_vector_view_ro); cgsl_histogram_bin = rb_define_class_under(cgsl_histogram, "Bin", cgsl_vector_view); cgsl_histogram_integ = rb_define_class_under(cgsl_histogram, "Integral", cgsl_histogram); #ifdef GSL_0_9_4_LATER rb_define_singleton_method(cgsl_histogram, "alloc", rb_gsl_histogram_alloc, -1); /* rb_define_singleton_method(cgsl_histogram, "new", rb_gsl_histogram_alloc, -1);*/ rb_define_singleton_method(cgsl_histogram, "[]", rb_gsl_histogram_alloc, -1); rb_define_singleton_method(cgsl_histogram, "alloc_uniform", rb_gsl_histogram_alloc_uniform, -1); rb_define_singleton_method(cgsl_histogram, "new_uniform", rb_gsl_histogram_alloc_uniform, -1); rb_define_singleton_method(cgsl_histogram, "alloc_with_min_max_step", rb_gsl_histogram_alloc_with_min_max_step, 3); rb_define_singleton_method(cgsl_histogram, "new_with_min_max_step", rb_gsl_histogram_alloc_with_min_max_step, 3); #endif rb_define_singleton_method(cgsl_histogram, "calloc", rb_gsl_histogram_calloc, 1); rb_define_singleton_method(cgsl_histogram, "calloc_range", rb_gsl_histogram_calloc_range, -1); rb_define_method(cgsl_histogram, "bins", rb_gsl_histogram_bins, 0); rb_define_alias(cgsl_histogram, "n", "bins"); rb_define_alias(cgsl_histogram, "size", "bins"); rb_define_method(cgsl_histogram, "set_ranges", rb_gsl_histogram_set_ranges, -1); rb_define_method(cgsl_histogram, "range", rb_gsl_histogram_range, 0); rb_define_method(cgsl_histogram, "bin", rb_gsl_histogram_bin, 0); rb_define_method(cgsl_histogram, "set_ranges_uniform", rb_gsl_histogram_set_ranges_uniform, -1); rb_define_singleton_method(cgsl_histogram, "memcpy", rb_gsl_histogram_memcpy, 2); rb_define_method(cgsl_histogram, "clone", rb_gsl_histogram_clone, 0); rb_define_alias(cgsl_histogram, "duplicate", "clone"); rb_define_method(cgsl_histogram, "increment", rb_gsl_histogram_accumulate, -1); rb_define_alias(cgsl_histogram, "fill", "increment"); rb_define_alias(cgsl_histogram, "accumulate", "increment"); rb_define_method(cgsl_histogram, "increment2", rb_gsl_histogram_accumulate2, -1); rb_define_alias(cgsl_histogram, "accumulate2", "increment2"); rb_define_alias(cgsl_histogram, "fill2", "increment2"); rb_define_method(cgsl_histogram, "get", rb_gsl_histogram_get, 1); rb_define_alias(cgsl_histogram, "[]", "get"); rb_define_method(cgsl_histogram, "get_range", rb_gsl_histogram_get_range, 1); rb_define_method(cgsl_histogram, "max", rb_gsl_histogram_max, 0); rb_define_method(cgsl_histogram, "min", rb_gsl_histogram_min, 0); rb_define_method(cgsl_histogram, "reset", rb_gsl_histogram_reset, 0); rb_define_method(cgsl_histogram, "find", rb_gsl_histogram_find, 1); rb_define_method(cgsl_histogram, "max_val", rb_gsl_histogram_max_val, 0); rb_define_method(cgsl_histogram, "max_bin", rb_gsl_histogram_max_bin, 0); rb_define_method(cgsl_histogram, "min_val", rb_gsl_histogram_min_val, 0); rb_define_method(cgsl_histogram, "min_bin", rb_gsl_histogram_min_bin, 0); rb_define_method(cgsl_histogram, "mean", rb_gsl_histogram_mean, 0); rb_define_method(cgsl_histogram, "sigma", rb_gsl_histogram_sigma, 0); rb_define_method(cgsl_histogram, "sum", rb_gsl_histogram_integral, -1); rb_define_alias(cgsl_histogram, "integral", "sum"); rb_define_method(cgsl_histogram, "equal_bins_p", rb_gsl_histogram_equal_bins_p, -1); rb_define_alias(cgsl_histogram, "equal_bins", "equal_bins_p"); rb_define_singleton_method(cgsl_histogram, "equal_bins_p", rb_gsl_histogram_equal_bins_p, -1); rb_define_singleton_method(cgsl_histogram, "equal_bins", rb_gsl_histogram_equal_bins_p, -1); rb_define_method(cgsl_histogram, "equal_bins_p?", rb_gsl_histogram_equal_bins_p2, -1); rb_define_alias(cgsl_histogram, "equal_bins?", "equal_bins_p?"); rb_define_singleton_method(cgsl_histogram, "equal_bins_p?", rb_gsl_histogram_equal_bins_p2, -1); rb_define_singleton_method(cgsl_histogram, "equal_bins?", rb_gsl_histogram_equal_bins_p2, -1); rb_define_method(cgsl_histogram, "add", rb_gsl_histogram_add, 1); rb_define_alias(cgsl_histogram, "+", "add"); rb_define_method(cgsl_histogram, "sub", rb_gsl_histogram_sub, 1); rb_define_alias(cgsl_histogram, "-", "sub"); rb_define_method(cgsl_histogram, "mul", rb_gsl_histogram_mul, 1); rb_define_alias(cgsl_histogram, "*", "mul"); rb_define_method(cgsl_histogram, "div", rb_gsl_histogram_div, 1); rb_define_alias(cgsl_histogram, "/", "div"); rb_define_method(cgsl_histogram, "add!", rb_gsl_histogram_add2, 1); rb_define_method(cgsl_histogram, "sub!", rb_gsl_histogram_sub2, 1); rb_define_method(cgsl_histogram, "mul!", rb_gsl_histogram_mul2, 1); rb_define_method(cgsl_histogram, "div!", rb_gsl_histogram_div2, 1); rb_define_method(cgsl_histogram, "scale!", rb_gsl_histogram_scale_bang, -1); rb_define_method(cgsl_histogram, "scale", rb_gsl_histogram_scale, -1); rb_define_method(cgsl_histogram, "shift!", rb_gsl_histogram_shift, 1); rb_define_method(cgsl_histogram, "shift", rb_gsl_histogram_shift2, 1); rb_define_method(cgsl_histogram, "fwrite", rb_gsl_histogram_fwrite, 1); rb_define_method(cgsl_histogram, "fread", rb_gsl_histogram_fread, 1); rb_define_method(cgsl_histogram, "fwrite2", rb_gsl_histogram_fwrite2, 1); rb_define_method(cgsl_histogram, "fread2", rb_gsl_histogram_fread2, 1); rb_define_method(cgsl_histogram, "fprintf", rb_gsl_histogram_fprintf, -1); rb_define_method(cgsl_histogram, "printf", rb_gsl_histogram_printf, -1); rb_define_method(cgsl_histogram, "fscanf", rb_gsl_histogram_fscanf, 1); rb_define_method(cgsl_histogram, "print", rb_gsl_histogram_print, 0); cgsl_histogram_pdf = rb_define_class_under(cgsl_histogram, "Pdf", cGSL_Object); rb_define_singleton_method(cgsl_histogram_pdf, "alloc", rb_gsl_histogram_pdf_alloc, 1); /* rb_define_singleton_method(cgsl_histogram_pdf, "new", rb_gsl_histogram_pdf_alloc, 1);*/ #ifdef GSL_0_9_4_LATER rb_define_method(cgsl_histogram_pdf, "init", rb_gsl_histogram_pdf_init, 1); #endif rb_define_method(cgsl_histogram_pdf, "sample", rb_gsl_histogram_pdf_sample, 1); rb_define_method(cgsl_histogram_pdf, "range", rb_gsl_histogram_pdf_range, 0); rb_define_method(cgsl_histogram_pdf, "sum", rb_gsl_histogram_pdf_sum, 0); /*****/ rb_define_method(cgsl_histogram, "graph", rb_gsl_histogram_graph, -1); rb_define_alias(cgsl_histogram, "draw", "graph"); rb_define_method(cgsl_histogram, "plot", rb_gsl_histogram_plot, -1); rb_define_method(cgsl_histogram, "fit_gaussian", rb_gsl_histogram_fit_gaussian, -1); rb_define_method(cgsl_histogram, "fit_exponential", rb_gsl_histogram_fit_exponential, -1); rb_define_method(cgsl_histogram, "fit_xexponential", rb_gsl_histogram_fit_xexponential, -1); rb_define_method(cgsl_histogram, "fit_power", rb_gsl_histogram_fit_power, -1); rb_define_method(cgsl_histogram, "fit_rayleigh", rb_gsl_histogram_fit_rayleigh, -1); rb_define_method(cgsl_histogram, "fit", rb_gsl_histogram_fit, -1); rb_define_method(cgsl_histogram, "integrate", rb_gsl_histogram_integrate, -1); rb_undef_method(cgsl_histogram_integ, "integrate"); rb_define_method(cgsl_histogram_integ, "differentiate", rb_gsl_histogram_differentiate, 0); rb_define_alias(cgsl_histogram_integ, "diff", "differentiate"); rb_define_method(cgsl_histogram, "normalize", rb_gsl_histogram_normalize, 0); rb_define_method(cgsl_histogram, "normalize!", rb_gsl_histogram_normalize_bang, 0); rb_define_method(cgsl_histogram, "rebin", rb_gsl_histogram_rebin, -1); rb_define_alias(cgsl_histogram, "mergebin", "rebin"); rb_define_method(cgsl_histogram, "reverse", rb_gsl_histogram_reverse, 0); rb_define_method(cgsl_histogram, "percentile", rb_gsl_histogram_percentile, 1); rb_define_method(cgsl_histogram, "median", rb_gsl_histogram_median, 0); rb_define_method(cgsl_histogram, "percentile_inv", rb_gsl_histogram_percentile_inv, 1); } gsl-1.15.3/ext/vector.c0000644000175000017500000000157412220252463014217 0ustar boutilboutil/* vector.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ /* This code uses "templates_on.h" and "templates_off.h", which are provided by the GSL source. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_histogram.h" #include "rb_gsl_complex.h" #include "rb_gsl_poly.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif #define BASE_DOUBLE #include "templates_on.h" #include "vector_source.c" #include "templates_off.h" #undef BASE_DOUBLE #define BASE_INT #include "templates_on.h" #include "vector_source.c" #include "templates_off.h" #undef BASE_INT gsl-1.15.3/ext/stats.c0000644000175000017500000006773212220252463014063 0ustar boutilboutil/* stats.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_statistics.h" #ifdef HAVE_NARRAY_H #include "narray.h" #endif static double* get_vector_stats2(int argc, VALUE *argv, VALUE obj, size_t *stride, size_t *size) { double *v = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); v = get_vector_ptr(argv[0], stride, size); break; default: v = get_vector_ptr(obj, stride, size); break; } return v; } static VALUE rb_gsl_stats_XXX(int argc, VALUE *argv, VALUE obj, double (*f)(const double*, size_t, size_t)) { size_t stride, size; double *data = NULL; data = get_vector_stats2(argc, argv, obj, &stride, &size); return rb_float_new((*f)(data, stride, size)); } static VALUE rb_gsl_stats_XXX1(int argc, VALUE *argv, VALUE obj, double (*f)(const double*, size_t, size_t, double)) { size_t stride, size; double *data = NULL; if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); data = get_vector_stats2(argc, argv, obj, &stride, &size); return rb_float_new((*f)(data, stride, size, NUM2DBL(argv[argc-1]))); } static VALUE rb_gsl_stats_XXX2(int argc, VALUE *argv, VALUE obj, double (*f)(const double*, size_t, size_t), double (*fm)(const double*, size_t, size_t, double, double)) { double x, a, b, *data = NULL; size_t stride, size; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: data = get_vector_ptr(argv[0], &stride, &size); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); x = (*fm)(data, stride, size, a, b); break; case 1: data = get_vector_ptr(argv[0], &stride, &size); x = (*f)(data, stride, size); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: switch (argc) { case 0: data = get_vector_ptr(obj, &stride, &size); x = (*f)(data, stride, size); break; case 1: data = get_vector_ptr(obj, &stride, &size); a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); x = (*fm)(data, stride, size, a, b); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } break; } return rb_float_new(x); } static VALUE rb_gsl_stats_mean(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX(argc, argv, obj, gsl_stats_mean); } static VALUE rb_gsl_stats_XXX_m(int argc, VALUE *argv, VALUE obj, double (*f)(const double*, size_t, size_t), double (*fm)(const double*, size_t, size_t, double)) { double x, mean, *data = NULL; size_t stride, size; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: data = get_vector_ptr(argv[0], &stride, &size); mean = NUM2DBL(argv[1]); x = (*fm)(data, stride, size, mean); break; case 1: data = get_vector_ptr(argv[0], &stride, &size); x = (*f)(data, stride, size); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: switch (argc) { case 0: data = get_vector_ptr(obj, &stride, &size); x = (*f)(data, stride, size); break; case 1: data = get_vector_ptr(obj, &stride, &size); mean = NUM2DBL(argv[0]); x = (*fm)(data, stride, size, mean); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } break; } return rb_float_new(x); } static VALUE rb_gsl_stats_variance_m(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX_m(argc, argv, obj, gsl_stats_variance, gsl_stats_variance_m); } static VALUE rb_gsl_stats_sd_m(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX_m(argc, argv, obj, gsl_stats_sd, gsl_stats_sd_m); } #ifdef GSL_1_11_LATER static VALUE rb_gsl_stats_tss_m(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX_m(argc, argv, obj, gsl_stats_tss, gsl_stats_tss_m); } #endif static VALUE rb_gsl_stats_variance_with_fixed_mean(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX1(argc, argv, obj, gsl_stats_variance_with_fixed_mean); } static VALUE rb_gsl_stats_sd_with_fixed_mean(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX1(argc, argv, obj, gsl_stats_sd_with_fixed_mean); } static VALUE rb_gsl_stats_absdev_m(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX_m(argc, argv, obj, gsl_stats_absdev, gsl_stats_absdev_m); } static VALUE rb_gsl_stats_skew(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX2(argc, argv, obj, gsl_stats_skew, gsl_stats_skew_m_sd); } static VALUE rb_gsl_stats_kurtosis(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX2(argc, argv, obj, gsl_stats_kurtosis, gsl_stats_kurtosis_m_sd); } static VALUE rb_gsl_stats_lag1_autocorrelation(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX_m(argc, argv, obj, gsl_stats_lag1_autocorrelation, gsl_stats_lag1_autocorrelation_m); } /****************************/ static void get_vector_stats3(int argc, VALUE *argv, VALUE obj, double **w, size_t *stridew, size_t *sizew, double **x, size_t *stridex, size_t *sizex) { switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2) rb_raise(rb_eArgError, "too few arguments"); *w = get_vector_ptr(argv[0], stridew, sizew); *x = get_vector_ptr(argv[1], stridex, sizex); break; default: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); *x = get_vector_ptr(obj, stridex, sizex); *w = get_vector_ptr(argv[0], stridew, sizew); break; } } static VALUE rb_gsl_stats_wXXX(int argc, VALUE *argv, VALUE obj, double (*f)(const double*, size_t, const double*, size_t, size_t)) { double *w, *x; double mean; size_t sizew, stridew, sizex, stridex; get_vector_stats3(argc, argv, obj, &w, &stridew, &sizew, &x, &stridex, &sizex); mean = (*f)(w, stridew, x, stridex, sizex); return rb_float_new(mean); } static VALUE rb_gsl_stats_wXXX_m(int argc, VALUE *argv, VALUE obj, double (*f)(const double*, size_t, const double*, size_t, size_t, double)) { double *w, *x; double mean; size_t sizew, stridew, sizex, stridex; get_vector_stats3(argc, argv, obj, &w, &stridew, &sizew, &x, &stridex, &sizex); mean = (*f)(w, stridew, x, stridex, sizex, NUM2DBL(argv[argc-1])); return rb_float_new(mean); } static VALUE rb_gsl_stats_wmean(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX(argc, argv, obj, gsl_stats_wmean); } static VALUE rb_gsl_stats_wvariance(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX(argc, argv, obj, gsl_stats_wvariance); } static VALUE rb_gsl_stats_wsd(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX(argc, argv, obj, gsl_stats_wsd); } static VALUE rb_gsl_stats_wvariance_m(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX_m(argc, argv, obj, gsl_stats_wvariance_m); } static VALUE rb_gsl_stats_wsd_m(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX_m(argc, argv, obj, gsl_stats_wsd_m); } static VALUE rb_gsl_stats_wvariance_with_fixed_mean(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX_m(argc, argv, obj, gsl_stats_wvariance_with_fixed_mean); } static VALUE rb_gsl_stats_wsd_with_fixed_mean(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX_m(argc, argv, obj, gsl_stats_wsd_with_fixed_mean); } static VALUE rb_gsl_stats_wabsdev(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX(argc, argv, obj, gsl_stats_wabsdev); } static VALUE rb_gsl_stats_wabsdev_m(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX_m(argc, argv, obj, gsl_stats_wabsdev_m); } static VALUE rb_gsl_stats_wskew(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX(argc, argv, obj, gsl_stats_wskew); } static VALUE rb_gsl_stats_wkurtosis(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_wXXX(argc, argv, obj, gsl_stats_wkurtosis); } static VALUE rb_gsl_stats_wskew_m_sd(VALUE obj, VALUE ww, VALUE wm, VALUE wsd) { double *w, *x; size_t stridew, stridex, sizew, sizex; double skew_m; x = get_vector_ptr(obj, &stridex, &sizex); w = get_vector_ptr(ww, &stridew, &sizew); skew_m = gsl_stats_wskew_m_sd(w, stridew, x, stridex, sizex, NUM2DBL(wm), NUM2DBL(wsd)); return rb_float_new(skew_m); } static VALUE rb_gsl_stats_wkurtosis_m_sd(VALUE obj, VALUE ww, VALUE wm, VALUE wsd) { double *w, *x; size_t stridew, stridex, sizew, sizex; double kurtosis_m; x = get_vector_ptr(obj, &stridex, &sizex); w = get_vector_ptr(ww, &stridew, &sizew); kurtosis_m = gsl_stats_wkurtosis_m_sd(w, stridew, x, stridex, sizex, NUM2DBL(wm), NUM2DBL(wsd)); return rb_float_new(kurtosis_m); } static VALUE rb_gsl_stats_max(int argc, VALUE *argv, VALUE obj) { size_t stride, size; double max, *data = NULL; data = get_vector_stats2(argc, argv, obj, &stride, &size); max = gsl_stats_max(data, stride, size); return rb_float_new(max); } static VALUE rb_gsl_stats_min(int argc, VALUE *argv, VALUE obj) { double min, *data = NULL; size_t stride, size; data = get_vector_stats2(argc, argv, obj, &stride, &size); min = gsl_stats_min(data, stride, size); return rb_float_new(min); } static VALUE rb_gsl_stats_minmax(int argc, VALUE *argv, VALUE obj) { size_t stride, size; double min, max, *data = NULL; data = get_vector_stats2(argc, argv, obj, &stride, &size); gsl_stats_minmax(&min, &max, data, stride, size); return rb_ary_new3(2, rb_float_new(min), rb_float_new(max)); } static VALUE rb_gsl_stats_max_index(int argc, VALUE *argv, VALUE obj) { double *data = NULL; size_t index, stride, size; data = get_vector_stats2(argc, argv, obj, &stride, &size); index = gsl_stats_max_index(data, stride, size); return INT2FIX(index); } static VALUE rb_gsl_stats_min_index(int argc, VALUE *argv, VALUE obj) { double *data = NULL; size_t index, stride, size; data = get_vector_stats2(argc, argv, obj, &stride, &size); index = gsl_stats_min_index(data, stride, size); return INT2FIX(index); } static VALUE rb_gsl_stats_minmax_index(int argc, VALUE *argv, VALUE obj) { double *data = NULL; size_t imin, imax, stride, size; data = get_vector_stats2(argc, argv, obj, &stride, &size); gsl_stats_minmax_index(&imin, &imax, data, stride, size); return rb_ary_new3(2, INT2FIX(imin), INT2FIX(imax)); } static VALUE rb_gsl_stats_median_from_sorted_data(int argc, VALUE *argv, VALUE obj) { size_t stride, size; double median, *data = NULL; data = get_vector_stats2(argc, argv, obj, &stride, &size); median = gsl_stats_median_from_sorted_data(data, stride, size); return rb_float_new(median); } static VALUE rb_gsl_stats_median(int argc, VALUE *argv, VALUE obj) { size_t stride, size; double median, *data = NULL, *data2 = NULL; data = get_vector_stats2(argc, argv, obj, &stride, &size); data2 = (double *) malloc(sizeof(double)*size*stride); memcpy(data2, data, sizeof(double)*size*stride); gsl_sort(data2, stride, size); median = gsl_stats_median_from_sorted_data(data2, stride, size); free(data2); return rb_float_new(median); } static VALUE rb_gsl_stats_quantile_from_sorted_data(int argc, VALUE *argv, VALUE obj) { return rb_gsl_stats_XXX1(argc, argv, obj, gsl_stats_quantile_from_sorted_data); /* size_t stride, size; double quantile, *data = NULL; data = get_vector_ptr(obj, &stride, &size); quantile = gsl_stats_quantile_from_sorted_data(data, stride, size, NUM2DBL(f)); return rb_float_new(quantile);*/ } /* static VALUE rb_gsl_stats_quantile(int argc, VALUE *argv, VALUE obj) { size_t stride, size; double quantile, *data = NULL, *data2 = NULL; data = get_vector_stats2(argc, argv, obj, &stride, &size); data2 = (double *) malloc(sizeof(double)*size*stride); memcpy(data2, data, sizeof(double)*size*stride); gsl_sort(data2, stride, size); quantile = gsl_stats_quantile_from_sorted_data(data2, stride, size); free(data2); return rb_float_new(quantile); } */ static VALUE rb_gsl_stats_covariance2(VALUE obj, VALUE vv1, VALUE vv2) { double *data1, *data2; size_t stride1, stride2, size; data1 = get_vector_ptr(vv1, &stride1, &size); data2 = get_vector_ptr(vv2, &stride2, &size); return rb_float_new(gsl_stats_covariance(data1, stride1, data2, stride2, size)); } static VALUE rb_gsl_stats_covariance_m2(VALUE obj, VALUE vv1, VALUE vv2, VALUE m1, VALUE m2) { double *data1, *data2; size_t stride1, stride2, size; data1 = get_vector_ptr(vv1, &stride1, &size); data2 = get_vector_ptr(vv2, &stride2, &size); return rb_float_new(gsl_stats_covariance_m(data1, stride1, data2, stride2, size, NUM2DBL(m1), NUM2DBL(m2))); } #ifdef GSL_1_10_LATER static VALUE rb_gsl_stats_correlation(VALUE obj, VALUE vv1, VALUE vv2) { double *data1, *data2; size_t stride1, stride2, size; data1 = get_vector_ptr(vv1, &stride1, &size); data2 = get_vector_ptr(vv2, &stride2, &size); return rb_float_new(gsl_stats_correlation(data1, stride1, data2, stride2, size)); } static VALUE rb_gsl_stats_pvariance(VALUE obj, VALUE vv1, VALUE vv2) { double *data1, *data2; size_t stride1, stride2, size1, size2; data1 = get_vector_ptr(vv1, &stride1, &size1); data2 = get_vector_ptr(vv2, &stride2, &size2); return rb_float_new(gsl_stats_pvariance(data1, stride1, size1, data2, stride2, size2)); } static VALUE rb_gsl_stats_ttest(VALUE obj, VALUE vv1, VALUE vv2) { double *data1, *data2; size_t stride1, stride2, size1, size2; data1 = get_vector_ptr(vv1, &stride1, &size1); data2 = get_vector_ptr(vv2, &stride2, &size2); return rb_float_new(gsl_stats_ttest(data1, stride1, size1, data2, stride2, size2)); } #endif static VALUE rb_gsl_stats_wmean2(VALUE obj, VALUE ww, VALUE dd) { double wmean, *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); wmean = gsl_stats_wmean(dataw, stridew, data, strided, size); return rb_float_new(wmean); } static VALUE rb_gsl_stats_wvariance2(VALUE obj, VALUE ww, VALUE dd) { double wvariance, *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); wvariance = gsl_stats_wvariance(dataw, stridew, data, strided, size); return rb_float_new(wvariance); } static VALUE rb_gsl_stats_wvariance_m2(VALUE obj, VALUE ww, VALUE dd, VALUE mm) { double *dataw = NULL, *data = NULL; double wvariance, m; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); m = NUM2DBL(mm); wvariance = gsl_stats_wvariance_m(dataw, stridew, data, strided, size, m); return rb_float_new(wvariance); } static VALUE rb_gsl_stats_wsd2(VALUE obj, VALUE ww, VALUE dd) { double wsd, *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); wsd = gsl_stats_wsd(dataw, stridew, data, strided, size); return rb_float_new(wsd); } static VALUE rb_gsl_stats_wsd_m2(VALUE obj, VALUE ww, VALUE dd, VALUE mm) { double *dataw = NULL, *data = NULL; double wsd, m; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); m = NUM2DBL(mm); wsd = gsl_stats_wsd_m(dataw, stridew, data, strided, size, m); return rb_float_new(wsd); } static VALUE rb_gsl_stats_wvariance_with_fixed_mean2(VALUE obj, VALUE ww, VALUE dd, VALUE mm) { double wvariance, m; double *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); m = NUM2DBL(mm); wvariance = gsl_stats_wvariance_with_fixed_mean(dataw, stridew, data, strided, size, m); return rb_float_new(wvariance); } static VALUE rb_gsl_stats_wsd_with_fixed_mean2(VALUE obj, VALUE ww, VALUE dd, VALUE mm) { double wsd, m; double *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); m = NUM2DBL(mm); wsd = gsl_stats_wsd_with_fixed_mean(dataw, stridew, data, strided, size, m); return rb_float_new(wsd); } static VALUE rb_gsl_stats_wabsdev2(VALUE obj, VALUE ww, VALUE dd) { double wabsdev, *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); wabsdev = gsl_stats_wabsdev(dataw, stridew, data, strided, size); return rb_float_new(wabsdev); } static VALUE rb_gsl_stats_wabsdev_m2(VALUE obj, VALUE ww, VALUE dd, VALUE mm) { double *dataw = NULL, *data = NULL; double wabsdev, m; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); m = NUM2DBL(mm); wabsdev = gsl_stats_wabsdev_m(dataw, stridew, data, strided, size, m); return rb_float_new(wabsdev); } static VALUE rb_gsl_stats_wskew2(VALUE obj, VALUE ww, VALUE dd) { double wskew, *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); wskew = gsl_stats_wskew(dataw, stridew, data, strided, size); return rb_float_new(wskew); } static VALUE rb_gsl_stats_wskew_m2(VALUE obj, VALUE ww, VALUE dd, VALUE mm, VALUE ss) { double *dataw = NULL, *data = NULL; double wskew, m, sd; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); m = NUM2DBL(mm); sd = NUM2DBL(ss); wskew = gsl_stats_wskew_m_sd(dataw, stridew, data, strided, size, m, sd); return rb_float_new(wskew); } static VALUE rb_gsl_stats_wkurtosis2(VALUE obj, VALUE ww, VALUE dd) { double wkurtosis, *dataw = NULL, *data = NULL; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); wkurtosis = gsl_stats_wkurtosis(dataw, stridew, data, strided, size); return rb_float_new(wkurtosis); } static VALUE rb_gsl_stats_wkurtosis_m2(VALUE obj, VALUE ww, VALUE dd, VALUE mm, VALUE ss) { double *dataw = NULL, *data = NULL; double wkurtosis, m, sd; size_t stridew, strided, size; dataw = get_vector_ptr(ww, &stridew, &size); data = get_vector_ptr(dd, &strided, &size); m = NUM2DBL(mm); sd = NUM2DBL(ss); wkurtosis = gsl_stats_wkurtosis_m_sd(dataw, stridew, data, strided, size, m, sd); return rb_float_new(wkurtosis); } void Init_gsl_stats(VALUE module) { VALUE mgsl_stats; mgsl_stats = rb_define_module_under(module, "Stats"); rb_define_singleton_method(mgsl_stats, "mean", rb_gsl_stats_mean, -1); rb_define_method(cgsl_vector, "stats_mean", rb_gsl_stats_mean, -1); rb_define_alias(cgsl_vector, "mean", "stats_mean"); rb_define_alias(cgsl_vector, "average", "stats_mean"); rb_define_singleton_method(mgsl_stats, "variance", rb_gsl_stats_variance_m, -1); rb_define_singleton_method(mgsl_stats, "variance_m", rb_gsl_stats_variance_m, -1); rb_define_method(cgsl_vector, "stats_variance_m", rb_gsl_stats_variance_m, -1); rb_define_alias(cgsl_vector, "variance_m", "stats_variance_m"); rb_define_alias(cgsl_vector, "variance", "stats_variance_m"); rb_define_alias(cgsl_vector, "var", "stats_variance_m"); rb_define_singleton_method(mgsl_stats, "sd", rb_gsl_stats_sd_m, -1); rb_define_singleton_method(mgsl_stats, "sd_m", rb_gsl_stats_sd_m, -1); #ifdef GSL_1_11_LATER rb_define_singleton_method(mgsl_stats, "tss", rb_gsl_stats_tss_m, -1); rb_define_singleton_method(mgsl_stats, "tss_m", rb_gsl_stats_tss_m, -1); #endif rb_define_singleton_method(mgsl_stats, "sdev", rb_gsl_stats_sd_m, -1); rb_define_singleton_method(mgsl_stats, "sigma", rb_gsl_stats_sd_m, -1); rb_define_method(cgsl_vector, "stats_sd_m", rb_gsl_stats_sd_m, -1); rb_define_alias(cgsl_vector, "sd_m", "stats_sd_m"); rb_define_alias(cgsl_vector, "stats_sd", "stats_sd_m"); rb_define_alias(cgsl_vector, "sd", "stats_sd_m"); rb_define_alias(cgsl_vector, "sigma", "stats_sd_m"); rb_define_alias(cgsl_vector, "sdev", "stats_sd_m"); #ifdef GSL_1_11_LATER rb_define_method(cgsl_vector, "stats_tss_m", rb_gsl_stats_tss_m, -1); rb_define_alias(cgsl_vector, "stats_tss", "stats_tss_m"); rb_define_alias(cgsl_vector, "tss_m", "stats_tss_m"); rb_define_alias(cgsl_vector, "tss", "stats_tss_m"); #endif rb_define_singleton_method(mgsl_stats, "variance_with_fixed_mean", rb_gsl_stats_variance_with_fixed_mean, -1); rb_define_method(cgsl_vector, "stats_variance_with_fixed_mean", rb_gsl_stats_variance_with_fixed_mean, -1); rb_define_alias(cgsl_vector, "variance_with_fixed_mean", "stats_variance_with_fixed_mean"); rb_define_singleton_method(mgsl_stats, "sd_with_fixed_mean", rb_gsl_stats_sd_with_fixed_mean, -1); rb_define_method(cgsl_vector, "stats_sd_with_fixed_mean", rb_gsl_stats_sd_with_fixed_mean, -1); rb_define_alias(cgsl_vector, "sd_with_fixed_mean", "stats_sd_with_fixed_mean"); rb_define_singleton_method(mgsl_stats, "absdev", rb_gsl_stats_absdev_m, -1); rb_define_singleton_method(mgsl_stats, "absdev_m", rb_gsl_stats_absdev_m, -1); rb_define_method(cgsl_vector, "stats_absdev_m", rb_gsl_stats_absdev_m, -1); rb_define_alias(cgsl_vector, "absdev_m", "stats_absdev_m"); rb_define_alias(cgsl_vector, "absdev", "stats_absdev_m"); rb_define_singleton_method(mgsl_stats, "skew", rb_gsl_stats_skew, -1); rb_define_singleton_method(mgsl_stats, "skew_m", rb_gsl_stats_skew, -1); rb_define_method(cgsl_vector, "stats_skew_m", rb_gsl_stats_skew, -1); rb_define_alias(cgsl_vector, "skew_m", "stats_skew_m"); rb_define_alias(cgsl_vector, "skew", "stats_skew_m"); rb_define_singleton_method(mgsl_stats, "kurtosis", rb_gsl_stats_kurtosis, -1); rb_define_singleton_method(mgsl_stats, "kurtosis_m", rb_gsl_stats_kurtosis, -1); rb_define_method(cgsl_vector, "stats_kurtosis_m", rb_gsl_stats_kurtosis, -1); rb_define_alias(cgsl_vector, "kurtosis_m", "stats_kurtosis_m"); rb_define_alias(cgsl_vector, "kurtosis", "stats_kurtosis_m"); rb_define_singleton_method(mgsl_stats, "lag1_autocorrelation", rb_gsl_stats_lag1_autocorrelation, -1); rb_define_singleton_method(mgsl_stats, "lag1_autocorrelation_m", rb_gsl_stats_lag1_autocorrelation, -1); rb_define_method(cgsl_vector, "stats_lag1_autocorrelation_m", rb_gsl_stats_lag1_autocorrelation, -1); rb_define_alias(cgsl_vector, "lag1_autocorrelation_m", "stats_lag1_autocorrelation_m"); rb_define_alias(cgsl_vector, "lag1_autocorrelation", "stats_lag1_autocorrelation_m"); rb_define_singleton_method(mgsl_stats, "covariance", rb_gsl_stats_covariance2, 2); rb_define_singleton_method(mgsl_stats, "covariance_m", rb_gsl_stats_covariance_m2, 4); #ifdef GSL_1_10_LATER rb_define_singleton_method(mgsl_stats, "correlation", rb_gsl_stats_correlation, 2); rb_define_singleton_method(mgsl_stats, "pvariance", rb_gsl_stats_pvariance, 2); rb_define_singleton_method(mgsl_stats, "ttest", rb_gsl_stats_ttest, 2); #endif /*****/ rb_define_singleton_method(mgsl_stats, "wmean", rb_gsl_stats_wmean2, -1); rb_define_singleton_method(mgsl_stats, "wvariance", rb_gsl_stats_wvariance2, -1); rb_define_singleton_method(mgsl_stats, "wvariance_m", rb_gsl_stats_wvariance_m2, -1); rb_define_singleton_method(mgsl_stats, "wsd", rb_gsl_stats_wsd2, -1); rb_define_singleton_method(mgsl_stats, "wsd_m", rb_gsl_stats_wsd_m2, -1); rb_define_singleton_method(mgsl_stats, "wvariance_with_fixed_mean", rb_gsl_stats_wvariance_with_fixed_mean2, -1); rb_define_singleton_method(mgsl_stats, "wsd_with_fixed_mean", rb_gsl_stats_wsd_with_fixed_mean2, -1); rb_define_singleton_method(mgsl_stats, "wabsdev", rb_gsl_stats_wabsdev2, -1); rb_define_singleton_method(mgsl_stats, "wabsdev_m", rb_gsl_stats_wabsdev_m2, -1); rb_define_singleton_method(mgsl_stats, "wskew", rb_gsl_stats_wskew2, -1); rb_define_singleton_method(mgsl_stats, "wskew_m_sd", rb_gsl_stats_wskew_m2, 4); rb_define_singleton_method(mgsl_stats, "wkurtosis", rb_gsl_stats_wkurtosis2, -1); rb_define_singleton_method(mgsl_stats, "wkurtosis_m_sd", rb_gsl_stats_wkurtosis_m2, 4); /*****/ rb_define_method(cgsl_vector, "stats_wmean", rb_gsl_stats_wmean, -1); rb_define_alias(cgsl_vector, "wmean", "stats_wmean"); rb_define_method(cgsl_vector, "stats_wvariance", rb_gsl_stats_wvariance, -1); rb_define_alias(cgsl_vector, "wvariance", "stats_wvariance"); rb_define_method(cgsl_vector, "stats_wvariance_m", rb_gsl_stats_wvariance_m, -1); rb_define_alias(cgsl_vector, "wvariance_m", "stats_wvariance_m"); rb_define_method(cgsl_vector, "stats_wsd", rb_gsl_stats_wsd, -1); rb_define_alias(cgsl_vector, "wsd", "stats_wsd"); rb_define_method(cgsl_vector, "stats_wsd_m", rb_gsl_stats_wsd_m, -1); rb_define_alias(cgsl_vector, "wsd_m", "stats_wsd_m"); rb_define_method(cgsl_vector, "stats_wvariance_with_fixed_mean", rb_gsl_stats_wvariance_with_fixed_mean, -1); rb_define_alias(cgsl_vector, "wvariance_with_fixed_mean", "stats_wvariance_with_fixed_mean"); rb_define_method(cgsl_vector, "stats_wsd_with_fixed_mean", rb_gsl_stats_wsd_with_fixed_mean, -1); rb_define_alias(cgsl_vector, "wsd_with_fixed_mean", "stats_wsd_with_fixed_mean"); rb_define_method(cgsl_vector, "stats_wabsdev", rb_gsl_stats_wabsdev, -1); rb_define_alias(cgsl_vector, "wabsdev", "stats_wabsdev"); rb_define_method(cgsl_vector, "stats_wabsdev_m", rb_gsl_stats_wabsdev_m, -1); rb_define_alias(cgsl_vector, "wabsdev_m", "stats_wabsdev_m"); rb_define_method(cgsl_vector, "stats_wskew", rb_gsl_stats_wskew, -1); rb_define_alias(cgsl_vector, "wskew", "stats_wskew"); rb_define_method(cgsl_vector, "stats_wskew_m_sd", rb_gsl_stats_wskew_m_sd, 2); rb_define_alias(cgsl_vector, "wskew_m_sd", "stats_wskew_m_sd"); rb_define_method(cgsl_vector, "stats_wkurtosis", rb_gsl_stats_wkurtosis, -1); rb_define_alias(cgsl_vector, "wkurtosis", "stats_wkurtosis"); rb_define_method(cgsl_vector, "stats_wkurtosis_m_sd", rb_gsl_stats_wkurtosis_m_sd, 2); rb_define_alias(cgsl_vector, "wkurtosis_m_sd", "stats_wkurtosis_m_sd"); /*****/ rb_define_singleton_method(mgsl_stats, "max", rb_gsl_stats_max, -1); rb_define_singleton_method(mgsl_stats, "min", rb_gsl_stats_min, -1); rb_define_singleton_method(mgsl_stats, "minmax", rb_gsl_stats_minmax, -1); rb_define_singleton_method(mgsl_stats, "max_index", rb_gsl_stats_max_index, -1); rb_define_singleton_method(mgsl_stats, "min_index", rb_gsl_stats_min_index, -1); rb_define_singleton_method(mgsl_stats, "minmax_index", rb_gsl_stats_minmax_index, -1); rb_define_method(cgsl_vector, "stats_max", rb_gsl_stats_max, -1); rb_define_method(cgsl_vector, "stats_min", rb_gsl_stats_min, -1); rb_define_method(cgsl_vector, "stats_minmax", rb_gsl_stats_minmax, -1); rb_define_method(cgsl_vector, "stats_max_index", rb_gsl_stats_max_index, -1); rb_define_method(cgsl_vector, "stats_min_index", rb_gsl_stats_min_index, -1); rb_define_method(cgsl_vector, "stats_minmax_index", rb_gsl_stats_minmax_index, -1); rb_define_singleton_method(mgsl_stats, "median_from_sorted_data", rb_gsl_stats_median_from_sorted_data, -1); rb_define_method(cgsl_vector, "stats_median_from_sorted_data", rb_gsl_stats_median_from_sorted_data, -1); rb_define_alias(cgsl_vector, "median_from_sorted_data", "stats_median_from_sorted_data"); rb_define_method(cgsl_vector, "median", rb_gsl_stats_median, -1); rb_define_method(cgsl_vector, "stats_quantile_from_sorted_data", rb_gsl_stats_quantile_from_sorted_data, -1); rb_define_alias(cgsl_vector, "quantile_from_sorted_data", "stats_quantile_from_sorted_data"); } gsl-1.15.3/ext/sf_psi.c0000644000175000017500000000516512220252463014200 0ustar boutilboutil/* sf_psi.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_psi_int(VALUE obj, VALUE n) { return rb_gsl_sf_eval1_int(gsl_sf_psi_int, n); } static VALUE rb_gsl_sf_psi_int_e(VALUE obj, VALUE n) { return rb_gsl_sf_eval_e_int(gsl_sf_psi_int_e, n); } static VALUE rb_gsl_sf_psi(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_psi, x); } static VALUE rb_gsl_sf_psi_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_psi_e, x); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_sf_psi_1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_psi_1, x); } #endif #ifdef GSL_1_4_9_LATER static VALUE rb_gsl_sf_psi_1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_psi_1_e, x); } #endif static VALUE rb_gsl_sf_psi_1piy(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_psi_1piy, x); } static VALUE rb_gsl_sf_psi_1piy_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_psi_1piy_e, x); } static VALUE rb_gsl_sf_psi_1_int(VALUE obj, VALUE n) { return rb_gsl_sf_eval1_int(gsl_sf_psi_1_int, n); } static VALUE rb_gsl_sf_psi_1_int_e(VALUE obj, VALUE n) { return rb_gsl_sf_eval_e_int(gsl_sf_psi_1_int_e, n); } static VALUE rb_gsl_sf_psi_n(VALUE obj, VALUE m, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_psi_n, m, x); } static VALUE rb_gsl_sf_psi_n_e(VALUE obj, VALUE m, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_psi_n_e, m, x); } void Init_gsl_sf_psi(VALUE module) { rb_define_module_function(module, "psi_int", rb_gsl_sf_psi_int, 1); rb_define_module_function(module, "psi_int_e", rb_gsl_sf_psi_int_e, 1); rb_define_module_function(module, "psi_1piy", rb_gsl_sf_psi_1piy, 1); rb_define_module_function(module, "psi_1piy_e", rb_gsl_sf_psi_1piy_e, 1); rb_define_module_function(module, "psi_1_int", rb_gsl_sf_psi_1_int, 1); rb_define_module_function(module, "psi_1_int_e", rb_gsl_sf_psi_1_int_e, 1); rb_define_module_function(module, "psi_n", rb_gsl_sf_psi_n, 2); rb_define_module_function(module, "psi_n_e", rb_gsl_sf_psi_n_e, 2); rb_define_module_function(module, "psi", rb_gsl_sf_psi, 1); rb_define_module_function(module, "psi_e", rb_gsl_sf_psi_e, 1); #ifdef GSL_1_6_LATER rb_define_module_function(module, "psi_1", rb_gsl_sf_psi_1, 1); #endif #ifdef GSL_1_4_9_LATER rb_define_module_function(module, "psi_1_e", rb_gsl_sf_psi_1_e, 1); #endif } gsl-1.15.3/ext/signal.c0000644000175000017500000002302312220252463014163 0ustar boutilboutil/* signal.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_fft.h" enum FFT_CONV_CORR { RB_GSL_FFT_CONVOLVE = 0, RB_GSL_FFT_CORRELATE = 1, RB_GSL_FFT_REAL = 2, RB_GSL_FFT_HALFCOMPLEX = 3, RB_GSL_FFT_DECONVOLVE = 4, }; #ifndef WAVETABLE_P #define WAVETABLE_P(x) (rb_obj_is_kind_of(x,cgsl_fft_halfcomplex_wavetable)?1:0) #endif #ifndef CHECK_WAVETABLE #define CHECK_WAVETABLE(x) if(!rb_obj_is_kind_of(x,cgsl_fft_halfcomplex_wavetable))\ rb_raise(rb_eTypeError, "wrong argument type (FFT::HalfComplex::Wavetable expected)"); #endif #ifndef WORKSPACE_P #define WORKSPACE_P(x) (rb_obj_is_kind_of(x,cgsl_fft_real_workspace)?1:0) #endif #ifndef CHECK_WORKSPACE #define CHECK_WORKSPACE(x) if(!rb_obj_is_kind_of(x,cgsl_fft_real_workspace))\ rb_raise(rb_eTypeError, "wrong argument type (FFT::Real::Workspace expected)"); #endif static void complex_mul(double re1, double im1, double re2, double im2, double *re, double *im) { *re = re1*re2 - im1*im2; *im = re1*im2 + im1*re2; } static void complex_conj_mul(double re1, double im1, double re2, double im2, double *re, double *im) { *re = re1*re2 + im1*im2; *im = -re1*im2 + im1*re2; } static void complex_div(double re1, double im1, double re2, double im2, double *re, double *im) { double factor = re2*re2 + im2*im2; complex_conj_mul(re1, im1, re2, im2, re, im); *re /= factor; *im /= factor; } /* data1, data2: FFTed data */ static void rbgsl_calc_conv_corr_c(const double *data1, const double *data2, double *data3, size_t size, gsl_fft_halfcomplex_wavetable *table, gsl_fft_real_workspace *space, enum FFT_CONV_CORR calcflag) { size_t i; double re1, re2, im1, im2; void (*complex_cal)(double, double, double, double, double*, double*); switch (calcflag) { case RB_GSL_FFT_CONVOLVE: complex_cal = complex_mul; data3[0] = data1[0]*data2[0]; data3[size-1] = data1[size-1]*data2[size-1]; break; case RB_GSL_FFT_CORRELATE: data3[0] = data1[0]*data2[0]; data3[size-1] = data1[size-1]*data2[size-1]; complex_cal = complex_conj_mul; break; case RB_GSL_FFT_DECONVOLVE: complex_cal = complex_div; data3[0] = data1[0]/data2[0]; data3[size-1] = data1[size-1]/data2[size-1]; break; default: rb_raise(rb_eArgError, "Wrong flag."); break; } for (i = 1; i < size-1; i+=2) { re1 = data1[i]; im1 = data1[i+1]; re2 = data2[i]; im2 = data2[i+1]; (*complex_cal)(re1, im1, re2, im2, &data3[i], &data3[i+1]); } } static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj, enum FFT_CONV_CORR flag1, enum FFT_CONV_CORR flag2) { double *data1, *data2, *data3; size_t stride1, stride2, size1, size2; #ifdef HAVE_NARRAY_H int naflag1, naflag2, shape; #else int naflag1, naflag2; #endif gsl_vector *v = NULL; gsl_fft_halfcomplex_wavetable *table = NULL; gsl_fft_real_wavetable *rtable = NULL; gsl_fft_real_workspace *space = NULL, *space2 = NULL; int flagt = 0, flagw = 0; // size_t i; gsl_vector *vtmp1 = NULL, *vtmp2 = NULL; VALUE ary; switch (argc) { case 3: data1 = get_ptr_double3(obj, &size1, &stride1, &naflag1); data2 = get_ptr_double3(argv[0], &size2, &stride2, &naflag2); CHECK_WAVETABLE(argv[1]); Data_Get_Struct(argv[1], gsl_fft_halfcomplex_wavetable, table); CHECK_WORKSPACE(argv[2]); Data_Get_Struct(argv[2], gsl_fft_real_workspace, space); break; case 2: data1 = get_ptr_double3(obj, &size1, &stride1, &naflag1); data2 = get_ptr_double3(argv[0], &size2, &stride2, &naflag2); if (WAVETABLE_P(argv[1])) { Data_Get_Struct(argv[1], gsl_fft_halfcomplex_wavetable, table); space = gsl_fft_real_workspace_alloc(size1); flagw = 1; } else if (WORKSPACE_P(argv[1])) { Data_Get_Struct(argv[1], gsl_fft_real_workspace, space); table = gsl_fft_halfcomplex_wavetable_alloc(size1); flagt = 1; } else { rb_raise(rb_eTypeError, "wrong argument type %s " "(FFT::HalfComplex::Wavetable or FFT::Real::Workspace expected)", rb_class2name(CLASS_OF(argv[2]))); } break; case 1: data1 = get_ptr_double3(obj, &size1, &stride1, &naflag1); data2 = get_ptr_double3(argv[0], &size2, &stride2, &naflag2); table = gsl_fft_halfcomplex_wavetable_alloc(size1); space = gsl_fft_real_workspace_alloc(size1); flagt = 1; flagw = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-3)", argc); } switch (naflag1*naflag2) { case 0: v = gsl_vector_alloc(size1); switch (flag1) { case RB_GSL_FFT_REAL: ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; default: ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; } data3 = v->data; break; case 1: #ifdef HAVE_NARRAY_H shape = (int) size1; ary = na_make_object(NA_DFLOAT, 1, &shape, cNArray); data3 = NA_PTR_TYPE(ary, double*); #endif break; default: break; } switch (flag1) { case RB_GSL_FFT_REAL: // do FFT vtmp1 = gsl_vector_alloc(size1); vtmp2 = gsl_vector_alloc(size2); memcpy(vtmp1->data, data1, sizeof(double)*size1); memcpy(vtmp2->data, data2, sizeof(double)*size2); data1 = vtmp1->data; data2 = vtmp2->data; rtable = gsl_fft_real_wavetable_alloc(size1); if (size1 == space->n) { gsl_fft_real_transform(data1, stride1, size1, rtable, space); } else { space2 = gsl_fft_real_workspace_alloc(size1); gsl_fft_real_transform(data1, stride1, size1, rtable, space2); /* no freeing space2 here */ } if (size1 != size2) { if (rtable) gsl_fft_real_wavetable_free(rtable); rtable = gsl_fft_real_wavetable_alloc(size2); } if (size2 == space->n) { gsl_fft_real_transform(data2, stride2, size2, rtable, space); } else if (size2 == size1) { gsl_fft_real_transform(data2, stride2, size2, rtable, space2); gsl_fft_real_workspace_free(space2); } else { if (space2) gsl_fft_real_workspace_free(space2); space2 = gsl_fft_real_workspace_alloc(size2); gsl_fft_real_transform(data2, stride2, size2, rtable, space2); gsl_fft_real_workspace_free(space2); } gsl_fft_real_wavetable_free(rtable); space2 = NULL; rtable = NULL; break; case RB_GSL_FFT_HALFCOMPLEX: /* do nothing */ break; default: /* not occur */ break; } rbgsl_calc_conv_corr_c(data1, data2, data3, size1, table, space, flag2); if (flag1 == RB_GSL_FFT_REAL) { gsl_fft_halfcomplex_inverse(data3, 1, size1, table, space); // for (i = 0; i < size1; i++) data3[i] /= size1; } if (flagt == 1) gsl_fft_halfcomplex_wavetable_free(table); if (flagw == 1) gsl_fft_real_workspace_free(space); if (vtmp1) gsl_vector_free(vtmp1); if (vtmp2) gsl_vector_free(vtmp2); return ary; } /* GSL::Vector#convolve */ static VALUE rb_gsl_fft_real_convolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_fft_conv_corr(argc, argv, obj, RB_GSL_FFT_REAL, RB_GSL_FFT_CONVOLVE); } /* GSL::Vector#deconvolve */ static VALUE rb_gsl_fft_real_deconvolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_fft_conv_corr(argc, argv, obj, RB_GSL_FFT_REAL, RB_GSL_FFT_DECONVOLVE); } /* GSL::Vector#correlate */ static VALUE rb_gsl_fft_real_correlate(int argc, VALUE *argv, VALUE obj) { return rb_gsl_fft_conv_corr(argc, argv, obj, RB_GSL_FFT_REAL, RB_GSL_FFT_CORRELATE); } /* GSL::Vector#halfcomplex_convolve */ static VALUE rb_gsl_fft_halfcomplex_convolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_fft_conv_corr(argc, argv, obj, RB_GSL_FFT_HALFCOMPLEX, RB_GSL_FFT_CONVOLVE); } /* GSL::Vector#halfcomplex_deconvolve */ static VALUE rb_gsl_fft_halfcomplex_deconvolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_fft_conv_corr(argc, argv, obj, RB_GSL_FFT_HALFCOMPLEX, RB_GSL_FFT_DECONVOLVE); } /* GSL::Vector#halfcomplex_correlate */ static VALUE rb_gsl_fft_halfcomplex_correlate(int argc, VALUE *argv, VALUE obj) { return rb_gsl_fft_conv_corr(argc, argv, obj, RB_GSL_FFT_HALFCOMPLEX, RB_GSL_FFT_CORRELATE); } void Init_gsl_signal(VALUE module) { rb_define_method(cgsl_vector, "real_convolve", rb_gsl_fft_real_convolve, -1); rb_define_method(cgsl_vector, "real_deconvolve", rb_gsl_fft_real_deconvolve, -1); rb_define_method(cgsl_vector, "real_correlate", rb_gsl_fft_real_correlate, -1); rb_define_alias(cgsl_vector, "convolve", "real_convolve"); rb_define_alias(cgsl_vector, "deconvolve", "real_deconvolve"); rb_define_alias(cgsl_vector, "correlate", "real_correlate"); rb_define_method(cgsl_vector, "halfcomplex_convolve", rb_gsl_fft_halfcomplex_convolve, -1); rb_define_method(cgsl_vector, "halfcomplex_deconvolve", rb_gsl_fft_halfcomplex_deconvolve, -1); rb_define_method(cgsl_vector, "halfcomplex_correlate", rb_gsl_fft_halfcomplex_correlate, -1); rb_define_alias(cgsl_vector, "hc_convolve", "halfcomplex_convolve"); rb_define_alias(cgsl_vector, "hc_deconvolve", "halfcomplex_deconvolve"); rb_define_alias(cgsl_vector, "hc_correlate", "halfcomplex_correlate"); } #undef WAVETABLE_P #undef CHECK_WAVETABLE #undef WORKSPACE_P #undef CHECK_WORKSPACE gsl-1.15.3/ext/multiroots.c0000644000175000017500000007677212220252463015152 0ustar boutilboutil/* multiroots.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include "rb_gsl_common.h" #include "rb_gsl_array.h" #include "rb_gsl_function.h" #include #ifndef CHECK_MULTIROOT_FUNCTION #define CHECK_MULTIROOT_FUNCTION(x) if(CLASS_OF(x)!=cgsl_multiroot_function)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::MultiRoot::Function expected)",\ rb_class2name(CLASS_OF(x))); #endif #ifndef CHECK_MULTIROOT_FUNCTION_FDF #define CHECK_MULTIROOT_FUNCTION_FDF(x) if(CLASS_OF(x)!=cgsl_multiroot_function_fdf)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::MultiRoot::Function_fdf expected)",\ rb_class2name(CLASS_OF(x))); #endif static VALUE cgsl_multiroot_function; static VALUE cgsl_multiroot_function_fdf; enum { GSL_MULTIROOT_FDFSOLVER_HYBRIDSJ, GSL_MULTIROOT_FDFSOLVER_HYBRIDJ, GSL_MULTIROOT_FDFSOLVER_NEWTON, GSL_MULTIROOT_FDFSOLVER_GNEWTON, GSL_MULTIROOT_FSOLVER_HYBRIDS, GSL_MULTIROOT_FSOLVER_HYBRID, GSL_MULTIROOT_FSOLVER_DNEWTON, GSL_MULTIROOT_FSOLVER_BROYDEN, }; static void gsl_multiroot_function_fdf_mark(gsl_multiroot_function_fdf *f); static void gsl_multiroot_function_mark(gsl_multiroot_function *f); static void gsl_multiroot_function_free(gsl_multiroot_function *f); static int rb_gsl_multiroot_function_f(const gsl_vector *x, void *p, gsl_vector *f); static void set_function(int i, VALUE *argv, gsl_multiroot_function *F); static void gsl_multiroot_function_fdf_free(gsl_multiroot_function_fdf *f); static int rb_gsl_multiroot_function_fdf_f(const gsl_vector *x, void *p, gsl_vector *f); static int rb_gsl_multiroot_function_fdf_df(const gsl_vector *x, void *p, gsl_matrix *J); static int rb_gsl_multiroot_function_fdf_fdf(const gsl_vector *x, void *p, gsl_vector *f, gsl_matrix *J); static void set_function_fdf(int i, VALUE *argv, gsl_multiroot_function_fdf *F); static const gsl_multiroot_fsolver_type* get_fsolver_type(VALUE t); static const gsl_multiroot_fdfsolver_type* get_fdfsolver_type(VALUE t); static VALUE rb_gsl_multiroot_function_new(int argc, VALUE *argv, VALUE klass) { gsl_multiroot_function *F = NULL; VALUE ary; size_t i; F = ALLOC(gsl_multiroot_function); F->f = &rb_gsl_multiroot_function_f; ary = rb_ary_new2(2); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); else rb_ary_store(ary, 0, Qnil); rb_ary_store(ary, 1, Qnil); switch (argc) { case 0: break; case 1: set_function(0, argv, F); break; case 2: case 3: for (i = 0; i < argc; i++) set_function(i, argv, F); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } return Data_Wrap_Struct(klass, gsl_multiroot_function_mark, gsl_multiroot_function_free, F); } static void gsl_multiroot_function_free(gsl_multiroot_function *f) { free((gsl_multiroot_function *) f); } static void gsl_multiroot_function_mark(gsl_multiroot_function *f) { size_t i; rb_gc_mark((VALUE) f->params); // for (i = 0; i < RARRAY(f->params)->len; i++) for (i = 0; i < RARRAY_LEN(f->params); i++) rb_gc_mark(rb_ary_entry((VALUE) f->params, i)); } static int rb_gsl_multiroot_function_f(const gsl_vector *x, void *p, gsl_vector *f) { VALUE vx, vf; VALUE vp, proc; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vf = Data_Wrap_Struct(cgsl_vector, 0, NULL, f); proc = rb_ary_entry((VALUE) p, 0); vp = rb_ary_entry((VALUE) p, 1); if (NIL_P(vp)) rb_funcall(proc, RBGSL_ID_call, 2, vx, vf); else rb_funcall(proc, RBGSL_ID_call, 3, vx, vp, vf); return GSL_SUCCESS; } static VALUE rb_gsl_multiroot_function_eval(VALUE obj, VALUE vx) { gsl_multiroot_function *F = NULL; gsl_vector *f = NULL; VALUE vp, proc, vf, ary; Data_Get_Struct(obj, gsl_multiroot_function, F); ary = (VALUE) F->params; f = gsl_vector_alloc(F->n); vf = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, f); proc = rb_ary_entry(ary, 0); vp = rb_ary_entry(ary, 1); if (NIL_P(vp)) rb_funcall(proc, RBGSL_ID_call, 2, vx, vf); else rb_funcall(proc, RBGSL_ID_call, 3, vx, vp, vf); return vf; } static void set_function(int i, VALUE *argv, gsl_multiroot_function *F) { VALUE ary; ary = (VALUE) F->params; if (TYPE(argv[i]) == T_FIXNUM) F->n = FIX2INT(argv[i]); else if (rb_obj_is_kind_of(argv[i], rb_cProc)) rb_ary_store(ary, 0, argv[i]); else if (TYPE(argv[i]) == T_ARRAY || rb_obj_is_kind_of(argv[i], cgsl_vector) || TYPE(argv[i]) == T_FIXNUM || TYPE(argv[i]) == T_FLOAT) { rb_ary_store(ary, 1, argv[i]); } else { rb_raise(rb_eTypeError, "wrong type of argument %d (Fixnum or Proc)", i); } } static VALUE rb_gsl_multiroot_function_set_f(int argc, VALUE *argv, VALUE obj) { gsl_multiroot_function *F = NULL; VALUE ary; size_t i; Data_Get_Struct(obj, gsl_multiroot_function, F); ary = (VALUE) F->params; if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC); switch (argc) { case 1: set_function(0, argv, F); break; case 2: case 3: for (i = 0; i < argc; i++) set_function(i, argv, F); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } return obj; } static VALUE rb_gsl_multiroot_function_set_params(int argc, VALUE *argv, VALUE obj) { gsl_multiroot_function *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_multiroot_function, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } if (argc == 1) rb_ary_store(ary, 1, argv[0]); else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 1, ary2); } return obj; } static VALUE rb_gsl_multiroot_function_params(VALUE obj) { gsl_multiroot_function *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function, F); return rb_ary_entry((VALUE) F->params, 1); } static VALUE rb_gsl_multiroot_function_n(VALUE obj) { gsl_multiroot_function *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function, F); return INT2FIX(F->n); } /*** multiroot_function_fdf ***/ static void set_function_fdf(int argc, VALUE *argv, gsl_multiroot_function_fdf *F); static VALUE rb_gsl_multiroot_function_fdf_new(int argc, VALUE *argv, VALUE klass) { gsl_multiroot_function_fdf *F = NULL; VALUE ary; F = ALLOC(gsl_multiroot_function_fdf); F->f = &rb_gsl_multiroot_function_fdf_f; F->df = &rb_gsl_multiroot_function_fdf_df; F->fdf = &rb_gsl_multiroot_function_fdf_fdf; ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; rb_ary_store(ary, 2, Qnil); rb_ary_store(ary, 3, Qnil); set_function_fdf(argc, argv, F); return Data_Wrap_Struct(klass, gsl_multiroot_function_fdf_mark, gsl_multiroot_function_fdf_free, F); } static void gsl_multiroot_function_fdf_free(gsl_multiroot_function_fdf *f) { free((gsl_multiroot_function_fdf *) f); } static void gsl_multiroot_function_fdf_mark(gsl_multiroot_function_fdf *f) { size_t i; rb_gc_mark((VALUE) f->params); // for (i = 0; i < RARRAY(f->params)->len; i++) for (i = 0; i < RARRAY_LEN(f->params); i++) rb_gc_mark(rb_ary_entry((VALUE) f->params, i)); } static void set_function_fdf(int argc, VALUE *argv, gsl_multiroot_function_fdf *F) { VALUE ary; if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } rb_ary_store(ary, 2, Qnil); rb_ary_store(ary, 3, Qnil); switch (argc) { case 1: if (TYPE(argv[0]) != T_FIXNUM) rb_raise(rb_eTypeError, "Fixnum expected"); F->n = FIX2INT(argv[0]); break; case 2: rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); rb_ary_store(ary, 2, Qnil); break; case 3: rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); if (TYPE(argv[2]) == T_FIXNUM) { F->n = FIX2INT(argv[2]); rb_ary_store(ary, 2, Qnil); } else { rb_ary_store(ary, 2, argv[2]); } break; case 4: rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); if (TYPE(argv[2]) == T_FIXNUM) { F->n = FIX2INT(argv[2]); rb_ary_store(ary, 2, Qnil); rb_ary_store(ary, 3, argv[3]); } else { rb_ary_store(ary, 2, argv[2]); F->n = FIX2INT(argv[3]); rb_ary_store(ary, 3, Qnil); } break; case 5: if (TYPE(argv[0]) == T_FIXNUM) { F->n = FIX2INT(argv[0]); rb_ary_store(ary, 0, argv[1]); rb_ary_store(ary, 1, argv[2]); rb_ary_store(ary, 2, argv[3]); } else { rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); rb_ary_store(ary, 2, argv[2]); F->n = FIX2INT(argv[3]); } rb_ary_store(ary, 3, argv[4]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (1, 3, or 4)"); break; } } static VALUE rb_gsl_multiroot_function_fdf_set_params(int argc, VALUE *argv, VALUE obj) { gsl_multiroot_function_fdf *F = NULL; VALUE ary, ary2; size_t i; if (argc == 0) return obj; Data_Get_Struct(obj, gsl_multiroot_function_fdf, F); if (F->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) F->params = ary;*/ F->params = (void *) ary; } else { ary = (VALUE) F->params; } if (argc == 1) rb_ary_store(ary, 3, argv[0]); else { ary2 = rb_ary_new2(argc); for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]); rb_ary_store(ary, 3, ary2); } return obj; } static VALUE rb_gsl_multiroot_function_fdf_set(int argc, VALUE *argv, VALUE obj) { gsl_multiroot_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function_fdf, F); set_function_fdf(argc, argv, F); return obj; } static int rb_gsl_multiroot_function_fdf_f(const gsl_vector *x, void *p, gsl_vector *f) { VALUE vx, vf, ary; VALUE proc, vp; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vf = Data_Wrap_Struct(cgsl_vector, 0, NULL, f); ary = (VALUE) p; proc = rb_ary_entry(ary, 0); vp = rb_ary_entry(ary, 3); if (NIL_P(vp)) rb_funcall(proc, RBGSL_ID_call, 2, vx, vf); else rb_funcall(proc, RBGSL_ID_call, 3, vx, vp, vf); return GSL_SUCCESS; } static int rb_gsl_multiroot_function_fdf_df(const gsl_vector *x, void *p, gsl_matrix *J) { VALUE vx, vJ, ary; VALUE proc, vp; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vJ = Data_Wrap_Struct(cgsl_matrix, 0, NULL, J); ary = (VALUE) p; proc = rb_ary_entry(ary, 1); vp = rb_ary_entry(ary, 3); if (NIL_P(vp)) rb_funcall(proc, RBGSL_ID_call, 2, vx, vJ); else rb_funcall(proc, RBGSL_ID_call, 3, vx, vp, vJ); return GSL_SUCCESS; } static int rb_gsl_multiroot_function_fdf_fdf(const gsl_vector *x, void *p, gsl_vector *f, gsl_matrix *J) { VALUE vx, vf, vJ, ary; VALUE proc_f, proc_df, proc_fdf, vp; vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vf = Data_Wrap_Struct(cgsl_vector, 0, NULL, f); vJ = Data_Wrap_Struct(cgsl_matrix, 0, NULL, J); ary = (VALUE) p; proc_f = rb_ary_entry(ary, 0); proc_df = rb_ary_entry(ary, 1); proc_fdf = rb_ary_entry(ary, 2); vp = rb_ary_entry(ary, 3); if (NIL_P(proc_fdf)) { if (NIL_P(vp)) { rb_funcall(proc_f, RBGSL_ID_call, 2, vx, vf); rb_funcall(proc_df, RBGSL_ID_call, 2, vx, vJ); } else { rb_funcall(proc_f, RBGSL_ID_call, 3, vx, vp, vf); rb_funcall(proc_df, RBGSL_ID_call, 3, vx, vp, vJ); } } else { if (NIL_P(vp)) rb_funcall(proc_fdf, RBGSL_ID_call, 3, vx, vf, vJ); else rb_funcall(proc_fdf, RBGSL_ID_call, 4, vx, vp, vf, vJ); } return GSL_SUCCESS; } static VALUE rb_gsl_multiroot_function_fdf_params(VALUE obj) { gsl_multiroot_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function_fdf, F); return rb_ary_entry((VALUE) F->params, 3); } static VALUE rb_gsl_multiroot_function_fdf_n(VALUE obj) { gsl_multiroot_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function_fdf, F); return INT2FIX(F->n); } /**********/ static void multiroot_define_const(VALUE klass1, VALUE klass2); static void multiroot_define_const(VALUE klass1, VALUE klass2) { rb_define_const(klass1, "HYBRIDSJ", INT2FIX(GSL_MULTIROOT_FDFSOLVER_HYBRIDSJ)); rb_define_const(klass1, "HYBRIDJ", INT2FIX(GSL_MULTIROOT_FDFSOLVER_HYBRIDJ)); rb_define_const(klass1, "NEWTON", INT2FIX(GSL_MULTIROOT_FDFSOLVER_NEWTON)); rb_define_const(klass1, "GNEWTON", INT2FIX(GSL_MULTIROOT_FDFSOLVER_GNEWTON)); rb_define_const(klass2, "HYBRIDS", INT2FIX(GSL_MULTIROOT_FSOLVER_HYBRIDS)); rb_define_const(klass2, "HYBRID", INT2FIX(GSL_MULTIROOT_FSOLVER_HYBRID)); rb_define_const(klass2, "DNEWTON", INT2FIX(GSL_MULTIROOT_FSOLVER_DNEWTON)); rb_define_const(klass2, "BROYDEN", INT2FIX(GSL_MULTIROOT_FSOLVER_BROYDEN)); } #include static const gsl_multiroot_fsolver_type* get_fsolver_type(VALUE t) { char name[32]; switch (TYPE(t)) { case T_STRING: strcpy(name,STR2CSTR(t)); if (str_tail_grep(name, "hybrids") == 0) return gsl_multiroot_fsolver_hybrids; else if (str_tail_grep(name, "hybrid") == 0) return gsl_multiroot_fsolver_hybrid; else if (str_tail_grep(name, "dnewton") == 0) return gsl_multiroot_fsolver_dnewton; else if (str_tail_grep(name, "broyden") == 0) return gsl_multiroot_fsolver_broyden; else rb_raise(rb_eTypeError, "%s: unknown algorithm", name); break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_MULTIROOT_FSOLVER_HYBRIDS: return gsl_multiroot_fsolver_hybrids; break; case GSL_MULTIROOT_FSOLVER_HYBRID: return gsl_multiroot_fsolver_hybrid; break; case GSL_MULTIROOT_FSOLVER_DNEWTON: return gsl_multiroot_fsolver_dnewton; break; case GSL_MULTIROOT_FSOLVER_BROYDEN: return gsl_multiroot_fsolver_broyden; break; default: rb_raise(rb_eTypeError, "%d: unknown algorithm", FIX2INT(t)); break; } break; default: rb_raise(rb_eTypeError, "wrong type argument (Fixnum or String expected)"); break; } } static const gsl_multiroot_fdfsolver_type* get_fdfsolver_type(VALUE t) { char name[32]; switch (TYPE(t)) { case T_STRING: strcpy(name,STR2CSTR(t)); if (str_tail_grep(name, "hybridsj") == 0) return gsl_multiroot_fdfsolver_hybridsj; else if (str_tail_grep(name, "hybridj") == 0) return gsl_multiroot_fdfsolver_hybridj; else if (str_tail_grep(name, "gnewton") == 0) return gsl_multiroot_fdfsolver_gnewton; else if (str_tail_grep(name, "newton") == 0) return gsl_multiroot_fdfsolver_newton; else rb_raise(rb_eTypeError, "%s: unknown algorithm", name); break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_MULTIROOT_FDFSOLVER_HYBRIDSJ: return gsl_multiroot_fdfsolver_hybridsj; break; case GSL_MULTIROOT_FDFSOLVER_HYBRIDJ: return gsl_multiroot_fdfsolver_hybridj; break; case GSL_MULTIROOT_FDFSOLVER_NEWTON: return gsl_multiroot_fdfsolver_newton; break; case GSL_MULTIROOT_FDFSOLVER_GNEWTON: return gsl_multiroot_fdfsolver_gnewton; break; default: rb_raise(rb_eTypeError, "%d: unknown algorithm", FIX2INT(t)); break; } break; default: rb_raise(rb_eTypeError, "wrong type argument (Fixnum or String expected)"); break; } } static VALUE rb_gsl_multiroot_fsolver_new(VALUE klass, VALUE t, VALUE n) { gsl_multiroot_fsolver *s = NULL; const gsl_multiroot_fsolver_type *T; CHECK_FIXNUM(n); T = get_fsolver_type(t); s = gsl_multiroot_fsolver_alloc(T, FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_multiroot_fsolver_free, s); } static VALUE rb_gsl_multiroot_fsolver_set(VALUE obj, VALUE vf, VALUE vx) { gsl_multiroot_fsolver *s = NULL; gsl_multiroot_function *f = NULL; gsl_vector *x = NULL; int flag = 0, status; CHECK_MULTIROOT_FUNCTION(vf); Data_Get_Struct(obj, gsl_multiroot_fsolver, s); Data_Get_Struct(vf, gsl_multiroot_function, f); if (TYPE(vx) == T_ARRAY) { x = gsl_vector_alloc(s->f->size); cvector_set_from_rarray(x, vx); flag = 1; } else { Data_Get_Vector(vx, x); } status = gsl_multiroot_fsolver_set(s, f, x); if (flag == 1) gsl_vector_free(x); return INT2FIX(status); } static VALUE rb_gsl_multiroot_fsolver_name(VALUE obj) { gsl_multiroot_fsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return rb_str_new2(gsl_multiroot_fsolver_name(s)); } static VALUE rb_gsl_multiroot_fsolver_iterate(VALUE obj) { gsl_multiroot_fsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return INT2FIX(gsl_multiroot_fsolver_iterate(s)); } static VALUE rb_gsl_multiroot_fsolver_root(VALUE obj) { gsl_multiroot_fsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, gsl_multiroot_fsolver_root(s)); } static VALUE rb_gsl_multiroot_fsolver_x(VALUE obj) { gsl_multiroot_fsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, s->x); } static VALUE rb_gsl_multiroot_fsolver_dx(VALUE obj) { gsl_multiroot_fsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, s->dx); } static VALUE rb_gsl_multiroot_fsolver_f(VALUE obj) { gsl_multiroot_fsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, s->f); } static VALUE rb_gsl_multiroot_fsolver_test_delta(VALUE obj, VALUE ea, VALUE er) { gsl_multiroot_fsolver *s = NULL; Need_Float(ea); Need_Float(er); Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return INT2FIX(gsl_multiroot_test_delta(s->dx, s->x, NUM2DBL(ea), NUM2DBL(er))); } static VALUE rb_gsl_multiroot_fsolver_test_residual(VALUE obj, VALUE ea) { gsl_multiroot_fsolver *s = NULL; Need_Float(ea); Data_Get_Struct(obj, gsl_multiroot_fsolver, s); return INT2FIX(gsl_multiroot_test_residual(s->f, NUM2DBL(ea))); } /***/ static VALUE rb_gsl_multiroot_fdfsolver_new(VALUE klass, VALUE t, VALUE n) { gsl_multiroot_fdfsolver *s = NULL; const gsl_multiroot_fdfsolver_type *T; CHECK_FIXNUM(n); T = get_fdfsolver_type(t); s = gsl_multiroot_fdfsolver_alloc(T, FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_multiroot_fdfsolver_free, s); } static VALUE rb_gsl_multiroot_fdfsolver_set(VALUE obj, VALUE vf, VALUE vx) { gsl_multiroot_fdfsolver *s = NULL; gsl_multiroot_function_fdf *f = NULL; gsl_vector *x = NULL; int flag = 0, status; CHECK_MULTIROOT_FUNCTION_FDF(vf); Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); Data_Get_Struct(vf, gsl_multiroot_function_fdf, f); if (TYPE(vx) == T_ARRAY) { x = gsl_vector_alloc(s->f->size); cvector_set_from_rarray(x, vx); flag = 1; } else { Data_Get_Vector(vx, x); } status = gsl_multiroot_fdfsolver_set(s, f, x); if (flag == 0) gsl_vector_free(x); return INT2FIX(status); } static VALUE rb_gsl_multiroot_fdfsolver_name(VALUE obj) { gsl_multiroot_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return rb_str_new2(gsl_multiroot_fdfsolver_name(s)); } static VALUE rb_gsl_multiroot_fdfsolver_iterate(VALUE obj) { gsl_multiroot_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return INT2FIX(gsl_multiroot_fdfsolver_iterate(s)); } static VALUE rb_gsl_multiroot_fdfsolver_root(VALUE obj) { gsl_multiroot_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, gsl_multiroot_fdfsolver_root(s)); } static VALUE rb_gsl_multiroot_fdfsolver_x(VALUE obj) { gsl_multiroot_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, s->x); } static VALUE rb_gsl_multiroot_fdfsolver_dx(VALUE obj) { gsl_multiroot_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, s->dx); } static VALUE rb_gsl_multiroot_fdfsolver_f(VALUE obj) { gsl_multiroot_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, s->f); } static VALUE rb_gsl_multiroot_fdfsolver_J(VALUE obj) { gsl_multiroot_fdfsolver *s = NULL; Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return Data_Wrap_Struct(cgsl_matrix_view_ro, 0, NULL, s->J); } static VALUE rb_gsl_multiroot_fdfsolver_test_delta(VALUE obj, VALUE ea, VALUE er) { gsl_multiroot_fdfsolver *s = NULL; Need_Float(ea); Need_Float(er); Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return INT2FIX(gsl_multiroot_test_delta(s->dx, s->x, NUM2DBL(ea), NUM2DBL(er))); } static VALUE rb_gsl_multiroot_fdfsolver_test_residual(VALUE obj, VALUE ea) { gsl_multiroot_fdfsolver *s = NULL; Need_Float(ea); Data_Get_Struct(obj, gsl_multiroot_fdfsolver, s); return INT2FIX(gsl_multiroot_test_residual(s->f, NUM2DBL(ea))); } static VALUE rb_gsl_multiroot_test_delta(VALUE obj, VALUE vdx, VALUE vx, VALUE ea, VALUE er) { gsl_vector *dx = NULL, *x = NULL; Need_Float(ea); Need_Float(er); Data_Get_Struct(vdx, gsl_vector, dx); Data_Get_Struct(vx, gsl_vector, x); return INT2FIX(gsl_multiroot_test_delta(dx, x, NUM2DBL(ea), NUM2DBL(er))); } static VALUE rb_gsl_multiroot_test_residual(VALUE obj, VALUE vf, VALUE ea) { gsl_vector *f = NULL; Need_Float(ea); Data_Get_Struct(vf, gsl_vector, f); return INT2FIX(gsl_multiroot_test_residual(f, NUM2DBL(ea))); } static VALUE rb_gsl_multiroot_fsolver_fsolve(int argc, VALUE *argv, VALUE obj) { gsl_multiroot_fsolver *s = NULL; int iter = 0, itmp = 0, i, status, max_iter = 1000; double eps = 1e-7; gsl_vector *xnew = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: Data_Get_Struct(argv[0], gsl_multiroot_fsolver, s); itmp = 1; break; default: Data_Get_Struct(obj, gsl_multiroot_fsolver, s); itmp = 0; break; } for (i = itmp; i < argc; i++) { switch (argv[i]) { case T_FIXNUM: max_iter = FIX2INT(argv[i]); break; case T_FLOAT: eps = NUM2DBL(argv[i]); break; default: rb_raise(rb_eTypeError, "wrong type of argument %s (Fixnum or Float expected)", rb_class2name(CLASS_OF(argv[i]))); break; } } do { iter ++; status = gsl_multiroot_fsolver_iterate (s); if (status) break; status = gsl_multiroot_test_residual(s->f, eps); } while (status == GSL_CONTINUE && iter < max_iter); xnew = gsl_vector_alloc(s->x->size); gsl_vector_memcpy(xnew, gsl_multiroot_fsolver_root(s)); return rb_ary_new3(3, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew), INT2FIX(iter), INT2FIX(status)); } /* singleton */ static VALUE rb_gsl_multiroot_fdjacobian(int argc, VALUE *argv, VALUE obj) { gsl_multiroot_function *F = NULL, func; gsl_multiroot_function_fdf *fdf = NULL; gsl_vector *x = NULL, *f = NULL; gsl_matrix *J = NULL; double eps; int status; if (argc != 4 && argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4 or 5)", argc); if (rb_obj_is_kind_of(argv[0], cgsl_multiroot_function_fdf)) { Data_Get_Struct(argv[0], gsl_multiroot_function_fdf, fdf); func.f = fdf->f; func.n = fdf->n; func.params = fdf->params; F = &func; } else if (rb_obj_is_kind_of(argv[0], cgsl_multiroot_function)) { Data_Get_Struct(argv[0], gsl_multiroot_function, F); } else { rb_raise(rb_eArgError, "wrong argument type %s (MultiRoot::Function or MultiRoot::Function_fdf expected)", rb_class2name(CLASS_OF(argv[0]))); } Need_Float(argv[3]); Data_Get_Vector(argv[1], x); Data_Get_Vector(argv[2], f); eps = NUM2DBL(argv[3]); if (argc == 4) { J = gsl_matrix_alloc(F->n, F->n); status = gsl_multiroot_fdjacobian(F, x, f, eps, J); return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, J), INT2FIX(status)); } else { Data_Get_Struct(argv[4], gsl_matrix, J); status = gsl_multiroot_fdjacobian(F, x, f, eps, J); return rb_ary_new3(2, argv[4], INT2FIX(status)); } } static VALUE rb_gsl_multiroot_function_get_f(VALUE obj) { gsl_multiroot_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function_fdf, F); return rb_ary_entry(((VALUE) F->params), 0); } static VALUE rb_gsl_multiroot_function_fdf_get_f(VALUE obj) { gsl_multiroot_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function_fdf, F); return rb_ary_entry(((VALUE) F->params), 0); } static VALUE rb_gsl_multiroot_function_fdf_get_df(VALUE obj) { gsl_multiroot_function_fdf *F = NULL; Data_Get_Struct(obj, gsl_multiroot_function_fdf, F); return rb_ary_entry(((VALUE) F->params), 1); } static VALUE rb_gsl_multiroot_function_solve(int argc, VALUE *argv, VALUE obj) { gsl_multiroot_function *F = NULL; gsl_vector *x0 = NULL, *xnew; int flag = 0; double epsabs = 1e-7; size_t max_iter = 10000, iter = 0, i; gsl_multiroot_fsolver_type *T = (gsl_multiroot_fsolver_type *) gsl_multiroot_fsolver_hybrids; gsl_multiroot_fsolver *s = NULL; int status; if (argc < 1) rb_raise(rb_eArgError, "too few arguments (%d for >= 1)", argc); Data_Get_Struct(obj, gsl_multiroot_function, F); switch (argc) { case 4: case 3: case 2: for (i = 1; i < argc; i++) { switch (TYPE(argv[i])) { case T_STRING: T = (gsl_multiroot_fsolver_type *) get_fsolver_type(argv[i]); break; case T_FLOAT: epsabs = NUM2DBL(argv[i]); break; case T_FIXNUM: max_iter = FIX2INT(argv[i]); break; } } /* no break */ case 1: if (TYPE(argv[0]) == T_ARRAY) { // if (RARRAY(argv[0])->len != F->n) if (RARRAY_LEN(argv[0]) != F->n) rb_raise(rb_eRangeError, "array size are different."); x0 = gsl_vector_alloc(F->n); for (i = 0; i < x0->size; i++) gsl_vector_set(x0, i, NUM2DBL(rb_ary_entry(argv[0], i))); flag = 1; } else { Data_Get_Vector(argv[0], x0); flag = 0; } break; default: rb_raise(rb_eArgError, "too many arguments (%d for 1 - 4)", argc); break; } s = gsl_multiroot_fsolver_alloc (T, F->n); gsl_multiroot_fsolver_set (s, F, x0); do { iter++; status = gsl_multiroot_fsolver_iterate (s); if (status) break; status = gsl_multiroot_test_residual(s->f, epsabs); } while (status == GSL_CONTINUE && iter < max_iter); xnew = gsl_vector_alloc(x0->size); gsl_vector_memcpy(xnew, s->x); gsl_multiroot_fsolver_free (s); if (flag == 1) gsl_vector_free(x0); return rb_ary_new3(3, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew), INT2FIX(iter), INT2FIX(status)); } void Init_gsl_multiroot(VALUE module) { VALUE mgsl_multiroot; VALUE cgsl_multiroot_fdfsolver, cgsl_multiroot_fsolver; mgsl_multiroot = rb_define_module_under(module, "MultiRoot"); rb_define_singleton_method(mgsl_multiroot, "test_delta", rb_gsl_multiroot_test_delta, 4); rb_define_singleton_method(mgsl_multiroot, "test_residual", rb_gsl_multiroot_test_residual, 2); rb_define_singleton_method(mgsl_multiroot, "fdjacobian", rb_gsl_multiroot_fdjacobian, -1); /* multiroot_function */ cgsl_multiroot_function = rb_define_class_under(mgsl_multiroot, "Function", cgsl_function); rb_define_singleton_method(cgsl_multiroot_function, "alloc", rb_gsl_multiroot_function_new, -1); rb_define_method(cgsl_multiroot_function, "eval", rb_gsl_multiroot_function_eval, 1); rb_define_alias(cgsl_multiroot_function, "call", "eval"); rb_define_method(cgsl_multiroot_function, "set", rb_gsl_multiroot_function_set_f, -1); rb_define_method(cgsl_multiroot_function, "set_params", rb_gsl_multiroot_function_set_params, -1); rb_define_method(cgsl_multiroot_function, "params", rb_gsl_multiroot_function_params, 0); rb_define_method(cgsl_multiroot_function, "n", rb_gsl_multiroot_function_n, 0); rb_define_method(cgsl_multiroot_function, "f", rb_gsl_multiroot_function_get_f, 0); /* multiroot_function_fdf */ cgsl_multiroot_function_fdf = rb_define_class_under(mgsl_multiroot, "Function_fdf", cgsl_multiroot_function); rb_define_singleton_method(cgsl_multiroot_function_fdf, "alloc", rb_gsl_multiroot_function_fdf_new, -1); rb_define_method(cgsl_multiroot_function_fdf, "set", rb_gsl_multiroot_function_fdf_set, -1); rb_define_method(cgsl_multiroot_function_fdf, "set_params", rb_gsl_multiroot_function_fdf_set_params, -1); rb_define_method(cgsl_multiroot_function_fdf, "params", rb_gsl_multiroot_function_fdf_params, 0); rb_define_method(cgsl_multiroot_function_fdf, "n", rb_gsl_multiroot_function_fdf_n, 0); rb_define_method(cgsl_multiroot_function_fdf, "f", rb_gsl_multiroot_function_fdf_get_f, 0); rb_define_method(cgsl_multiroot_function_fdf, "df", rb_gsl_multiroot_function_fdf_get_df, 0); /* solver */ cgsl_multiroot_fsolver = rb_define_class_under(mgsl_multiroot, "FSolver", cGSL_Object); cgsl_multiroot_fdfsolver = rb_define_class_under(mgsl_multiroot, "FdfSolver", cgsl_multiroot_fsolver); rb_define_singleton_method(cgsl_multiroot_fsolver, "alloc", rb_gsl_multiroot_fsolver_new, 2); rb_define_singleton_method(cgsl_multiroot_fdfsolver, "alloc", rb_gsl_multiroot_fdfsolver_new, 2); rb_define_method(cgsl_multiroot_fsolver, "set", rb_gsl_multiroot_fsolver_set, 2); rb_define_method(cgsl_multiroot_fsolver, "name", rb_gsl_multiroot_fsolver_name, 0); rb_define_method(cgsl_multiroot_fsolver, "iterate", rb_gsl_multiroot_fsolver_iterate, 0); rb_define_method(cgsl_multiroot_fsolver, "root", rb_gsl_multiroot_fsolver_root, 0); rb_define_method(cgsl_multiroot_fsolver, "x", rb_gsl_multiroot_fsolver_x, 0); rb_define_method(cgsl_multiroot_fsolver, "dx", rb_gsl_multiroot_fsolver_dx, 0); rb_define_method(cgsl_multiroot_fsolver, "f", rb_gsl_multiroot_fsolver_f, 0); rb_define_method(cgsl_multiroot_fsolver, "test_delta", rb_gsl_multiroot_fsolver_test_delta, 2); rb_define_method(cgsl_multiroot_fsolver, "test_residual", rb_gsl_multiroot_fsolver_test_residual, 1); rb_define_method(cgsl_multiroot_fdfsolver, "set", rb_gsl_multiroot_fdfsolver_set, 2); rb_define_method(cgsl_multiroot_fdfsolver, "name", rb_gsl_multiroot_fdfsolver_name, 0); rb_define_method(cgsl_multiroot_fdfsolver, "iterate", rb_gsl_multiroot_fdfsolver_iterate, 0); rb_define_method(cgsl_multiroot_fdfsolver, "root", rb_gsl_multiroot_fdfsolver_root, 0); rb_define_method(cgsl_multiroot_fdfsolver, "x", rb_gsl_multiroot_fdfsolver_x, 0); rb_define_method(cgsl_multiroot_fdfsolver, "dx", rb_gsl_multiroot_fdfsolver_dx, 0); rb_define_method(cgsl_multiroot_fdfsolver, "f", rb_gsl_multiroot_fdfsolver_f, 0); rb_define_method(cgsl_multiroot_fdfsolver, "J", rb_gsl_multiroot_fdfsolver_J, 0); rb_define_alias(cgsl_multiroot_fdfsolver, "jac", "J"); rb_define_alias(cgsl_multiroot_fdfsolver, "jacobian", "J"); rb_define_method(cgsl_multiroot_fdfsolver, "test_delta", rb_gsl_multiroot_fdfsolver_test_delta, 2); rb_define_method(cgsl_multiroot_fdfsolver, "test_residual", rb_gsl_multiroot_fdfsolver_test_residual, 1); multiroot_define_const(cgsl_multiroot_fdfsolver, cgsl_multiroot_fsolver); rb_define_method(cgsl_multiroot_fsolver, "fsolve", rb_gsl_multiroot_fsolver_fsolve, -1); rb_define_alias(cgsl_multiroot_fsolver, "solve", "fsolve"); rb_define_singleton_method(cgsl_multiroot_fsolver, "fsolve", rb_gsl_multiroot_fsolver_fsolve, -1); rb_define_singleton_method(cgsl_multiroot_fsolver, "solve", rb_gsl_multiroot_fsolver_fsolve, -1); /*****/ rb_define_method(cgsl_multiroot_function, "solve", rb_gsl_multiroot_function_solve, -1); rb_define_alias(cgsl_multiroot_function, "fsolve", "solve"); } #ifdef CHECK_MULTIROOT_FUNCTION #undef CHECK_MULTIROOT_FUNCTION #endif #ifdef CHECK_MULTIROOT_FUNCTION_FDF #undef CHECK_MULTIROOT_FUNCTION_FDF #endif gsl-1.15.3/ext/sf_airy.c0000644000175000017500000002101012220252463014334 0ustar boutilboutil/* sf_airy.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" #include "rb_gsl_array.h" /* m: precision, d(double), s(single), a(apporox) */ static VALUE rb_gsl_sf_airy_Ai(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Ai, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Ai, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Ai_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Ai_e, x, m); } static VALUE rb_gsl_sf_airy_Bi(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Bi, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Bi, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Bi_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Bi_e, x, m); } static VALUE rb_gsl_sf_airy_Ai_scaled(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Ai_scaled, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Ai_scaled, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Ai_scaled_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Ai_scaled_e, x, m); } static VALUE rb_gsl_sf_airy_Bi_scaled(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Bi_scaled, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Bi_scaled, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Bi_scaled_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Bi_scaled_e, x, m); } static VALUE rb_gsl_sf_airy_Ai_deriv(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Ai_deriv, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Ai_deriv, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Ai_deriv_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Ai_deriv_e, x, m); } static VALUE rb_gsl_sf_airy_Bi_deriv(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Bi_deriv, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Bi_deriv, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Bi_deriv_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Bi_deriv_e, x, m); } static VALUE rb_gsl_sf_airy_Ai_deriv_scaled(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Ai_deriv_scaled, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Ai_deriv_scaled, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Ai_deriv_scaled_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Ai_deriv_scaled_e, x, m); } static VALUE rb_gsl_sf_airy_Bi_deriv_scaled(int argc, VALUE *argv, VALUE obj) { if (argc == 1) return eval_sf(gsl_sf_airy_Bi_deriv_scaled, argv[0]); else return rb_gsl_sf_eval_double_m(gsl_sf_airy_Bi_deriv_scaled, argv[0], argv[1]); } static VALUE rb_gsl_sf_airy_Bi_deriv_scaled_e(VALUE obj, VALUE x, VALUE m) { return rb_gsl_sf_eval_e_m(gsl_sf_airy_Bi_deriv_scaled_e, x, m); } static VALUE rb_gsl_sf_airy_zero_Ai(VALUE obj, VALUE s) { return rb_gsl_sf_eval1_uint(gsl_sf_airy_zero_Ai, s); } static VALUE rb_gsl_sf_airy_zero_Ai_e(VALUE obj, VALUE s) { return rb_gsl_sf_eval_e_uint(gsl_sf_airy_zero_Ai_e, s); } static VALUE rb_gsl_sf_airy_zero_Bi(VALUE obj, VALUE s) { return rb_gsl_sf_eval1_uint(gsl_sf_airy_zero_Bi, s); } static VALUE rb_gsl_sf_airy_zero_Bi_e(VALUE obj, VALUE s) { return rb_gsl_sf_eval_e_uint(gsl_sf_airy_zero_Bi_e, s); } static VALUE rb_gsl_sf_airy_zero_Ai_deriv(VALUE obj, VALUE s) { return rb_gsl_sf_eval1_uint(gsl_sf_airy_zero_Ai_deriv, s); } static VALUE rb_gsl_sf_airy_zero_Ai_deriv_e(VALUE obj, VALUE s) { return rb_gsl_sf_eval_e_uint(gsl_sf_airy_zero_Ai_deriv_e, s); } static VALUE rb_gsl_sf_airy_zero_Bi_deriv(VALUE obj, VALUE s) { return rb_gsl_sf_eval1_uint(gsl_sf_airy_zero_Bi_deriv, s); } static VALUE rb_gsl_sf_airy_zero_Bi_deriv_e(VALUE obj, VALUE s) { return rb_gsl_sf_eval_e_uint(gsl_sf_airy_zero_Bi_deriv_e, s); } void Init_gsl_sf_airy(VALUE module) { VALUE mgsl_sf_airy; rb_define_module_function(module, "airy_Ai", rb_gsl_sf_airy_Ai, -1); rb_define_module_function(module, "airy_Ai_e", rb_gsl_sf_airy_Ai_e, 2); rb_define_module_function(module, "airy_Bi", rb_gsl_sf_airy_Bi, -1); rb_define_module_function(module, "airy_Bi_e", rb_gsl_sf_airy_Bi_e, 2); rb_define_module_function(module, "airy_Ai_scaled", rb_gsl_sf_airy_Ai_scaled, -1); rb_define_module_function(module, "airy_Ai_scaled_e", rb_gsl_sf_airy_Ai_scaled_e, 2); rb_define_module_function(module, "airy_Bi_scaled", rb_gsl_sf_airy_Bi_scaled, -1); rb_define_module_function(module, "airy_Bi_scaled_e", rb_gsl_sf_airy_Bi_scaled_e, 2); rb_define_module_function(module, "airy_Ai_deriv", rb_gsl_sf_airy_Ai_deriv, -1); rb_define_module_function(module, "airy_Ai_deriv_e", rb_gsl_sf_airy_Ai_deriv_e, 2); rb_define_module_function(module, "airy_Bi_deriv", rb_gsl_sf_airy_Bi_deriv, -1); rb_define_module_function(module, "airy_Bi_deriv_e", rb_gsl_sf_airy_Bi_deriv_e, 2); rb_define_module_function(module, "airy_Ai_deriv_scaled", rb_gsl_sf_airy_Ai_deriv_scaled, -1); rb_define_module_function(module, "airy_Ai_deriv_scaled_e", rb_gsl_sf_airy_Ai_deriv_scaled_e, 2); rb_define_module_function(module, "airy_Bi_deriv_scaled", rb_gsl_sf_airy_Bi_deriv_scaled, -1); rb_define_module_function(module, "airy_Bi_deriv_scaled_e", rb_gsl_sf_airy_Bi_deriv_scaled_e, 2); rb_define_module_function(module, "airy_zero_Ai", rb_gsl_sf_airy_zero_Ai, 1); rb_define_module_function(module, "airy_zero_Ai_e", rb_gsl_sf_airy_zero_Ai_e, 1); rb_define_module_function(module, "airy_zero_Bi", rb_gsl_sf_airy_zero_Bi, 1); rb_define_module_function(module, "airy_zero_Bi_e", rb_gsl_sf_airy_zero_Bi_e, 1); rb_define_module_function(module, "airy_zero_Ai_deriv", rb_gsl_sf_airy_zero_Ai_deriv, 1); rb_define_module_function(module, "airy_zero_Ai_deriv_e", rb_gsl_sf_airy_zero_Ai_deriv_e, 1); rb_define_module_function(module, "airy_zero_Bi_deriv", rb_gsl_sf_airy_zero_Bi_deriv, 1); rb_define_module_function(module, "airy_zero_Bi_deriv_e", rb_gsl_sf_airy_zero_Bi_deriv_e, 1); mgsl_sf_airy = rb_define_module_under(module, "Airy"); rb_define_module_function(mgsl_sf_airy, "Ai", rb_gsl_sf_airy_Ai, -1); rb_define_module_function(mgsl_sf_airy, "Ai_e", rb_gsl_sf_airy_Ai_e, 2); rb_define_module_function(mgsl_sf_airy, "Bi", rb_gsl_sf_airy_Bi, -1); rb_define_module_function(mgsl_sf_airy, "Bi_e", rb_gsl_sf_airy_Bi_e, 2); rb_define_module_function(mgsl_sf_airy, "Ai_scaled", rb_gsl_sf_airy_Ai_scaled, -1); rb_define_module_function(mgsl_sf_airy, "Ai_scaled_e", rb_gsl_sf_airy_Ai_scaled_e, 2); rb_define_module_function(mgsl_sf_airy, "Bi_scaled", rb_gsl_sf_airy_Bi_scaled, -1); rb_define_module_function(mgsl_sf_airy, "Bi_scaled_e", rb_gsl_sf_airy_Bi_scaled_e, 2); rb_define_module_function(mgsl_sf_airy, "Ai_deriv", rb_gsl_sf_airy_Ai_deriv, -1); rb_define_module_function(mgsl_sf_airy, "Ai_deriv_e", rb_gsl_sf_airy_Ai_deriv_e, 2); rb_define_module_function(mgsl_sf_airy, "Bi_deriv", rb_gsl_sf_airy_Bi_deriv, -1); rb_define_module_function(mgsl_sf_airy, "Bi_deriv_e", rb_gsl_sf_airy_Bi_deriv_e, 2); rb_define_module_function(mgsl_sf_airy, "Ai_deriv_scaled", rb_gsl_sf_airy_Ai_deriv_scaled, -1); rb_define_module_function(mgsl_sf_airy, "Ai_deriv_scaled_e", rb_gsl_sf_airy_Ai_deriv_scaled_e, 2); rb_define_module_function(mgsl_sf_airy, "Bi_deriv_scaled", rb_gsl_sf_airy_Bi_deriv_scaled, -1); rb_define_module_function(mgsl_sf_airy, "Bi_deriv_scaled_e", rb_gsl_sf_airy_Bi_deriv_scaled_e, 2); rb_define_module_function(mgsl_sf_airy, "zero_Ai", rb_gsl_sf_airy_zero_Ai, 1); rb_define_module_function(mgsl_sf_airy, "zero_Ai_e", rb_gsl_sf_airy_zero_Ai_e, 1); rb_define_module_function(mgsl_sf_airy, "zero_Bi", rb_gsl_sf_airy_zero_Bi, 1); rb_define_module_function(mgsl_sf_airy, "zero_Bi_e", rb_gsl_sf_airy_zero_Bi_e, 1); rb_define_module_function(mgsl_sf_airy, "zero_Ai_deriv", rb_gsl_sf_airy_zero_Ai_deriv, 1); rb_define_module_function(mgsl_sf_airy, "zero_Ai_deriv_e", rb_gsl_sf_airy_zero_Ai_deriv_e, 1); rb_define_module_function(mgsl_sf_airy, "zero_Bi_deriv", rb_gsl_sf_airy_zero_Bi_deriv, 1); rb_define_module_function(mgsl_sf_airy, "zero_Bi_deriv_e", rb_gsl_sf_airy_zero_Bi_deriv_e, 1); } gsl-1.15.3/ext/cdf.c0000644000175000017500000006750112220252463013453 0ustar boutilboutil/* cdf.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #ifdef GSL_1_4_LATER #include "rb_gsl_array.h" #include "rb_gsl_common.h" #include "rb_gsl_rng.h" #include #include VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double)); VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa, double (*f)(double, double)); VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb, double (*f)(double, double, double)); VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa, double (*f)(unsigned int, double)); static VALUE rb_gsl_cdf_gaussian_P(int argc, VALUE *argv, VALUE obj) { if (argc == 1) { return rb_gsl_eval_pdf_cdf(argv[0], gsl_cdf_ugaussian_P); } else if (argc == 2) { return rb_gsl_eval_pdf_cdf2(argv[0], argv[1], gsl_cdf_gaussian_P); } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } } static VALUE rb_gsl_cdf_gaussian_Q(int argc, VALUE *argv, VALUE obj) { if (argc == 1) { return rb_gsl_eval_pdf_cdf(argv[0], gsl_cdf_ugaussian_Q); } else if (argc == 2) { return rb_gsl_eval_pdf_cdf2(argv[0], argv[1], gsl_cdf_gaussian_Q); } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } } static VALUE rb_gsl_cdf_gaussian_Pinv(int argc, VALUE *argv, VALUE obj) { if (argc == 1) { return rb_gsl_eval_pdf_cdf(argv[0], gsl_cdf_ugaussian_Pinv); } else if (argc == 2) { return rb_gsl_eval_pdf_cdf2(argv[0], argv[1], gsl_cdf_gaussian_Pinv); } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } } static VALUE rb_gsl_cdf_gaussian_Qinv(int argc, VALUE *argv, VALUE obj) { if (argc == 1) { return rb_gsl_eval_pdf_cdf(argv[0], gsl_cdf_ugaussian_Qinv); } else if (argc == 2) { return rb_gsl_eval_pdf_cdf2(argv[0], argv[1], gsl_cdf_gaussian_Qinv); } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } } static VALUE rb_gsl_cdf_exponential_P(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_exponential_P); } static VALUE rb_gsl_cdf_exponential_Q(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_exponential_Q); } static VALUE rb_gsl_cdf_exponential_Pinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_exponential_Pinv); } static VALUE rb_gsl_cdf_exponential_Qinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_exponential_Qinv); } static VALUE rb_gsl_cdf_laplace_P(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_laplace_P); } static VALUE rb_gsl_cdf_laplace_Q(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_laplace_Q); } static VALUE rb_gsl_cdf_laplace_Pinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_laplace_Pinv); } static VALUE rb_gsl_cdf_laplace_Qinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_laplace_Qinv); } static VALUE rb_gsl_cdf_cauchy_P(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_cauchy_P); } static VALUE rb_gsl_cdf_cauchy_Q(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_cauchy_Q); } static VALUE rb_gsl_cdf_cauchy_Pinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_cauchy_Pinv); } static VALUE rb_gsl_cdf_cauchy_Qinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_cauchy_Qinv); } static VALUE rb_gsl_cdf_rayleigh_P(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_rayleigh_P); } static VALUE rb_gsl_cdf_rayleigh_Q(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_rayleigh_Q); } static VALUE rb_gsl_cdf_rayleigh_Pinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_rayleigh_Pinv); } static VALUE rb_gsl_cdf_rayleigh_Qinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_rayleigh_Qinv); } static VALUE rb_gsl_cdf_gamma_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gamma_P); } static VALUE rb_gsl_cdf_gamma_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gamma_Q); } static VALUE rb_gsl_cdf_gamma_Pinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gamma_Pinv); } static VALUE rb_gsl_cdf_gamma_Qinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gamma_Qinv); } static VALUE rb_gsl_cdf_flat_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_flat_P); } static VALUE rb_gsl_cdf_flat_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_flat_Q); } static VALUE rb_gsl_cdf_flat_Pinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_flat_Pinv); } static VALUE rb_gsl_cdf_flat_Qinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_flat_Qinv); } static VALUE rb_gsl_cdf_lognormal_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_lognormal_P); } static VALUE rb_gsl_cdf_lognormal_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_lognormal_Q); } static VALUE rb_gsl_cdf_lognormal_Pinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_lognormal_Pinv); } static VALUE rb_gsl_cdf_lognormal_Qinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_lognormal_Qinv); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_cdf_exppow_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_exppow_P); } static VALUE rb_gsl_cdf_exppow_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_exppow_Q); } #endif static VALUE rb_gsl_cdf_chisq_P(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_chisq_P); } static VALUE rb_gsl_cdf_chisq_Q(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_chisq_Q); } static VALUE rb_gsl_cdf_chisq_Pinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_chisq_Pinv); } static VALUE rb_gsl_cdf_chisq_Qinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_chisq_Qinv); } static VALUE rb_gsl_cdf_fdist_P(VALUE obj, VALUE x, VALUE nu1, VALUE nu2) { return rb_gsl_eval_pdf_cdf3(x, nu1, nu2, gsl_cdf_fdist_P); } static VALUE rb_gsl_cdf_fdist_Q(VALUE obj, VALUE x, VALUE nu1, VALUE nu2) { return rb_gsl_eval_pdf_cdf3(x, nu1, nu2, gsl_cdf_fdist_Q); } static VALUE rb_gsl_cdf_tdist_P(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_tdist_P); } static VALUE rb_gsl_cdf_tdist_Q(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_tdist_Q); } static VALUE rb_gsl_cdf_tdist_Pinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_tdist_Pinv); } static VALUE rb_gsl_cdf_tdist_Qinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_tdist_Qinv); } static VALUE rb_gsl_cdf_beta_P(VALUE obj, VALUE x, VALUE nu1, VALUE nu2) { return rb_gsl_eval_pdf_cdf3(x, nu1, nu2, gsl_cdf_beta_P); } static VALUE rb_gsl_cdf_beta_Q(VALUE obj, VALUE x, VALUE nu1, VALUE nu2) { return rb_gsl_eval_pdf_cdf3(x, nu1, nu2, gsl_cdf_beta_Q); } static VALUE rb_gsl_cdf_logistic_P(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_logistic_P); } static VALUE rb_gsl_cdf_logistic_Q(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_logistic_Q); } static VALUE rb_gsl_cdf_logistic_Pinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_logistic_Pinv); } static VALUE rb_gsl_cdf_logistic_Qinv(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_cdf_logistic_Qinv); } static VALUE rb_gsl_cdf_pareto_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_pareto_P); } static VALUE rb_gsl_cdf_pareto_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_pareto_Q); } static VALUE rb_gsl_cdf_pareto_Pinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_pareto_Pinv); } static VALUE rb_gsl_cdf_pareto_Qinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_pareto_Qinv); } static VALUE rb_gsl_cdf_weibull_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_weibull_P); } static VALUE rb_gsl_cdf_weibull_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_weibull_Q); } static VALUE rb_gsl_cdf_weibull_Pinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_weibull_Pinv); } static VALUE rb_gsl_cdf_weibull_Qinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_weibull_Qinv); } static VALUE rb_gsl_cdf_gumbel1_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel1_P); } static VALUE rb_gsl_cdf_gumbel1_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel1_Q); } static VALUE rb_gsl_cdf_gumbel1_Pinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel1_Pinv); } static VALUE rb_gsl_cdf_gumbel1_Qinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel1_Qinv); } static VALUE rb_gsl_cdf_gumbel2_P(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel2_P); } static VALUE rb_gsl_cdf_gumbel2_Q(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel2_Q); } static VALUE rb_gsl_cdf_gumbel2_Pinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel2_Pinv); } static VALUE rb_gsl_cdf_gumbel2_Qinv(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_cdf_gumbel2_Qinv); } #ifdef GSL_1_8_LATER static VALUE rb_gsl_cdf_binomial_P(VALUE obj, VALUE kk, VALUE pp, VALUE nn) { unsigned int k, n; double p; k = NUM2UINT(kk); n = NUM2UINT(nn); p = NUM2DBL(pp); return rb_float_new(gsl_cdf_binomial_P(k, p, n)); } static VALUE rb_gsl_cdf_binomial_Q(VALUE obj, VALUE kk, VALUE pp, VALUE nn) { unsigned int k, n; double p; k = NUM2UINT(kk); n = NUM2UINT(nn); p = NUM2DBL(pp); return rb_float_new(gsl_cdf_binomial_Q(k, p, n)); } static VALUE rb_gsl_cdf_poisson_P(VALUE obj, VALUE kk, VALUE mm) { unsigned int k; double mu; k = NUM2UINT(kk); mu = NUM2DBL(mm); return rb_float_new(gsl_cdf_poisson_P(k, mu)); } static VALUE rb_gsl_cdf_poisson_Q(VALUE obj, VALUE kk, VALUE mm) { unsigned int k; double mu; k = NUM2UINT(kk); mu = NUM2DBL(mm); return rb_float_new(gsl_cdf_poisson_Q(k, mu)); } static VALUE rb_gsl_cdf_geometric_P(VALUE obj, VALUE kk, VALUE mm) { unsigned int k; double mu; k = NUM2UINT(kk); mu = NUM2DBL(mm); return rb_float_new(gsl_cdf_geometric_P(k, mu)); } static VALUE rb_gsl_cdf_geometric_Q(VALUE obj, VALUE kk, VALUE mm) { unsigned int k; double mu; k = NUM2UINT(kk); mu = NUM2DBL(mm); return rb_float_new(gsl_cdf_geometric_Q(k, mu)); } static VALUE rb_gsl_cdf_negative_binomial_P(VALUE obj, VALUE kk, VALUE pp, VALUE nn) { unsigned int k; double p, n; k = NUM2UINT(kk); p = NUM2DBL(pp); n = NUM2DBL(nn); return rb_float_new(gsl_cdf_negative_binomial_P(k, p, n)); } static VALUE rb_gsl_cdf_negative_binomial_Q(VALUE obj, VALUE kk, VALUE pp, VALUE nn) { unsigned int k; double p, n; k = NUM2UINT(kk); p = NUM2DBL(pp); n = NUM2DBL(nn); return rb_float_new(gsl_cdf_negative_binomial_Q(k, p, n)); } static VALUE rb_gsl_cdf_pascal_P(VALUE obj, VALUE kk, VALUE pp, VALUE nn) { unsigned int k, n; double p; k = NUM2UINT(kk); n = NUM2UINT(nn); p = NUM2DBL(pp); return rb_float_new(gsl_cdf_pascal_P(k, p, n)); } static VALUE rb_gsl_cdf_pascal_Q(VALUE obj, VALUE kk, VALUE pp, VALUE nn) { unsigned int k, n; double p; k = NUM2UINT(kk); n = NUM2UINT(nn); p = NUM2DBL(pp); return rb_float_new(gsl_cdf_pascal_Q(k, p, n)); } static VALUE rb_gsl_cdf_hypergeometric_P(VALUE obj, VALUE kk, VALUE nn1, VALUE nn2, VALUE tt) { unsigned int k, n1, n2, t; k = NUM2UINT(kk); n1 = NUM2UINT(nn1); n2 = NUM2UINT(nn2); t = NUM2UINT(tt); return rb_float_new(gsl_cdf_hypergeometric_P(k, n1, n2, t)); } static VALUE rb_gsl_cdf_hypergeometric_Q(VALUE obj, VALUE kk, VALUE nn1, VALUE nn2, VALUE tt) { unsigned int k, n1, n2, t; k = NUM2UINT(kk); n1 = NUM2UINT(nn1); n2 = NUM2UINT(nn2); t = NUM2UINT(tt); return rb_float_new(gsl_cdf_hypergeometric_Q(k, n1, n2, t)); } static VALUE rb_gsl_cdf_beta_Pinv(VALUE obj, VALUE pp, VALUE aa, VALUE bb) { double P, a, b; P = NUM2DBL(pp); a = NUM2DBL(aa); b = NUM2DBL(bb); return rb_float_new(gsl_cdf_beta_Pinv(P, a, b)); } static VALUE rb_gsl_cdf_beta_Qinv(VALUE obj, VALUE qq, VALUE aa, VALUE bb) { double Q, a, b; Q = NUM2DBL(qq); a = NUM2DBL(aa); b = NUM2DBL(bb); return rb_float_new(gsl_cdf_beta_Qinv(Q, a, b)); } static VALUE rb_gsl_cdf_fdist_Pinv(VALUE obj, VALUE pp, VALUE aa, VALUE bb) { double P, a, b; P = NUM2DBL(pp); a = NUM2DBL(aa); b = NUM2DBL(bb); return rb_float_new(gsl_cdf_fdist_Pinv(P, a, b)); } static VALUE rb_gsl_cdf_fdist_Qinv(VALUE obj, VALUE qq, VALUE aa, VALUE bb) { double Q, a, b; Q = NUM2DBL(qq); a = NUM2DBL(aa); b = NUM2DBL(bb); return rb_float_new(gsl_cdf_fdist_Qinv(Q, a, b)); } #endif void Init_gsl_cdf(VALUE module) { VALUE mgsl_cdf; mgsl_cdf = rb_define_module_under(module, "Cdf"); /***** Cumulative distribution functions *****/ rb_define_module_function(module, "cdf_gaussian_P", rb_gsl_cdf_gaussian_P, -1); rb_define_module_function(module, "cdf_ugaussian_P", rb_gsl_cdf_gaussian_P, -1); rb_define_module_function(module, "cdf_gaussian_Q", rb_gsl_cdf_gaussian_Q, -1); rb_define_module_function(module, "cdf_ugaussian_Q", rb_gsl_cdf_gaussian_Q, -1); rb_define_module_function(module, "cdf_gaussian_Pinv", rb_gsl_cdf_gaussian_Pinv, -1); rb_define_module_function(module, "cdf_ugaussian_Pinv", rb_gsl_cdf_gaussian_Pinv, -1); rb_define_module_function(module, "cdf_gaussian_Qinv", rb_gsl_cdf_gaussian_Qinv, -1); rb_define_module_function(module, "cdf_ugaussian_Qinv", rb_gsl_cdf_gaussian_Qinv, -1); rb_define_module_function(module, "cdf_exponential_P", rb_gsl_cdf_exponential_P, 2); rb_define_module_function(module, "cdf_exponential_Q", rb_gsl_cdf_exponential_Q, 2); rb_define_module_function(module, "cdf_exponential_Pinv", rb_gsl_cdf_exponential_Pinv, 2); rb_define_module_function(module, "cdf_exponential_Qinv", rb_gsl_cdf_exponential_Qinv, 2); rb_define_module_function(module, "cdf_laplace_P", rb_gsl_cdf_laplace_P, 2); rb_define_module_function(module, "cdf_laplace_Q", rb_gsl_cdf_laplace_Q, 2); rb_define_module_function(module, "cdf_laplace_Pinv", rb_gsl_cdf_laplace_Pinv, 2); rb_define_module_function(module, "cdf_laplace_Qinv", rb_gsl_cdf_laplace_Qinv, 2); rb_define_module_function(module, "cdf_cauchy_P", rb_gsl_cdf_cauchy_P, 2); rb_define_module_function(module, "cdf_cauchy_Q", rb_gsl_cdf_cauchy_Q, 2); rb_define_module_function(module, "cdf_cauchy_Pinv", rb_gsl_cdf_cauchy_Pinv, 2); rb_define_module_function(module, "cdf_cauchy_Qinv", rb_gsl_cdf_cauchy_Qinv, 2); rb_define_module_function(module, "cdf_rayleigh_P", rb_gsl_cdf_rayleigh_P, 2); rb_define_module_function(module, "cdf_rayleigh_Q", rb_gsl_cdf_rayleigh_Q, 2); rb_define_module_function(module, "cdf_rayleigh_Pinv", rb_gsl_cdf_rayleigh_Pinv, 2); rb_define_module_function(module, "cdf_rayleigh_Qinv", rb_gsl_cdf_rayleigh_Qinv, 2); rb_define_module_function(module, "cdf_gamma_P", rb_gsl_cdf_gamma_P, 3); rb_define_module_function(module, "cdf_gamma_Q", rb_gsl_cdf_gamma_Q, 3); rb_define_module_function(module, "cdf_gamma_Pinv", rb_gsl_cdf_gamma_Pinv, 3); rb_define_module_function(module, "cdf_gamma_Qinv", rb_gsl_cdf_gamma_Qinv, 3); rb_define_module_function(module, "cdf_flat_P", rb_gsl_cdf_flat_P, 3); rb_define_module_function(module, "cdf_flat_Q", rb_gsl_cdf_flat_Q, 3); rb_define_module_function(module, "cdf_flat_Pinv", rb_gsl_cdf_flat_Pinv, 3); rb_define_module_function(module, "cdf_flat_Qinv", rb_gsl_cdf_flat_Qinv, 3); rb_define_module_function(module, "cdf_lognormal_P", rb_gsl_cdf_lognormal_P, 3); rb_define_module_function(module, "cdf_lognormal_Q", rb_gsl_cdf_lognormal_Q, 3); rb_define_module_function(module, "cdf_lognormal_Pinv", rb_gsl_cdf_lognormal_Pinv, 3); rb_define_module_function(module, "cdf_lognormal_Qinv", rb_gsl_cdf_lognormal_Qinv, 3); rb_define_module_function(module, "cdf_chisq_P", rb_gsl_cdf_chisq_P, 2); rb_define_module_function(module, "cdf_chisq_Q", rb_gsl_cdf_chisq_Q, 2); rb_define_module_function(module, "cdf_chisq_Pinv", rb_gsl_cdf_chisq_Pinv, 2); rb_define_module_function(module, "cdf_chisq_Qinv", rb_gsl_cdf_chisq_Qinv, 2); rb_define_module_function(module, "cdf_fdist_P", rb_gsl_cdf_fdist_P, 3); rb_define_module_function(module, "cdf_fdist_Q", rb_gsl_cdf_fdist_Q, 3); rb_define_module_function(module, "cdf_tdist_P", rb_gsl_cdf_tdist_P, 2); rb_define_module_function(module, "cdf_tdist_Q", rb_gsl_cdf_tdist_Q, 2); rb_define_module_function(module, "cdf_tdist_Pinv", rb_gsl_cdf_tdist_Pinv, 2); rb_define_module_function(module, "cdf_tdist_Qinv", rb_gsl_cdf_tdist_Qinv, 2); rb_define_module_function(module, "cdf_beta_P", rb_gsl_cdf_beta_P, 3); rb_define_module_function(module, "cdf_beta_Q", rb_gsl_cdf_beta_Q, 3); rb_define_module_function(module, "cdf_logistic_P", rb_gsl_cdf_logistic_P, 2); rb_define_module_function(module, "cdf_logistic_Q", rb_gsl_cdf_logistic_Q, 2); rb_define_module_function(module, "cdf_logistic_Pinv", rb_gsl_cdf_logistic_Pinv, 2); rb_define_module_function(module, "cdf_logistic_Qinv", rb_gsl_cdf_logistic_Qinv, 2); rb_define_module_function(module, "cdf_pareto_P", rb_gsl_cdf_pareto_P, 3); rb_define_module_function(module, "cdf_pareto_Q", rb_gsl_cdf_pareto_Q, 3); rb_define_module_function(module, "cdf_pareto_Pinv", rb_gsl_cdf_pareto_Pinv, 3); rb_define_module_function(module, "cdf_pareto_Qinv", rb_gsl_cdf_pareto_Qinv, 3); rb_define_module_function(module, "cdf_weibull_P", rb_gsl_cdf_weibull_P, 3); rb_define_module_function(module, "cdf_weibull_Q", rb_gsl_cdf_weibull_Q, 3); rb_define_module_function(module, "cdf_weibull_Pinv", rb_gsl_cdf_weibull_Pinv, 3); rb_define_module_function(module, "cdf_weibull_Qinv", rb_gsl_cdf_weibull_Qinv, 3); rb_define_module_function(module, "cdf_gumbel1_P", rb_gsl_cdf_gumbel1_P, 3); rb_define_module_function(module, "cdf_gumbel1_Q", rb_gsl_cdf_gumbel1_Q, 3); rb_define_module_function(module, "cdf_gumbel1_Pinv", rb_gsl_cdf_gumbel1_Pinv, 3); rb_define_module_function(module, "cdf_gumbel1_Qinv", rb_gsl_cdf_gumbel1_Qinv, 3); rb_define_module_function(module, "cdf_gumbel2_P", rb_gsl_cdf_gumbel2_P, 3); rb_define_module_function(module, "cdf_gumbel2_Q", rb_gsl_cdf_gumbel2_Q, 3); rb_define_module_function(module, "cdf_gumbel2_Pinv", rb_gsl_cdf_gumbel2_Pinv, 3); rb_define_module_function(module, "cdf_gumbel2_Qinv", rb_gsl_cdf_gumbel2_Qinv, 3); /*****/ rb_define_module_function(mgsl_cdf, "gaussian_P", rb_gsl_cdf_gaussian_P, -1); rb_define_module_function(mgsl_cdf, "gaussian_Q", rb_gsl_cdf_gaussian_Q, -1); rb_define_module_function(mgsl_cdf, "gaussian_Pinv", rb_gsl_cdf_gaussian_Pinv, -1); rb_define_module_function(mgsl_cdf, "gaussian_Qinv", rb_gsl_cdf_gaussian_Qinv, -1); rb_define_module_function(mgsl_cdf, "ugaussian_P", rb_gsl_cdf_gaussian_P, -1); rb_define_module_function(mgsl_cdf, "ugaussian_Q", rb_gsl_cdf_gaussian_Q, -1); rb_define_module_function(mgsl_cdf, "ugaussian_Pinv", rb_gsl_cdf_gaussian_Pinv, -1); rb_define_module_function(mgsl_cdf, "ugaussian_Qinv", rb_gsl_cdf_gaussian_Qinv, -1); rb_define_module_function(mgsl_cdf, "exponential_P", rb_gsl_cdf_exponential_P, 2); rb_define_module_function(mgsl_cdf, "exponential_Q", rb_gsl_cdf_exponential_Q, 2); rb_define_module_function(mgsl_cdf, "exponential_Pinv", rb_gsl_cdf_exponential_Pinv, 2); rb_define_module_function(mgsl_cdf, "exponential_Qinv", rb_gsl_cdf_exponential_Qinv, 2); rb_define_module_function(mgsl_cdf, "laplace_P", rb_gsl_cdf_laplace_P, 2); rb_define_module_function(mgsl_cdf, "laplace_Q", rb_gsl_cdf_laplace_Q, 2); rb_define_module_function(mgsl_cdf, "laplace_Pinv", rb_gsl_cdf_laplace_Pinv, 2); rb_define_module_function(mgsl_cdf, "laplace_Qinv", rb_gsl_cdf_laplace_Qinv, 2); rb_define_module_function(mgsl_cdf, "cauchy_P", rb_gsl_cdf_cauchy_P, 2); rb_define_module_function(mgsl_cdf, "cauchy_Q", rb_gsl_cdf_cauchy_Q, 2); rb_define_module_function(mgsl_cdf, "cauchy_Pinv", rb_gsl_cdf_cauchy_Pinv, 2); rb_define_module_function(mgsl_cdf, "cauchy_Qinv", rb_gsl_cdf_cauchy_Qinv, 2); rb_define_module_function(mgsl_cdf, "rayleigh_P", rb_gsl_cdf_rayleigh_P, 2); rb_define_module_function(mgsl_cdf, "rayleigh_Q", rb_gsl_cdf_rayleigh_Q, 2); rb_define_module_function(mgsl_cdf, "rayleigh_Pinv", rb_gsl_cdf_rayleigh_Pinv, 2); rb_define_module_function(mgsl_cdf, "rayleigh_Qinv", rb_gsl_cdf_rayleigh_Qinv, 2); rb_define_module_function(mgsl_cdf, "gamma_P", rb_gsl_cdf_gamma_P, 3); rb_define_module_function(mgsl_cdf, "gamma_Q", rb_gsl_cdf_gamma_Q, 3); rb_define_module_function(mgsl_cdf, "gamma_Pinv", rb_gsl_cdf_gamma_Pinv, 3); rb_define_module_function(mgsl_cdf, "gamma_Qinv", rb_gsl_cdf_gamma_Qinv, 3); rb_define_module_function(mgsl_cdf, "flat_P", rb_gsl_cdf_flat_P, 3); rb_define_module_function(mgsl_cdf, "flat_Q", rb_gsl_cdf_flat_Q, 3); rb_define_module_function(mgsl_cdf, "flat_Pinv", rb_gsl_cdf_flat_Pinv, 3); rb_define_module_function(mgsl_cdf, "flat_Qinv", rb_gsl_cdf_flat_Qinv, 3); rb_define_module_function(mgsl_cdf, "lognormal_P", rb_gsl_cdf_lognormal_P, 3); rb_define_module_function(mgsl_cdf, "lognormal_Q", rb_gsl_cdf_lognormal_Q, 3); rb_define_module_function(mgsl_cdf, "lognormal_Pinv", rb_gsl_cdf_lognormal_Pinv, 3); rb_define_module_function(mgsl_cdf, "lognormal_Qinv", rb_gsl_cdf_lognormal_Qinv, 3); rb_define_module_function(mgsl_cdf, "chisq_P", rb_gsl_cdf_chisq_P, 2); rb_define_module_function(mgsl_cdf, "chisq_Q", rb_gsl_cdf_chisq_Q, 2); rb_define_module_function(mgsl_cdf, "chisq_Pinv", rb_gsl_cdf_chisq_Pinv, 2); rb_define_module_function(mgsl_cdf, "chisq_Qinv", rb_gsl_cdf_chisq_Qinv, 2); rb_define_module_function(mgsl_cdf, "fdist_P", rb_gsl_cdf_fdist_P, 3); rb_define_module_function(mgsl_cdf, "fdist_Q", rb_gsl_cdf_fdist_Q, 3); rb_define_module_function(mgsl_cdf, "tdist_P", rb_gsl_cdf_tdist_P, 2); rb_define_module_function(mgsl_cdf, "tdist_Q", rb_gsl_cdf_tdist_Q, 2); rb_define_module_function(mgsl_cdf, "tdist_Pinv", rb_gsl_cdf_tdist_Pinv, 2); rb_define_module_function(mgsl_cdf, "tdist_Qinv", rb_gsl_cdf_tdist_Qinv, 2); rb_define_module_function(mgsl_cdf, "beta_P", rb_gsl_cdf_beta_P, 3); rb_define_module_function(mgsl_cdf, "beta_Q", rb_gsl_cdf_beta_Q, 3); rb_define_module_function(mgsl_cdf, "logistic_P", rb_gsl_cdf_logistic_P, 2); rb_define_module_function(mgsl_cdf, "logistic_Q", rb_gsl_cdf_logistic_Q, 2); rb_define_module_function(mgsl_cdf, "logistic_Pinv", rb_gsl_cdf_logistic_Pinv, 2); rb_define_module_function(mgsl_cdf, "logistic_Qinv", rb_gsl_cdf_logistic_Qinv, 2); rb_define_module_function(mgsl_cdf, "pareto_P", rb_gsl_cdf_pareto_P, 3); rb_define_module_function(mgsl_cdf, "pareto_Q", rb_gsl_cdf_pareto_Q, 3); rb_define_module_function(mgsl_cdf, "pareto_Pinv", rb_gsl_cdf_pareto_Pinv, 3); rb_define_module_function(mgsl_cdf, "pareto_Qinv", rb_gsl_cdf_pareto_Qinv, 3); rb_define_module_function(mgsl_cdf, "weibull_P", rb_gsl_cdf_weibull_P, 3); rb_define_module_function(mgsl_cdf, "weibull_Q", rb_gsl_cdf_weibull_Q, 3); rb_define_module_function(mgsl_cdf, "weibull_Pinv", rb_gsl_cdf_weibull_Pinv, 3); rb_define_module_function(mgsl_cdf, "weibull_Qinv", rb_gsl_cdf_weibull_Qinv, 3); rb_define_module_function(mgsl_cdf, "gumbel1_P", rb_gsl_cdf_gumbel1_P, 3); rb_define_module_function(mgsl_cdf, "gumbel1_Q", rb_gsl_cdf_gumbel1_Q, 3); rb_define_module_function(mgsl_cdf, "gumbel1_Pinv", rb_gsl_cdf_gumbel1_Pinv, 3); rb_define_module_function(mgsl_cdf, "gumbel1_Qinv", rb_gsl_cdf_gumbel1_Qinv, 3); rb_define_module_function(mgsl_cdf, "gumbel2_P", rb_gsl_cdf_gumbel2_P, 3); rb_define_module_function(mgsl_cdf, "gumbel2_Q", rb_gsl_cdf_gumbel2_Q, 3); rb_define_module_function(mgsl_cdf, "gumbel2_Pinv", rb_gsl_cdf_gumbel2_Pinv, 3); rb_define_module_function(mgsl_cdf, "gumbel2_Qinv", rb_gsl_cdf_gumbel2_Qinv, 3); #ifdef GSL_1_6_LATER rb_define_module_function(module, "cdf_exppow_P", rb_gsl_cdf_exppow_P, 3); rb_define_module_function(module, "cdf_exppow_Q", rb_gsl_cdf_exppow_Q, 3); rb_define_module_function(mgsl_cdf, "exppow_P", rb_gsl_cdf_exppow_P, 3); rb_define_module_function(mgsl_cdf, "exppow_Q", rb_gsl_cdf_exppow_Q, 3); #endif #ifdef GSL_1_8_LATER rb_define_module_function(module, "cdf_binomial_P", rb_gsl_cdf_binomial_P, 3); rb_define_module_function(module, "cdf_binomial_Q", rb_gsl_cdf_binomial_Q, 3); rb_define_module_function(mgsl_cdf, "binomial_P", rb_gsl_cdf_binomial_P, 3); rb_define_module_function(mgsl_cdf, "binomial_Q", rb_gsl_cdf_binomial_Q, 3); rb_define_module_function(module, "cdf_poisson_P", rb_gsl_cdf_poisson_P, 2); rb_define_module_function(module, "cdf_poisson_Q", rb_gsl_cdf_poisson_Q, 2); rb_define_module_function(mgsl_cdf, "poisson_P", rb_gsl_cdf_poisson_P, 2); rb_define_module_function(mgsl_cdf, "poisson_Q", rb_gsl_cdf_poisson_Q, 2); rb_define_module_function(module, "cdf_geometric_P", rb_gsl_cdf_geometric_P, 2); rb_define_module_function(module, "cdf_geometric_Q", rb_gsl_cdf_geometric_Q, 2); rb_define_module_function(mgsl_cdf, "geometric_P", rb_gsl_cdf_geometric_P, 2); rb_define_module_function(mgsl_cdf, "geometric_Q", rb_gsl_cdf_geometric_Q, 2); rb_define_module_function(module, "cdf_negative_binomial_P", rb_gsl_cdf_negative_binomial_P, 3); rb_define_module_function(module, "cdf_negative_binomial_Q", rb_gsl_cdf_negative_binomial_Q, 3); rb_define_module_function(mgsl_cdf, "negative_binomial_P", rb_gsl_cdf_negative_binomial_P, 3); rb_define_module_function(mgsl_cdf, "negative_binomial_Q", rb_gsl_cdf_negative_binomial_Q, 3); rb_define_module_function(module, "cdf_pascal_P", rb_gsl_cdf_pascal_P, 3); rb_define_module_function(module, "cdf_pascal_Q", rb_gsl_cdf_pascal_Q, 3); rb_define_module_function(mgsl_cdf, "pascal_P", rb_gsl_cdf_pascal_P, 3); rb_define_module_function(mgsl_cdf, "pascal_Q", rb_gsl_cdf_pascal_Q, 3); rb_define_module_function(module, "cdf_hypergeometric_P", rb_gsl_cdf_hypergeometric_P, 4); rb_define_module_function(module, "cdf_hypergeometric_Q", rb_gsl_cdf_hypergeometric_Q, 4); rb_define_module_function(mgsl_cdf, "hypergeometric_P", rb_gsl_cdf_hypergeometric_P, 4); rb_define_module_function(mgsl_cdf, "hypergeometric_Q", rb_gsl_cdf_hypergeometric_Q, 4); rb_define_module_function(module, "cdf_beta_Pinv", rb_gsl_cdf_beta_Pinv, 3); rb_define_module_function(mgsl_cdf, "beta_Pinv", rb_gsl_cdf_beta_Pinv, 3); rb_define_module_function(module, "cdf_beta_Qinv", rb_gsl_cdf_beta_Qinv, 3); rb_define_module_function(mgsl_cdf, "beta_Qinv", rb_gsl_cdf_beta_Qinv, 3); rb_define_module_function(module, "cdf_fdist_Pinv", rb_gsl_cdf_fdist_Pinv, 3); rb_define_module_function(mgsl_cdf, "fdist_Pinv", rb_gsl_cdf_fdist_Pinv, 3); rb_define_module_function(module, "cdf_fdist_Qinv", rb_gsl_cdf_fdist_Qinv, 3); rb_define_module_function(mgsl_cdf, "fdist_Qinv", rb_gsl_cdf_fdist_Qinv, 3); #endif } #endif gsl-1.15.3/ext/sum.c0000644000175000017500000001307512220252463013520 0ustar boutilboutil/* sum.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include static VALUE rb_gsl_sum_accel(VALUE obj) { gsl_sum_levin_u_workspace *w = NULL; double sum, err, sum_plain, *ptr; size_t terms_used, n, stride; ptr = get_vector_ptr(obj, &stride, &n); w = gsl_sum_levin_u_alloc(n); gsl_sum_levin_u_accel(ptr, n, w, &sum, &err); sum_plain = w->sum_plain; terms_used = w->terms_used; gsl_sum_levin_u_free(w); return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), rb_float_new(sum_plain), INT2FIX(terms_used)); } static VALUE rb_gsl_utrunc_accel(VALUE obj) { gsl_sum_levin_utrunc_workspace *w = NULL; double sum, err, sum_plain, *ptr; size_t terms_used, n, stride; ptr = get_vector_ptr(obj, &stride, &n); w = gsl_sum_levin_utrunc_alloc(n); gsl_sum_levin_utrunc_accel(ptr, n, w, &sum, &err); sum_plain = w->sum_plain; terms_used = w->terms_used; gsl_sum_levin_utrunc_free(w); return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), rb_float_new(sum_plain), INT2FIX(terms_used)); } static VALUE rb_gsl_sum_levin_u_new(VALUE klass, VALUE nn) { gsl_sum_levin_u_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_sum_levin_u_alloc(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, gsl_sum_levin_u_free, w); } static VALUE rb_gsl_sum_levin_utrunc_new(VALUE klass, VALUE nn) { gsl_sum_levin_utrunc_workspace *w = NULL; CHECK_FIXNUM(nn); w = gsl_sum_levin_utrunc_alloc(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, gsl_sum_levin_utrunc_free, w); } /* singleton */ static VALUE rb_gsl_sum_levin_u_accel2(VALUE obj, VALUE vv) { gsl_sum_levin_u_workspace *w = NULL; double sum, err, sum_plain; size_t terms_used, n, stride; double *ptr; ptr = get_vector_ptr(vv, &stride, &n); w = gsl_sum_levin_u_alloc(n); gsl_sum_levin_u_accel(ptr, n, w, &sum, &err); sum_plain = w->sum_plain; terms_used = w->terms_used; gsl_sum_levin_u_free(w); return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), rb_float_new(sum_plain), INT2FIX(terms_used)); } static VALUE rb_gsl_sum_levin_utrunc_accel2(VALUE obj, VALUE vv) { gsl_sum_levin_utrunc_workspace *w = NULL; double sum, err, sum_plain; size_t terms_used, n, stride; double *ptr; ptr = get_vector_ptr(vv, &stride, &n); w = gsl_sum_levin_utrunc_alloc(n); gsl_sum_levin_utrunc_accel(ptr, n, w, &sum, &err); sum_plain = w->sum_plain; terms_used = w->terms_used; gsl_sum_levin_utrunc_free(w); return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), rb_float_new(sum_plain), INT2FIX(terms_used)); } static VALUE rb_gsl_sum_levin_u_sum_plain(VALUE obj) { gsl_sum_levin_u_workspace *w = NULL; Data_Get_Struct(obj, gsl_sum_levin_u_workspace, w); return rb_float_new(w->sum_plain); } static VALUE rb_gsl_sum_levin_u_terms_used(VALUE obj) { gsl_sum_levin_u_workspace *w = NULL; Data_Get_Struct(obj, gsl_sum_levin_u_workspace, w); return INT2FIX(w->terms_used); } static VALUE rb_gsl_sum_levin_utrunc_sum_plain(VALUE obj) { gsl_sum_levin_utrunc_workspace *w = NULL; Data_Get_Struct(obj, gsl_sum_levin_utrunc_workspace, w); return rb_float_new(w->sum_plain); } static VALUE rb_gsl_sum_levin_utrunc_terms_used(VALUE obj) { gsl_sum_levin_utrunc_workspace *w = NULL; Data_Get_Struct(obj, gsl_sum_levin_utrunc_workspace, w); return INT2FIX(w->terms_used); } void Init_gsl_sum(VALUE module) { VALUE mgsl_sum; VALUE cgsl_sum_levin_u, cgsl_sum_levin_utrunc; mgsl_sum = rb_define_module_under(module, "Sum"); cgsl_sum_levin_u = rb_define_class_under(mgsl_sum, "Levin_u", cGSL_Object); cgsl_sum_levin_utrunc = rb_define_class_under(mgsl_sum, "Levin_utrunc", cGSL_Object); rb_define_singleton_method(cgsl_sum_levin_u, "new", rb_gsl_sum_levin_u_new, 1); rb_define_singleton_method(cgsl_sum_levin_u, "alloc", rb_gsl_sum_levin_u_new, 1); rb_define_singleton_method(cgsl_sum_levin_utrunc, "new", rb_gsl_sum_levin_utrunc_new, 1); rb_define_singleton_method(cgsl_sum_levin_utrunc, "alloc", rb_gsl_sum_levin_utrunc_new, 1); rb_define_singleton_method(cgsl_sum_levin_u, "accel", rb_gsl_sum_levin_u_accel2, 1); rb_define_singleton_method(cgsl_sum_levin_utrunc, "accel", rb_gsl_sum_levin_utrunc_accel2, 1); rb_define_method(cgsl_sum_levin_u, "accel", rb_gsl_sum_levin_u_accel2, 1); rb_define_method(cgsl_sum_levin_utrunc, "accel", rb_gsl_sum_levin_utrunc_accel2, 1); rb_define_method(cgsl_sum_levin_u, "sum_plain", rb_gsl_sum_levin_u_sum_plain, 0); rb_define_method(cgsl_sum_levin_u, "terms_used", rb_gsl_sum_levin_u_terms_used, 0); rb_define_method(cgsl_sum_levin_utrunc, "sum_plain", rb_gsl_sum_levin_utrunc_sum_plain, 0); rb_define_method(cgsl_sum_levin_utrunc, "terms_used", rb_gsl_sum_levin_utrunc_terms_used, 0); /***/ rb_define_method(cgsl_vector, "accel_sum", rb_gsl_sum_accel, 0); rb_define_alias(cgsl_vector, "accel", "accel_sum"); rb_define_alias(cgsl_vector, "sum_accel", "accel_sum"); rb_define_method(cgsl_vector, "utrunc_accel", rb_gsl_utrunc_accel, 0); #ifdef HAVE_NARRAY_H rb_define_method(cNArray, "accel_sum", rb_gsl_sum_accel, 0); rb_define_alias(cNArray, "accel", "accel_sum"); rb_define_alias(cNArray, "sum_accel", "accel_sum"); rb_define_method(cNArray, "utrunc_accel", rb_gsl_utrunc_accel, 0); #endif } gsl-1.15.3/ext/common.c0000644000175000017500000001467612220252463014214 0ustar boutilboutil/* common.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_histogram.h" #include #include FILE* rb_gsl_open_writefile(VALUE io, int *flag) { #ifdef RUBY_1_9_LATER rb_io_t *fptr = NULL; #else OpenFile *fptr = NULL; #endif FILE *fp = NULL; char *name; switch (TYPE(io)) { case T_STRING: name = RSTRING_PTR(io); fp = fopen(name, "w"); *flag = 1; break; case T_FILE: GetOpenFile(io, fptr); /* #ifdef RUBY_1_9_LATER name = STR2CSTR(fptr->pathv); #else name = fptr->path; #endif */ rb_io_check_writable(fptr); #ifdef RUBY_1_9_LATER fp = rb_io_stdio_file(fptr); #else fp = GetWriteFile(fptr); #endif *flag = 0; break; default: rb_raise(rb_eTypeError, "argv 1 String or File expected"); break; } // if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name); if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file."); return fp; } FILE* rb_gsl_open_readfile(VALUE io, int *flag) { #ifdef RUBY_1_9_LATER rb_io_t *fptr = NULL; #else OpenFile *fptr = NULL; #endif FILE *fp = NULL; char *name; switch (TYPE(io)) { case T_STRING: name = RSTRING_PTR(io); fp = fopen(name, "r"); *flag = 1; break; case T_FILE: GetOpenFile(io, fptr); /* #ifdef RUBY_1_9_LATER name = STR2CSTR(fptr->pathv); #else name = fptr->path; #endif */ rb_io_check_readable(fptr); #ifdef RUBY_1_9_LATER fp = rb_io_stdio_file(fptr); #else fp = fptr->f; #endif *flag = 0; break; default: rb_raise(rb_eTypeError, "argv 1 String or File expected"); break; } // if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name); if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file"); return fp; } VALUE rb_gsl_obj_read_only(int argc, VALUE *argv, VALUE obj) { rb_raise(rb_eRuntimeError, "Read only object."); } int str_tail_grep(const char *s0, const char *s1) { int len0, len1; char *p = NULL; len0 = strlen(s0); len1 = strlen(s1); p = (char *) s0 + len0 - len1; return strcmp(p, s1); } int str_head_grep(const char *s0, const char *s1) { int len0, len1; size_t i, len; char *p0, *p1; len0 = strlen(s0); len1 = strlen(s1); len = (size_t) GSL_MIN_INT(len0, len1); p0 = (char *) s0; p1 = (char *) s1; for (i = 0; i < len; i++) if (*p0++ != *p1++) return 1; return 0; } size_t count_columns(const char *str) { size_t n = 0; int flag = 1; char *p; p = (char *) str; do { if (isspace(*p)) { flag = 1; } else { if (flag == 1) { flag = 0; n++; } } p++; } while (*p != '\0' && *p != '\n'); return n; } char* str_scan_double(const char *str, double *val) { char buf[256]; char *p, *q; double x; int flag = 0; p = (char *) str; q = buf; do { if (isspace(*p)) { if (flag == 0) { /* do nothing */ } else { break; } } else { *q++ = *p; flag = 1; } p++; } while (*p != '\0' && *p != '\n'); if (flag == 0) { *val = 0; return NULL; } *q = '\0'; flag = sscanf(buf, "%lf", &x); if (flag == 1) { *val = x; return p; } else { *val = 0; return NULL; } } char* str_scan_int(const char *str, int *val) { char buf[256]; char *p, *q; int x; int flag = 0; p = (char *) str; q = buf; do { if (isspace(*p)) { if (flag == 0) { /* do nothing */ } else { break; } } else { *q++ = *p; flag = 1; } p++; } while (*p != '\0' && *p != '\n'); if (flag == 0) { *val = 0; return NULL; } *q = '\0'; flag = sscanf(buf, "%d", &x); if (flag == 1) { *val = x; return p; } else { *val = 0; return NULL; } } double* get_ptr_double3(VALUE obj, size_t *size, size_t *stride, int *flag) { gsl_vector *v; #ifdef HAVE_NARRAY_H double *ptr; struct NARRAY *na; if (NA_IsNArray(obj)) { obj = na_change_type(obj, NA_DFLOAT); GetNArray(obj, na); ptr = (double *) na->ptr; *size = na->total; *stride = 1; *flag = 1; return ptr; } #endif CHECK_VECTOR(obj); Data_Get_Struct(obj, gsl_vector, v); *size = v->size; *stride = v->stride; *flag = 0; return v->data; } gsl_complex ary2complex(VALUE obj) { gsl_complex *z, c; switch (TYPE(obj)) { case T_ARRAY: GSL_SET_REAL(&c, NUM2DBL(rb_ary_entry(obj, 0))); GSL_SET_IMAG(&c, NUM2DBL(rb_ary_entry(obj, 1))); break; default: if (COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_complex, z); c = *z; } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Complex expected)", rb_class2name(CLASS_OF(obj))); } break; } return c; } VALUE vector_eval_create(VALUE obj, double (*func)(double)) { gsl_vector *vnew; size_t i, size, stride; double *ptr; ptr = get_vector_ptr(obj, &stride, &size); vnew = gsl_vector_alloc(size); for (i = 0; i < size; i++) { gsl_vector_set(vnew, i, (*func)(ptr[i*stride])); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } VALUE matrix_eval_create(VALUE obj, double (*func)(double)) { gsl_matrix *m, *mnew; size_t i, j; Data_Get_Struct(obj, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (*func)(gsl_matrix_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } VALUE rb_gsl_ary_eval1(VALUE ary, double (*f)(double)) { VALUE ary2; size_t i, n; double val; // n = RARRAY(ary)->len; n = RARRAY_LEN(ary); ary2 = rb_ary_new2(n); for (i = 0; i < n; i++) { val = (*f)(NUM2DBL(rb_ary_entry(ary, i))); rb_ary_store(ary2, i, rb_float_new(val)); } return ary2; } #ifdef HAVE_NARRAY_H VALUE rb_gsl_nary_eval1(VALUE ary, double (*f)(double)) { VALUE ary2; struct NARRAY *na; double *ptr1, *ptr2; size_t i, n; ary = na_change_type(ary, NA_DFLOAT); GetNArray(ary, na); ptr1 = (double *) na->ptr; n = na->total; ary2 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(ary)); ptr2 = NA_PTR_TYPE(ary2, double*); for (i = 0; i < n; i++) ptr2[i] = (*f)(ptr1[i]); return ary2; } #endif gsl-1.15.3/ext/sf_gamma.c0000644000175000017500000002555512220252463014474 0ustar boutilboutil/* sf_gamma.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_gamma(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_gamma, x); } static VALUE rb_gsl_sf_gamma_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_gamma_e, x); } static VALUE rb_gsl_sf_lngamma(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_lngamma, x); } static VALUE rb_gsl_sf_lngamma_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_lngamma_e, x); } static VALUE rb_gsl_sf_lngamma_sgn_e(VALUE obj, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; double sgn; Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_lngamma_sgn_e(NUM2DBL(x), rslt, &sgn); return rb_ary_new3(2, v, rb_float_new(sgn)); } static VALUE rb_gsl_sf_gammastar(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_gammastar, x); } static VALUE rb_gsl_sf_gammastar_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_gammastar_e, x); } static VALUE rb_gsl_sf_gammainv(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_gammainv, x); } static VALUE rb_gsl_sf_gammainv_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_gammainv_e, x); } static VALUE rb_gsl_sf_lngamma_complex_e(int argc, VALUE *argv, VALUE obj) { gsl_sf_result *lnr, *arg; gsl_complex *z; double re, im; VALUE vlnr, varg; int status; switch (argc) { case 1: CHECK_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_complex, z); re = GSL_REAL(*z); im = GSL_IMAG(*z); break; case 2: Need_Float(argv[0]); Need_Float(argv[1]); re = NUM2DBL(argv[0]); im = NUM2DBL(argv[1]); default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } vlnr = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, lnr); varg = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, arg); status = gsl_sf_lngamma_complex_e(re, im, lnr, arg); return rb_ary_new3(3, vlnr, varg, INT2FIX(status)); } static VALUE rb_gsl_sf_taylorcoeff(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_taylorcoeff, n, x); } static VALUE rb_gsl_sf_taylorcoeff_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_taylorcoeff_e, n, x); } static VALUE rb_gsl_sf_fact(VALUE obj, VALUE n) { return rb_gsl_sf_eval1_uint(gsl_sf_fact, n); } static VALUE rb_gsl_sf_fact_e(VALUE obj, VALUE n) { return rb_gsl_sf_eval_e_uint(gsl_sf_fact_e, n); } static VALUE rb_gsl_sf_doublefact(VALUE obj, VALUE n) { return rb_gsl_sf_eval1_uint(gsl_sf_doublefact, n); } static VALUE rb_gsl_sf_doublefact_e(VALUE obj, VALUE n) { return rb_gsl_sf_eval_e_uint(gsl_sf_doublefact_e, n); } static VALUE rb_gsl_sf_lnfact(VALUE obj, VALUE n) { return rb_gsl_sf_eval1_uint(gsl_sf_lnfact, n); } static VALUE rb_gsl_sf_lnfact_e(VALUE obj, VALUE n) { return rb_gsl_sf_eval_e_uint(gsl_sf_lnfact_e, n); } static VALUE rb_gsl_sf_lndoublefact(VALUE obj, VALUE n) { return rb_gsl_sf_eval1_uint(gsl_sf_lndoublefact, n); } static VALUE rb_gsl_sf_lndoublefact_e(VALUE obj, VALUE n) { return rb_gsl_sf_eval_e_uint(gsl_sf_lndoublefact_e, n); } static VALUE rb_gsl_sf_choose(VALUE obj, VALUE n, VALUE m) { return rb_float_new(gsl_sf_choose(FIX2INT(n), FIX2INT(m))); } static VALUE rb_gsl_sf_choose_e(VALUE obj, VALUE n, VALUE m) { gsl_sf_result *rslt = NULL; VALUE v; CHECK_FIXNUM(n); CHECK_FIXNUM(m); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); gsl_sf_choose_e(FIX2INT(n), FIX2INT(m), rslt); return v; } static VALUE rb_gsl_sf_lnchoose(VALUE obj, VALUE n, VALUE m) { CHECK_FIXNUM(n); CHECK_FIXNUM(m); return rb_float_new(gsl_sf_lnchoose(FIX2INT(n), FIX2INT(m))); } static VALUE rb_gsl_sf_lnchoose_e(VALUE obj, VALUE n, VALUE m) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(n); CHECK_FIXNUM(m); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_lnchoose_e(FIX2INT(n), FIX2INT(m), rslt); return v; } static VALUE rb_gsl_sf_poch(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_poch, a, x); } static VALUE rb_gsl_sf_poch_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_poch_e, a, x); } static VALUE rb_gsl_sf_lnpoch(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_lnpoch, a, x); } static VALUE rb_gsl_sf_lnpoch_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_lnpoch_e, a, x); } static VALUE rb_gsl_sf_lnpoch_sgn_e(VALUE obj, VALUE a, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; double sgn; // local variable "status" declared and set, but never used //int status; Need_Float(a); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_lnpoch_sgn_e(NUM2DBL(a), NUM2DBL(x), rslt, &sgn); return rb_ary_new3(2, v, rb_float_new(sgn)); } static VALUE rb_gsl_sf_pochrel(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_pochrel, a, x); } static VALUE rb_gsl_sf_pochrel_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_pochrel_e, a, x); } static VALUE rb_gsl_sf_gamma_inc_Q(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_gamma_inc_Q, a, x); } static VALUE rb_gsl_sf_gamma_inc_Q_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_gamma_inc_Q_e, a, x); } static VALUE rb_gsl_sf_gamma_inc_P(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_gamma_inc_P, a, x); } static VALUE rb_gsl_sf_gamma_inc_P_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_gamma_inc_P_e, a, x); } static VALUE rb_gsl_sf_gamma_inc(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_gamma_inc_P, a, x); } #ifdef GSL_1_4_LATER static VALUE rb_gsl_sf_gamma_inc_e(VALUE obj, VALUE a, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_gamma_inc_e, a, x); } #endif static VALUE rb_gsl_sf_beta(VALUE obj, VALUE a, VALUE b) { return rb_float_new(gsl_sf_beta(NUM2DBL(a), NUM2DBL(b))); } static VALUE rb_gsl_sf_beta_e(VALUE obj, VALUE a, VALUE b) { return rb_gsl_sf_eval_e_double2(gsl_sf_beta_e, a, b); } static VALUE rb_gsl_sf_lnbeta(VALUE obj, VALUE a, VALUE b) { Need_Float(a); Need_Float(b); return rb_float_new(gsl_sf_lnbeta(NUM2DBL(a), NUM2DBL(b))); } static VALUE rb_gsl_sf_lnbeta_e(VALUE obj, VALUE a, VALUE b) { return rb_gsl_sf_eval_e_double2(gsl_sf_lnbeta_e, a, b); } static VALUE rb_gsl_sf_beta_inc(VALUE obj, VALUE a, VALUE b, VALUE x) { Need_Float(a); Need_Float(b); return rb_gsl_sf_eval_double3(gsl_sf_beta_inc, a, b, x); } static VALUE rb_gsl_sf_beta_inc_e(VALUE obj, VALUE a, VALUE b, VALUE x) { return rb_gsl_sf_eval_e_double3(gsl_sf_beta_inc_e, a, b, x); } double mygsl_binomial_coef(unsigned int n, unsigned int k); double mygsl_binomial_coef(unsigned int n, unsigned int k) { return floor(0.5 + exp(gsl_sf_lnfact(n) - gsl_sf_lnfact(k) - gsl_sf_lnfact(n-k))); } static VALUE rb_gsl_sf_bincoef(VALUE obj, VALUE n, VALUE k) { CHECK_FIXNUM(n); CHECK_FIXNUM(k); return rb_float_new(mygsl_binomial_coef(FIX2UINT(n), FIX2UINT(k))); } void Init_gsl_sf_gamma(VALUE module) { rb_define_const(module, "GAMMA_XMAX", NUM2DBL(GSL_SF_GAMMA_XMAX)); rb_define_module_function(module, "gamma", rb_gsl_sf_gamma, 1); rb_define_module_function(module, "gamma_e", rb_gsl_sf_gamma_e, 1); rb_define_module_function(module, "lngamma", rb_gsl_sf_lngamma, 1); rb_define_module_function(module, "lngamma_e", rb_gsl_sf_lngamma_e, 1); rb_define_module_function(module, "lngamma_sgn_e", rb_gsl_sf_lngamma_sgn_e, 1); rb_define_module_function(module, "gammastar", rb_gsl_sf_gammastar, 1); rb_define_module_function(module, "gammastar_e", rb_gsl_sf_gammastar_e, 1); rb_define_module_function(module, "gammainv", rb_gsl_sf_gammainv, 1); rb_define_module_function(module, "gammainv_e", rb_gsl_sf_gammainv_e, 1); rb_define_module_function(module, "lngamma_complex_e", rb_gsl_sf_lngamma_complex_e, -1); rb_define_module_function(module, "taylorcoeff", rb_gsl_sf_taylorcoeff, 2); rb_define_module_function(module, "taylorcoeff_e", rb_gsl_sf_taylorcoeff_e, 2); rb_define_module_function(module, "fact", rb_gsl_sf_fact, 1); rb_define_module_function(module, "fact_e", rb_gsl_sf_fact_e, 1); rb_define_module_function(module, "doublefact", rb_gsl_sf_doublefact, 1); rb_define_module_function(module, "doublefact_e", rb_gsl_sf_doublefact_e, 1); rb_define_module_function(module, "lnfact", rb_gsl_sf_lnfact, 1); rb_define_module_function(module, "lnfact_e", rb_gsl_sf_lnfact_e, 1); rb_define_module_function(module, "lndoublefact", rb_gsl_sf_lndoublefact, 1); rb_define_module_function(module, "lndoublefact_e", rb_gsl_sf_lndoublefact_e, 1); rb_define_module_function(module, "choose", rb_gsl_sf_choose, 2); rb_define_module_function(module, "choose_e", rb_gsl_sf_choose_e, 2); rb_define_module_function(module, "lnchoose", rb_gsl_sf_lnchoose, 2); rb_define_module_function(module, "lnchoose_e", rb_gsl_sf_lnchoose_e, 2); rb_define_module_function(module, "poch", rb_gsl_sf_poch, 2); rb_define_module_function(module, "poch_e", rb_gsl_sf_poch_e, 2); rb_define_module_function(module, "lnpoch", rb_gsl_sf_lnpoch, 2); rb_define_module_function(module, "lnpoch_e", rb_gsl_sf_lnpoch_e, 2); rb_define_module_function(module, "lnpoch_sgn_e", rb_gsl_sf_lnpoch_sgn_e, 2); rb_define_module_function(module, "pochrel", rb_gsl_sf_pochrel, 2); rb_define_module_function(module, "pochrel_e", rb_gsl_sf_pochrel_e, 2); rb_define_module_function(module, "gamma_inc_P", rb_gsl_sf_gamma_inc_P, 2); rb_define_module_function(module, "gamma_inc_P_e", rb_gsl_sf_gamma_inc_P_e, 2); rb_define_module_function(module, "gamma_inc_Q", rb_gsl_sf_gamma_inc_Q, 2); rb_define_module_function(module, "gamma_inc_Q_e", rb_gsl_sf_gamma_inc_Q_e, 2); rb_define_module_function(module, "gamma_inc", rb_gsl_sf_gamma_inc, 2); #ifdef GSL_1_4_LATER rb_define_module_function(module, "gamma_inc_e", rb_gsl_sf_gamma_inc_e, 2); #endif rb_define_module_function(module, "beta", rb_gsl_sf_beta, 2); rb_define_module_function(module, "beta_e", rb_gsl_sf_beta_e, 2); rb_define_module_function(module, "lnbeta", rb_gsl_sf_lnbeta, 2); rb_define_module_function(module, "lnbeta_e", rb_gsl_sf_lnbeta_e, 2); rb_define_module_function(module, "beta_inc", rb_gsl_sf_beta_inc, 3); rb_define_module_function(module, "beta_inc_e", rb_gsl_sf_beta_inc_e, 3); rb_define_module_function(module, "bincoef", rb_gsl_sf_bincoef, 2); } gsl-1.15.3/ext/histogram3d_source.c0000644000175000017500000005241612220252463016522 0ustar boutilboutil/* histogram3d_source.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ /* This source code is created modifying gsl-1.5/histogram/ *2d.c */ #include "rb_gsl_histogram.h" mygsl_histogram3d* mygsl_histogram3d_alloc(const size_t nx, const size_t ny, const size_t nz) { mygsl_histogram3d *h = NULL; if (nx == 0) GSL_ERROR_VAL ("histogram3d length nx must be positive integer", GSL_EDOM, 0); if (ny == 0) GSL_ERROR_VAL ("histogram3d length ny must be positive integer", GSL_EDOM, 0); if (nz == 0) GSL_ERROR_VAL ("histogram3d length nz must be positive integer", GSL_EDOM, 0); h = (mygsl_histogram3d *) malloc(sizeof(mygsl_histogram3d)); if (h == NULL) GSL_ERROR_VAL ("failed to allocate space for histogram3d struct", GSL_ENOMEM, 0); h->xrange = (double *) malloc ((nx + 1) * sizeof (double)); if (h->xrange == 0) { free (h); /* exception in constructor, avoid memory leak */ GSL_ERROR_VAL ("failed to allocate space for histogram3d x ranges", GSL_ENOMEM, 0); } h->yrange = (double *) malloc ((ny + 1) * sizeof (double)); if (h->yrange == 0) { free (h->xrange); free (h); /* exception in constructor, avoid memory leak */ GSL_ERROR_VAL ("failed to allocate space for histogram3d y ranges", GSL_ENOMEM, 0); } h->zrange = (double *) malloc ((nz + 1) * sizeof (double)); if (h->zrange == 0) { free (h->xrange); free (h->yrange); free (h); /* exception in constructor, avoid memory leak */ GSL_ERROR_VAL ("failed to allocate space for histogram3d z ranges", GSL_ENOMEM, 0); } h->bin = (double *) malloc (nx*ny*nz*sizeof (double)); if (h->bin == 0) { free (h->xrange); free (h->yrange); free (h->zrange); free (h); /* exception in constructor, avoid memory leak */ GSL_ERROR_VAL ("failed to allocate space for histogram bins", GSL_ENOMEM, 0); } h->nx = nx; h->ny = ny; h->nz = nz; return h; } mygsl_histogram3d* mygsl_histogram3d_calloc_uniform(const size_t nx, const size_t ny, const size_t nz, const double xmin, const double xmax, const double ymin, const double ymax, const double zmin, const double zmax) { mygsl_histogram3d *h; size_t i; h = mygsl_histogram3d_alloc(nx, ny, nz); for (i = 0; i < nx + 1; i++) h->xrange[i] = xmin + ((double) i / (double) nx) * (xmax - xmin); for (i = 0; i < ny + 1; i++) h->yrange[i] = ymin + ((double) i / (double) ny) * (ymax - ymin); for (i = 0; i < nz + 1; i++) h->zrange[i] = zmin + ((double) i / (double) nz) * (zmax - zmin); return h; } mygsl_histogram3d* mygsl_histogram3d_calloc(const size_t nx, const size_t ny, const size_t nz) { mygsl_histogram3d *h; size_t i; h = mygsl_histogram3d_alloc(nx, ny, nz); for (i = 0; i < nx + 1; i++) h->xrange[i] = i; for (i = 0; i < ny + 1; i++) h->yrange[i] = i; for (i = 0; i < nz + 1; i++) h->zrange[i] = i; for (i = 0; i < nx*ny*nz; i++) h->bin[i] = 0; return h; } int mygsl_histogram3d_set_ranges_uniform (mygsl_histogram3d * h, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) { size_t i; const size_t nx = h->nx, ny = h->ny, nz = h->nz; if (xmin >= xmax) GSL_ERROR_VAL ("xmin must be less than xmax", GSL_EINVAL, 0); if (ymin >= ymax) GSL_ERROR_VAL ("ymin must be less than ymax", GSL_EINVAL, 0); if (zmin >= zmax) GSL_ERROR_VAL ("zmin must be less than zmax", GSL_EINVAL, 0); for (i = 0; i <= nx; i++) h->xrange[i] = xmin + ((double) i / (double) nx) * (xmax - xmin); for (i = 0; i <= ny; i++) h->yrange[i] = ymin + ((double) i / (double) ny) * (ymax - ymin); for (i = 0; i <= nz; i++) h->zrange[i] = zmin + ((double) i / (double) nz) * (zmax - zmin); for (i = 0; i < nx*ny*nz; i++) h->bin[i] = 0; return GSL_SUCCESS; } int mygsl_histogram3d_set_ranges(mygsl_histogram3d * h, const double xrange[], size_t xsize, const double yrange[], size_t ysize, const double zrange[], size_t zsize) { size_t i; const size_t nx = h->nx, ny = h->ny, nz = h->nz; if (xsize != (nx + 1)) GSL_ERROR_VAL ("size of xrange must match size of histogram", GSL_EINVAL, 0); if (ysize != (ny + 1)) GSL_ERROR_VAL ("size of yrange must match size of histogram", GSL_EINVAL, 0); if (zsize != (nz + 1)) GSL_ERROR_VAL ("size of yrange must match size of histogram", GSL_EINVAL, 0); memcpy(h->xrange, xrange, sizeof(double)*xsize); memcpy(h->yrange, yrange, sizeof(double)*ysize); memcpy(h->zrange, zrange, sizeof(double)*zsize); for (i = 0; i < nx*ny*nz; i++) h->bin[i] = 0; return GSL_SUCCESS; } void mygsl_histogram3d_free (mygsl_histogram3d * h) { free (h->xrange); free (h->yrange); free (h->zrange); free (h->bin); free (h); } /*****/ int mygsl_histogram3d_memcpy(mygsl_histogram3d * dest, const mygsl_histogram3d * src) { size_t nx = src->nx; size_t ny = src->ny; size_t nz = src->nz; if (dest->nx != src->nx || dest->ny != src->ny || dest->nz != src->nz) { GSL_ERROR ("histograms have different sizes, cannot copy", GSL_EINVAL); } memcpy(dest->xrange, src->xrange, sizeof(double)*(nx+1)); memcpy(dest->yrange, src->yrange, sizeof(double)*(ny+1)); memcpy(dest->zrange, src->zrange, sizeof(double)*(nz+1)); memcpy(dest->bin, src->bin, sizeof(double)*nx*ny*nz); return GSL_SUCCESS; } mygsl_histogram3d* mygsl_histogram3d_clone(const mygsl_histogram3d * src) { mygsl_histogram3d *h; h = mygsl_histogram3d_alloc(src->nx, src->ny, src->nz); mygsl_histogram3d_memcpy(h, src); return h; } /*****/ int mygsl_histogram3d_fread(FILE * stream, mygsl_histogram3d * h) { int status = gsl_block_raw_fread (stream, h->xrange, h->nx + 1, 1); if (status) return status; status = gsl_block_raw_fread (stream, h->yrange, h->ny + 1, 1); if (status) return status; status = gsl_block_raw_fread (stream, h->zrange, h->nz + 1, 1); if (status) return status; status = gsl_block_raw_fread (stream, h->bin, h->nx * h->ny * h->nz, 1); return status; } int mygsl_histogram3d_fwrite(FILE * stream, const mygsl_histogram3d * h) { int status = gsl_block_raw_fwrite (stream, h->xrange, h->nx + 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->yrange, h->ny + 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->zrange, h->nz + 1, 1); if (status) return status; status = gsl_block_raw_fwrite (stream, h->bin, h->nx * h->ny * h->nz, 1); return status; } int mygsl_histogram3d_increment(mygsl_histogram3d * h, double x, double y, double z) { int status = mygsl_histogram3d_accumulate (h, x, y, z, 1.0); return status; } int mygsl_find (const size_t n, const double range[], const double x, size_t * i); int mygsl_find2d (const size_t nx, const double xrange[], const size_t ny, const double yrange[], const double x, const double y, size_t * i, size_t * j); int mygsl_find3d (const size_t nx, const double xrange[], const size_t ny, const double yrange[], const size_t nz, const double zrange[], const double x, const double y, const double z, size_t * i, size_t * j, size_t *k); int mygsl_histogram3d_accumulate(mygsl_histogram3d * h, double x, double y, double z, double weight) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t i = 0, j = 0, k = 0; int status = mygsl_find3d (h->nx, h->xrange, h->ny, h->yrange, h->nz, h->zrange, x, y, z, &i, &j, &k); if (status) return GSL_EDOM; if (i >= nx) GSL_ERROR ("index lies outside valid range of 0 .. nx - 1", GSL_ESANITY); if (j >= ny) GSL_ERROR ("index lies outside valid range of 0 .. ny - 1", GSL_ESANITY); if (k >= nz) GSL_ERROR ("index lies outside valid range of 0 .. nz - 1", GSL_ESANITY); h->bin[i*ny*nz + j*nz + k] += weight; return GSL_SUCCESS; } int mygsl_histogram3d_increment2(mygsl_histogram3d * h, double x, double y, double z) { return mygsl_histogram3d_accumulate2(h, x, y, z, 1.0); } int mygsl_histogram3d_accumulate2(mygsl_histogram3d * h, double x, double y, double z, double weight) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t i = 0, j = 0, k = 0; int status; if (x < h->xrange[0]) x = h->xrange[0] + 4*GSL_DBL_EPSILON; if (x > h->xrange[h->nx]) x = h->xrange[h->nx] - 4*GSL_DBL_EPSILON; if (y < h->yrange[0]) y = h->yrange[0] + 4*GSL_DBL_EPSILON; if (y > h->yrange[h->ny]) y = h->yrange[h->ny] - 4*GSL_DBL_EPSILON; if (z < h->zrange[0]) z = h->zrange[0] + 4*GSL_DBL_EPSILON; if (z > h->zrange[h->nz]) z = h->zrange[h->nz] - 4*GSL_DBL_EPSILON; status = mygsl_find3d (h->nx, h->xrange, h->ny, h->yrange, h->nz, h->zrange, x, y, z, &i, &j, &k); if (status) return GSL_EDOM; if (i >= nx) GSL_ERROR ("index lies outside valid range of 0 .. nx - 1", GSL_ESANITY); if (j >= ny) GSL_ERROR ("index lies outside valid range of 0 .. ny - 1", GSL_ESANITY); if (k >= nz) GSL_ERROR ("index lies outside valid range of 0 .. nz - 1", GSL_ESANITY); h->bin[i*ny*nz + j*nz + k] += weight; return GSL_SUCCESS; } double mygsl_histogram3d_get(const mygsl_histogram3d * h, const size_t i, const size_t j, const size_t k) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; if (i >= nx) GSL_ERROR_VAL ("index i lies outside valid range of 0 .. nx - 1", GSL_EDOM, 0); if (j >= ny) GSL_ERROR_VAL ("index j lies outside valid range of 0 .. ny - 1", GSL_EDOM, 0); if (k >= nz) GSL_ERROR_VAL ("index k lies outside valid range of 0 .. nz - 1", GSL_EDOM, 0); return h->bin[i*ny*nz + j*nz + k]; } int mygsl_histogram3d_get_xrange(const mygsl_histogram3d * h, const size_t i, double *xlower, double *xupper) { const size_t nx = h->nx; if (i >= nx) GSL_ERROR ("index i lies outside valid range of 0 .. nx - 1", GSL_EDOM); *xlower = h->xrange[i]; *xupper = h->xrange[i + 1]; return GSL_SUCCESS; } int mygsl_histogram3d_get_yrange(const mygsl_histogram3d * h, const size_t j, double *ylower, double *yupper) { const size_t ny = h->ny; if (j >= ny) GSL_ERROR ("index j lies outside valid range of 0 .. ny - 1", GSL_EDOM); *ylower = h->yrange[j]; *yupper = h->yrange[j + 1]; return GSL_SUCCESS; } int mygsl_histogram3d_get_zrange(const mygsl_histogram3d * h, const size_t k, double *zlower, double *zupper) { const size_t nz = h->nz; if (k >= nz) GSL_ERROR ("index k lies outside valid range of 0 .. nz - 1", GSL_EDOM); *zlower = h->zrange[k]; *zupper = h->zrange[k + 1]; return GSL_SUCCESS; } int mygsl_histogram3d_find (const mygsl_histogram3d * h, const double x, const double y, const double z, size_t * i, size_t * j, size_t *k) { int status = mygsl_find(h->nx, h->xrange, x, i); if (status) GSL_ERROR ("x not found in range of h", GSL_EDOM); status = mygsl_find (h->ny, h->yrange, y, j); if (status) GSL_ERROR ("y not found in range of h", GSL_EDOM); status = mygsl_find (h->nz, h->zrange, z, k); if (status) GSL_ERROR ("z not found in range of h", GSL_EDOM); return GSL_SUCCESS; } gsl_histogram2d* mygsl_histogram3d_xyproject(const mygsl_histogram3d * h3, size_t kstart, size_t kend) { gsl_histogram2d *h2; double count; size_t i, j, k; h2 = gsl_histogram2d_calloc(h3->nx, h3->ny); gsl_histogram2d_set_ranges(h2, h3->xrange, h3->nx+1, h3->yrange, h3->ny+1); for (i = 0; i < h3->nx; i++) { for (j = 0; j < h3->ny; j++) { count = 0; for (k = kstart; k <= kend; k++) { if (k >= h3->nz) break; count += mygsl_histogram3d_get(h3, i, j, k); } h2->bin[i*h2->ny + j] = count; } } return h2; } gsl_histogram2d* mygsl_histogram3d_xzproject(const mygsl_histogram3d * h3, size_t jstart, size_t jend) { gsl_histogram2d *h2; double count; size_t i, j, k; h2 = gsl_histogram2d_calloc(h3->nx, h3->nz); gsl_histogram2d_set_ranges(h2, h3->xrange, h3->nx+1, h3->zrange, h3->nz+1); for (i = 0; i < h3->nx; i++) { for (k = 0; k < h3->nz; k++) { count = 0; for (j = jstart; j <= jend; j++) { if (j >= h3->ny) break; count += mygsl_histogram3d_get(h3, i, j, k); } h2->bin[i*h2->ny + k] = count; } } return h2; } gsl_histogram2d* mygsl_histogram3d_yzproject(const mygsl_histogram3d * h3, size_t istart, size_t iend) { gsl_histogram2d *h2; double count; size_t i, j, k; h2 = gsl_histogram2d_calloc(h3->ny, h3->nz); gsl_histogram2d_set_ranges(h2, h3->yrange, h3->ny+1, h3->zrange, h3->nz+1); for (j = 0; j < h3->ny; j++) { for (k = 0; k < h3->nz; k++) { count = 0; for (i = istart; i <= iend; i++) { if (i >= h3->nx) break; count += mygsl_histogram3d_get(h3, i, j, k); } h2->bin[j*h2->ny + k] = count; } } return h2; } int mygsl_histogram3d_scale(mygsl_histogram3d * h, double scale) { size_t i, n; n = h->nx*h->ny*h->nz; for (i = 0; i < n; i++) h->bin[i] *= scale; return GSL_SUCCESS; } int mygsl_histogram3d_shift(mygsl_histogram3d * h, double shift) { size_t i, n; n = h->nx*h->ny*h->nz; for (i = 0; i < n; i++) h->bin[i] += shift; return GSL_SUCCESS; } double mygsl_histogram3d_xmax(const mygsl_histogram3d * h) { const int nx = h->nx; return h->xrange[nx]; } double mygsl_histogram3d_xmin(const mygsl_histogram3d * h) { return h->xrange[0]; } double mygsl_histogram3d_ymax(const mygsl_histogram3d * h) { const int ny = h->ny; return h->yrange[ny]; } double mygsl_histogram3d_ymin(const mygsl_histogram3d * h) { return h->yrange[0]; } double mygsl_histogram3d_zmax(const mygsl_histogram3d * h) { const int nz = h->nz; return h->zrange[nz]; } double mygsl_histogram3d_zmin(const mygsl_histogram3d * h) { return h->zrange[0]; } double mygsl_histogram3d_max_val(const mygsl_histogram3d * h) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t i; double max = h->bin[0]; for (i = 0; i < nx*ny*nz; i++) { if (h->bin[i] > max) max = h->bin[i]; } return max; } void mygsl_histogram3d_max_bin(const mygsl_histogram3d * h, size_t *imax_out, size_t *jmax_out, size_t *kmax_out) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t imax = 0, jmax = 0, kmax = 0, i, j, k; double max = h->bin[0], x; for (i = 0; i < nx; i++) { for (j = 0; j < ny; j++) { for (k = 0; k < nz; k++) { x = h->bin[i * ny*nz + j*nz + k]; if (x > max) { max = x; imax = i; jmax = j; kmax = k; } } } } *imax_out = imax; *jmax_out = jmax; *kmax_out = kmax; } double mygsl_histogram3d_min_val(const mygsl_histogram3d * h) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t i; double min = h->bin[0]; for (i = 0; i < nx*ny*nz; i++) { if (h->bin[i] < min) min = h->bin[i]; } return min; } void mygsl_histogram3d_min_bin(const mygsl_histogram3d * h, size_t *imin_out, size_t *jmin_out, size_t *kmin_out) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t imin = 0, jmin = 0, kmin = 0, i, j, k; double min = h->bin[0], x; for (i = 0; i < nx; i++) { for (j = 0; j < ny; j++) { for (k = 0; k < nz; k++) { x = h->bin[i * ny*nz + j*nz + k]; if (x < min) { min = x; imin = i; jmin = j; kmin = k; } } } } *imin_out = imin; *jmin_out = jmin; *kmin_out = kmin; } double mygsl_histogram3d_sum (const mygsl_histogram3d * h) { const size_t n = h->nx*h->ny*h->nz; double sum = 0; size_t i = 0; while (i < n) sum += h->bin[i++]; return sum; } double mygsl_histogram3d_xmean (const mygsl_histogram3d * h) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t i, j, k; double wmean = 0; double W = 0; for (i = 0; i < nx; i++) { double xi = (h->xrange[i + 1] + h->xrange[i]) / 2.0; double wi = 0; for (j = 0; j < ny; j++) { for (k = 0; k < nz; k++) { double wijk = h->bin[i * ny *nz + j * nz + k]; if (wijk > 0) wi += wijk; } } if (wi > 0) { W += wi; wmean += (xi - wmean) * (wi / W); } } return wmean; } double mygsl_histogram3d_ymean (const mygsl_histogram3d * h) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t i, j, k; double wmean = 0; double W = 0; for (j = 0; j < ny; j++) { double yj = (h->yrange[j + 1] + h->yrange[j]) / 2.0; double wj = 0; for (i = 0; i < nx; i++) { for (k = 0; k < nz; k++) { double wijk = h->bin[i * ny *nz + j * nz + k]; if (wijk > 0) wj += wijk; } } if (wj > 0) { W += wj; wmean += (yj - wmean) * (wj / W); } } return wmean; } double mygsl_histogram3d_zmean (const mygsl_histogram3d * h) { const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; size_t i, j, k; double wmean = 0; double W = 0; for (k = 0; k < nz; k++) { double zk = (h->zrange[k + 1] + h->zrange[k]) / 2.0; double wk = 0; for (i = 0; i < nx; i++) { for (j = 0; j < ny; j++) { double wijk = h->bin[i * ny *nz + j * nz + k]; if (wijk > 0) wk += wijk; } } if (wk > 0) { W += wk; wmean += (zk - wmean) * (wk / W); } } return wmean; } double mygsl_histogram3d_xsigma(const mygsl_histogram3d * h) { const double xmean = mygsl_histogram3d_xmean(h); const size_t nx = h->nx, ny = h->ny, nz = h->nz; size_t i, j, k; double wvariance = 0, W = 0; for (i = 0; i < nx; i++) { double xi = (h->xrange[i + 1] + h->xrange[i]) / 2 - xmean; double wi = 0; for (j = 0; j < ny; j++) { for (k = 0; k < nz; k++) { double wijk = h->bin[i * ny*nz + j*nz + k]; if (wijk > 0) wi += wijk; } } if (wi > 0) { W += wi; wvariance += ((xi * xi) - wvariance) * (wi / W); } } return sqrt(wvariance); } double mygsl_histogram3d_ysigma(const mygsl_histogram3d * h) { const double ymean = mygsl_histogram3d_ymean(h); const size_t nx = h->nx, ny = h->ny, nz = h->nz; size_t i, j, k; double wvariance = 0, W = 0; for (j = 0; j < ny; j++) { double yj = (h->yrange[j + 1] + h->yrange[j]) / 2 - ymean; double wj = 0; for (i = 0; i < nx; i++) { for (k = 0; k < nz; k++) { double wjjk = h->bin[i * ny*nz + j*nz + k]; if (wjjk > 0) wj += wjjk; } } if (wj > 0) { W += wj; wvariance += ((yj * yj) - wvariance) * (wj / W); } } return sqrt(wvariance); } double mygsl_histogram3d_zsigma(const mygsl_histogram3d * h) { const double zmean = mygsl_histogram3d_zmean(h); const size_t nx = h->nx, ny = h->ny, nz = h->nz; size_t i, j, k; double wvariance = 0, W = 0; for (k = 0; k < nz; k++) { double zk = (h->zrange[k + 1] + h->zrange[k]) / 2 - zmean; double wk = 0; for (i = 0; i < nx; i++) { for (j = 0; j < ny; j++) { double wijk = h->bin[i * ny*nz + j*nz + k]; if (wijk > 0) wk += wijk; } } if (wk > 0) { W += wk; wvariance += ((zk * zk) - wvariance) * (wk / W); } } return sqrt(wvariance); } void mygsl_histogram3d_reset(mygsl_histogram3d * h) { size_t i; const size_t nx = h->nx; const size_t ny = h->ny; const size_t nz = h->nz; for (i = 0; i < nx * ny * nz; i++) { h->bin[i] = 0; } } int mygsl_histogram3d_equal_bins_p(const mygsl_histogram3d * h1, const mygsl_histogram3d * h2) { size_t i; if ((h1->nx != h2->nx) || (h1->ny != h2->ny) || (h1->nz != h2->nz)) return 0; for (i = 0; i <= h1->nx; i++) if (h1->xrange[i] != h2->xrange[i]) return 0; for (i = 0; i <= h1->ny; i++) if (h1->yrange[i] != h2->yrange[i]) return 0; for (i = 0; i <= h1->nz; i++) if (h1->zrange[i] != h2->zrange[i]) return 0; return 1; } int mygsl_histogram3d_add(mygsl_histogram3d * h1, const mygsl_histogram3d * h2) { size_t i; if (!mygsl_histogram3d_equal_bins_p(h1, h2)) GSL_ERROR ("histograms have different binning", GSL_EINVAL); for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++) h1->bin[i] += h2->bin[i]; return GSL_SUCCESS; } int mygsl_histogram3d_sub(mygsl_histogram3d * h1, const mygsl_histogram3d * h2) { size_t i; if (!mygsl_histogram3d_equal_bins_p(h1, h2)) GSL_ERROR ("histograms have different binning", GSL_EINVAL); for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++) h1->bin[i] -= h2->bin[i]; return GSL_SUCCESS; } int mygsl_histogram3d_mul(mygsl_histogram3d * h1, const mygsl_histogram3d * h2) { size_t i; if (!mygsl_histogram3d_equal_bins_p(h1, h2)) GSL_ERROR ("histograms have different binning", GSL_EINVAL); for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++) h1->bin[i] *= h2->bin[i]; return GSL_SUCCESS; } int mygsl_histogram3d_div(mygsl_histogram3d * h1, const mygsl_histogram3d * h2) { size_t i; if (!mygsl_histogram3d_equal_bins_p(h1, h2)) GSL_ERROR ("histograms have different binning", GSL_EINVAL); for (i = 0; i < (h1->nx) * (h1->ny) * (h1->nz); i++) h1->bin[i] /= h2->bin[i]; return GSL_SUCCESS; } gsl-1.15.3/ext/qrng.c0000644000175000017500000001144012220252463013655 0ustar boutilboutil/* qrng.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_rng.h" #include "rb_gsl_array.h" #include #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H #include #endif enum rb_gsl_qrng_generator { GSL_QRNG_NIEDERREITER_2, GSL_QRNG_SOBOL, GSL_QRNG_HALTON, GSL_QRNG_REVERSEHALTON, #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H GSL_QRNG_HDSOBOL, #endif }; static const gsl_qrng_type* get_gsl_qrng_type(VALUE t); static const gsl_qrng_type* get_gsl_qrng_type(VALUE t) { const gsl_qrng_type *T; char name[32]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (strstr(name, "niederreiter_2")) return T = gsl_qrng_niederreiter_2; #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H else if (strstr(name, "hdsobol")) return T = qrngextra_hdsobol; #endif else if (strstr(name, "sobol")) return T = gsl_qrng_sobol; #ifdef GSL_1_11_LATER else if (strstr(name, "reversehalton")) return T = gsl_qrng_reversehalton; else if (strstr(name, "halton")) return T = gsl_qrng_halton; #endif else rb_raise(rb_eArgError, "unknown type"); break; case T_FIXNUM: switch (FIX2INT(t)) { case GSL_QRNG_NIEDERREITER_2: T = gsl_qrng_niederreiter_2; break; case GSL_QRNG_SOBOL: T = gsl_qrng_sobol; break; #ifdef GSL_1_11_LATER case GSL_QRNG_HALTON: T = gsl_qrng_halton; break; case GSL_QRNG_REVERSEHALTON: T = gsl_qrng_reversehalton; break; #endif #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H case GSL_QRNG_HDSOBOL: T = qrngextra_hdsobol; break; #endif default: rb_raise(rb_eArgError, "unknown type"); } break; default: rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)", rb_class2name(CLASS_OF(t))); } return T; } static VALUE rb_gsl_qrng_new(VALUE klass, VALUE t, VALUE dd) { unsigned int d; gsl_qrng *q; const gsl_qrng_type *T; d = NUM2UINT(dd); T = get_gsl_qrng_type(t); q = gsl_qrng_alloc(T, d); return Data_Wrap_Struct(klass, 0, gsl_qrng_free, q); } #ifdef GSL_1_2_LATER static VALUE rb_gsl_qrng_init(VALUE obj) { gsl_qrng *q = NULL; Data_Get_Struct(obj, gsl_qrng, q); gsl_qrng_init(q); return obj; } #endif static VALUE rb_gsl_qrng_name(VALUE obj) { gsl_qrng *q = NULL; Data_Get_Struct(obj, gsl_qrng, q); return rb_str_new2(gsl_qrng_name(q)); } static VALUE rb_gsl_qrng_size(VALUE obj) { gsl_qrng *q = NULL; Data_Get_Struct(obj, gsl_qrng, q); return INT2FIX(gsl_qrng_size(q)); } static VALUE rb_gsl_qrng_clone(VALUE obj) { gsl_qrng *q = NULL, *q2 = NULL; Data_Get_Struct(obj, gsl_qrng, q); q2 = gsl_qrng_clone(q); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_qrng_free, q2); } /* singleton */ static VALUE rb_gsl_qrng_memcpy(VALUE obj, VALUE dest, VALUE src) { gsl_qrng *q = NULL, *q2 = NULL; Data_Get_Struct(dest, gsl_qrng, q); Data_Get_Struct(src, gsl_qrng, q2); gsl_qrng_memcpy(q, q2); return dest; } static VALUE rb_gsl_qrng_get(int argc, VALUE *argv, VALUE obj) { gsl_qrng *q = NULL; gsl_vector *v; Data_Get_Struct(obj, gsl_qrng, q); if (argc == 0) { v = gsl_vector_alloc(q->dimension); gsl_qrng_get(q, v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } else { if (!rb_obj_is_kind_of(argv[0], cgsl_vector)) { rb_raise(rb_eArgError, "wrong type argument (GSL_Vector required)"); } Data_Get_Struct(argv[0], gsl_vector, v); return INT2FIX(gsl_qrng_get(q, v->data)); } } void Init_gsl_qrng(VALUE module) { VALUE cgsl_qrng; cgsl_qrng = rb_define_class_under(module, "QRng", cGSL_Object); rb_define_singleton_method(cgsl_qrng, "new", rb_gsl_qrng_new, 2); rb_define_singleton_method(cgsl_qrng, "alloc", rb_gsl_qrng_new, 2); #ifdef GSL_1_2_LATER rb_define_method(cgsl_qrng, "init", rb_gsl_qrng_init, 0); #endif rb_define_method(cgsl_qrng, "name", rb_gsl_qrng_name, 0); rb_define_method(cgsl_qrng, "size", rb_gsl_qrng_size, 0); rb_define_method(cgsl_qrng, "clone", rb_gsl_qrng_clone, 0); rb_define_alias(cgsl_qrng, "duplicate", "clone"); rb_define_singleton_method(cgsl_qrng, "memcpy", rb_gsl_qrng_memcpy, 2); rb_define_method(cgsl_qrng, "get", rb_gsl_qrng_get, -1); rb_define_const(cgsl_qrng, "NIEDERREITER_2", INT2FIX(GSL_QRNG_NIEDERREITER_2)); rb_define_const(cgsl_qrng, "SOBOL", INT2FIX(GSL_QRNG_SOBOL)); #ifdef GSL_1_11_LATER rb_define_const(cgsl_qrng, "HALTON", INT2FIX(GSL_QRNG_HALTON)); rb_define_const(cgsl_qrng, "REVERSEHALTON", INT2FIX(GSL_QRNG_REVERSEHALTON)); #endif #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H rb_define_const(cgsl_qrng, "HDSOBOL", INT2FIX(GSL_QRNG_HDSOBOL)); #endif } gsl-1.15.3/ext/cqp.c0000644000175000017500000001706712220252463013504 0ustar boutilboutil#ifdef HAVE_GSL_GSL_CQP_H #include "rb_gsl.h" #include "gsl/gsl_cqp.h" static const gsl_cqpminimizer_type* type_by_string(VALUE t); static const gsl_cqpminimizer_type* get_type(VALUE t) { switch (TYPE(t)) { case T_STRING: return type_by_string(t); break; default: rb_raise(rb_eTypeError, "Wrong argument type %s.", rb_class2name(CLASS_OF(t))); } } static const gsl_cqpminimizer_type* type_by_string(VALUE t) { char *name; name = STR2CSTR(t); if (strcmp(name, "mg_pdip") == 0) { return gsl_cqpminimizer_mg_pdip; } else { rb_raise(rb_eRuntimeError, "Unknown minimizer type %s.", name); } return NULL; /* never reach here */ } static VALUE rb_cqpminimizer_alloc(VALUE klass, VALUE t, VALUE n, VALUE me, VALUE mi) { gsl_cqpminimizer *m; m = gsl_cqpminimizer_alloc(get_type(t), (size_t) FIX2INT(n), (size_t) FIX2INT(me), (size_t) FIX2INT(mi)); return Data_Wrap_Struct(klass, 0, gsl_cqpminimizer_free, m); } static VALUE rb_cqpminimizer_set(VALUE obj, VALUE data) { gsl_cqpminimizer *m; gsl_cqp_data *d; Data_Get_Struct(obj, gsl_cqpminimizer, m); Data_Get_Struct(data, gsl_cqp_data, d); gsl_cqpminimizer_set(m, d); return Qtrue; } static VALUE rb_cqpminimizer_name(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return rb_str_new2(gsl_cqpminimizer_name(m)); } static VALUE rb_cqpminimizer_iterate(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return INT2FIX(gsl_cqpminimizer_iterate(m)); } static VALUE rb_cqpminimizer_x(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, gsl_cqpminimizer_x(m)); } static VALUE rb_cqpminimizer_lm_eq(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, gsl_cqpminimizer_lm_eq(m)); } static VALUE rb_cqpminimizer_lm_ineq(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, gsl_cqpminimizer_lm_ineq(m)); } static VALUE rb_cqpminimizer_f(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return rb_float_new(gsl_cqpminimizer_f(m)); } static VALUE rb_cqpminimizer_gap(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return rb_float_new(gsl_cqpminimizer_gap(m)); } static VALUE rb_cqpminimizer_residuals_norm(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return rb_float_new(gsl_cqpminimizer_residuals_norm(m)); } /* static VALUE rb_cqpminimizer_minimum(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return rb_float_new(gsl_cqpminimizer_minimum(m)); } */ static VALUE rb_cqpminimizer_test_convergence(VALUE obj, VALUE g, VALUE r) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return INT2FIX(gsl_cqpminimizer_test_convergence(m, NUM2DBL(g), NUM2DBL(r))); } static VALUE rb_cqpminimizer_test_infeasibility(VALUE obj, VALUE e) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return INT2FIX(gsl_cqp_minimizer_test_infeasibility(m, NUM2DBL(e))); } static VALUE rb_cqp_data_alloc(VALUE klass) { gsl_cqp_data *d; d = (gsl_cqp_data*) malloc(sizeof(gsl_cqp_data)); return Data_Wrap_Struct(klass, 0, free, d); } static VALUE rb_cqp_data_Q(VALUE obj) { gsl_cqp_data *d; Data_Get_Struct(obj, gsl_cqp_data, d); return Data_Wrap_Struct(cgsl_matrix_view, 0, NULL, d->Q); } static VALUE rb_cqp_data_q(VALUE obj) { gsl_cqp_data *d; Data_Get_Struct(obj, gsl_cqp_data, d); return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, d->q); } static VALUE rb_cqp_data_A(VALUE obj) { gsl_cqp_data *d; Data_Get_Struct(obj, gsl_cqp_data, d); return Data_Wrap_Struct(cgsl_matrix_view, 0, NULL, d->A); } static VALUE rb_cqp_data_b(VALUE obj) { gsl_cqp_data *d; Data_Get_Struct(obj, gsl_cqp_data, d); return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, d->b); } static VALUE rb_cqp_data_C(VALUE obj) { gsl_cqp_data *d; Data_Get_Struct(obj, gsl_cqp_data, d); return Data_Wrap_Struct(cgsl_matrix_view, 0, NULL, d->C); } static VALUE rb_cqp_data_d(VALUE obj) { gsl_cqp_data *d; Data_Get_Struct(obj, gsl_cqp_data, d); return Data_Wrap_Struct(cgsl_vector_view, 0, NULL, d->d); } static VALUE rb_cqp_data_set_Q(VALUE obj, VALUE mm) { gsl_cqp_data *d; gsl_matrix *m; Data_Get_Struct(obj, gsl_cqp_data, d); CHECK_MATRIX(mm); Data_Get_Struct(mm, gsl_matrix, m); d->Q = m; return Qtrue; } static VALUE rb_cqp_data_set_q(VALUE obj, VALUE vv) { gsl_cqp_data *d; gsl_vector *v; Data_Get_Struct(obj, gsl_cqp_data, d); CHECK_VECTOR(vv); Data_Get_Struct(vv, gsl_vector, v); d->q = v; return Qtrue; } static VALUE rb_cqp_data_set_A(VALUE obj, VALUE mm) { gsl_cqp_data *d; gsl_matrix *m; Data_Get_Struct(obj, gsl_cqp_data, d); CHECK_MATRIX(mm); Data_Get_Struct(mm, gsl_matrix, m); d->A = m; return Qtrue; } static VALUE rb_cqp_data_set_b(VALUE obj, VALUE vv) { gsl_cqp_data *d; gsl_vector *v; Data_Get_Struct(obj, gsl_cqp_data, d); CHECK_VECTOR(vv); Data_Get_Struct(vv, gsl_vector, v); d->b = v; return Qtrue; } static VALUE rb_cqp_data_set_C(VALUE obj, VALUE mm) { gsl_cqp_data *d; gsl_matrix *m; Data_Get_Struct(obj, gsl_cqp_data, d); CHECK_MATRIX(mm); Data_Get_Struct(mm, gsl_matrix, m); d->C = m; return Qtrue; } static VALUE rb_cqp_data_set_d(VALUE obj, VALUE vv) { gsl_cqp_data *d; gsl_vector *v; Data_Get_Struct(obj, gsl_cqp_data, d); CHECK_VECTOR(vv); Data_Get_Struct(vv, gsl_vector, v); d->d = v; return Qtrue; } void Init_cqp(VALUE module) { VALUE mCQP, cMinimizer, cData; mCQP = rb_define_module_under(module, "CQP"); cMinimizer = rb_define_class_under(mCQP, "Minimizer", cGSL_Object); cData = rb_define_class_under(mCQP, "Data", cGSL_Object); rb_define_singleton_method(cMinimizer, "alloc", rb_cqpminimizer_alloc, 4); rb_define_method(cMinimizer, "set", rb_cqpminimizer_set, 1); rb_define_method(cMinimizer, "name", rb_cqpminimizer_name, 0); rb_define_method(cMinimizer, "iterate", rb_cqpminimizer_iterate, 0); rb_define_method(cMinimizer, "x", rb_cqpminimizer_x, 0); rb_define_method(cMinimizer, "lm_eq", rb_cqpminimizer_lm_eq, 0); rb_define_method(cMinimizer, "lm_ineq", rb_cqpminimizer_lm_ineq, 0); rb_define_method(cMinimizer, "f", rb_cqpminimizer_f, 0); rb_define_method(cMinimizer, "gap", rb_cqpminimizer_gap, 0); rb_define_method(cMinimizer, "residuals_norm", rb_cqpminimizer_residuals_norm, 0); /* rb_define_method(cMinimizer, "minimum", rb_cqpminimizer_minimum, 0); */ rb_define_method(cMinimizer, "test_convergence", rb_cqpminimizer_test_convergence, 2); rb_define_method(cMinimizer, "test_infeasibility", rb_cqpminimizer_test_infeasibility, 1); /*****/ rb_define_singleton_method(cData, "alloc", rb_cqp_data_alloc, 0); rb_define_method(cData, "Q", rb_cqp_data_Q, 0); rb_define_method(cData, "q", rb_cqp_data_q, 0); rb_define_method(cData, "A", rb_cqp_data_A, 0); rb_define_method(cData, "b", rb_cqp_data_b, 0); rb_define_method(cData, "C", rb_cqp_data_C, 0); rb_define_method(cData, "d", rb_cqp_data_d, 0); rb_define_method(cData, "set_Q", rb_cqp_data_set_Q, 1); rb_define_method(cData, "set_q", rb_cqp_data_set_q, 1); rb_define_method(cData, "set_A", rb_cqp_data_set_A, 1); rb_define_method(cData, "set_b", rb_cqp_data_set_b, 1); rb_define_method(cData, "set_C", rb_cqp_data_set_C, 1); rb_define_method(cData, "set_d", rb_cqp_data_set_d, 1); rb_define_alias(cData, "Q=", "set_Q"); rb_define_alias(cData, "q=", "set_q"); rb_define_alias(cData, "A=", "set_A"); rb_define_alias(cData, "b=", "set_b"); rb_define_alias(cData, "C=", "set_C"); rb_define_alias(cData, "d=", "set_d"); } #endif gsl-1.15.3/ext/math.c0000644000175000017500000005171212220252463013645 0ustar boutilboutil/* math.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_config.h" #include "rb_gsl_math.h" #include "rb_gsl_complex.h" #ifdef HAVE_NARRAY_H #include "narray.h" #endif static void rb_gsl_define_const(VALUE module); static void rb_gsl_define_const(VALUE module) { rb_define_const(module, "M_E", rb_float_new(M_E)); rb_define_const(module, "M_LOG2E", rb_float_new(M_LOG2E)); rb_define_const(module, "M_LOG10E", rb_float_new(M_LOG10E)); rb_define_const(module, "M_SQRT2", rb_float_new(M_SQRT2)); rb_define_const(module, "M_SQRT1_2", rb_float_new(M_SQRT1_2)); rb_define_const(module, "M_SQRT3", rb_float_new(M_SQRT3)); rb_define_const(module, "M_PI", rb_float_new(M_PI)); rb_define_const(module, "M_PI_2", rb_float_new(M_PI_2)); rb_define_const(module, "M_PI_4", rb_float_new(M_PI_4)); rb_define_const(module, "M_SQRTPI", rb_float_new(M_SQRTPI)); rb_define_const(module, "M_2_SQRTPI", rb_float_new(M_2_SQRTPI)); rb_define_const(module, "M_1_PI", rb_float_new(M_1_PI)); rb_define_const(module, "M_2_PI", rb_float_new(M_2_PI)); rb_define_const(module, "M_LN10", rb_float_new(M_LN10)); rb_define_const(module, "M_LN2", rb_float_new(M_LN2)); rb_define_const(module, "M_LNPI", rb_float_new(M_LNPI)); rb_define_const(module, "M_EULER", rb_float_new(M_EULER)); rb_define_const(module, "POSINF", rb_float_new(GSL_POSINF)); rb_define_const(module, "NEGINF", rb_float_new(GSL_NEGINF)); rb_define_const(module, "NAN", rb_float_new(GSL_NAN)); } static VALUE rb_GSL_POSINF(VALUE obj) { return rb_float_new(GSL_POSINF); } static VALUE rb_GSL_NEGINF(VALUE obj) { return rb_float_new(GSL_NEGINF); } static VALUE rb_GSL_NAN(VALUE obj) { return rb_float_new(GSL_NAN); } static VALUE rb_gsl_isnan(VALUE obj, VALUE x) { Need_Float(x); return INT2FIX(gsl_isnan(NUM2DBL(x))); } static VALUE rb_gsl_isnan2(VALUE obj, VALUE x) { Need_Float(x); if (gsl_isnan(NUM2DBL(x))) return Qtrue; else return Qfalse; } static VALUE rb_gsl_isinf(VALUE obj, VALUE x) { Need_Float(x); return INT2FIX(gsl_isinf(NUM2DBL(x))); } static VALUE rb_gsl_isinf2(VALUE obj, VALUE x) { // Need_Float(x); if (gsl_isinf(NUM2DBL(x))) return Qtrue; else return Qfalse; } static VALUE rb_gsl_finite(VALUE obj, VALUE x) { Need_Float(x); return INT2FIX(gsl_finite(NUM2DBL(x))); } static VALUE rb_gsl_finite2(VALUE obj, VALUE x) { Need_Float(x); if (gsl_finite(NUM2DBL(x))) return Qtrue; else return Qfalse; } /*****/ static VALUE rb_gsl_math_eval(double (*func)(const double), VALUE xx); VALUE rb_gsl_math_complex_eval(gsl_complex (*func)(gsl_complex), VALUE obj) { gsl_complex *z, *znew; gsl_vector_complex *v, *vnew; gsl_matrix_complex *m, *mnew; size_t i, j; if (COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_complex, z); znew = xmalloc(sizeof(gsl_complex)); *znew = (*func)(*z); return Data_Wrap_Struct(cgsl_complex, 0, free, znew); } else if (VECTOR_COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); for (i = 0; i < v->size; i++) { z = GSL_COMPLEX_AT(v, i); gsl_vector_complex_set(vnew, i, (*func)(*z)); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } else if (MATRIX_COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_complex_set(mnew, i, j, (*func)(gsl_matrix_complex_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type %s " " (GSL::Complex or GSL::Vector::Complex expected)", rb_class2name(CLASS_OF(obj))); } } static VALUE rb_gsl_math_eval(double (*func)(const double), VALUE xx) { VALUE x, ary; size_t i, size; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*func)(NUM2DBL(xx))); break; case T_ARRAY: size = RARRAY_LEN(xx); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { x = rb_ary_entry(xx, i); Need_Float(x); // rb_ary_store(ary, i, rb_float_new((*func)(RFLOAT(x)->value))); rb_ary_store(ary, i, rb_float_new((*func)(NUM2DBL(x)))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; size = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < size; i++) ptr2[i] = (*func)(ptr1[i]); return ary; } #endif if (VECTOR_P(xx)) { return vector_eval_create(xx, func); } else if (MATRIX_P(xx)) { return matrix_eval_create(xx, func); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; } static VALUE rb_gsl_math_eval2(double (*func)(const double, const double), VALUE xx, VALUE yy); static VALUE rb_gsl_math_eval2(double (*func)(const double, const double), VALUE xx, VALUE yy) { VALUE x, y, ary; size_t i, j, size; gsl_vector *v = NULL, *v2 = NULL, *vnew = NULL; gsl_matrix *m = NULL, *m2 = NULL, *mnew = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *nax, *nay; double *ptr1, *ptr2, *ptr3; #endif if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: Need_Float(yy); return rb_float_new((*func)(NUM2DBL(xx), NUM2DBL(yy))); break; case T_ARRAY: Check_Type(yy, T_ARRAY); size = RARRAY_LEN(xx); // if (size != RARRAY(yy)->len) rb_raise(rb_eRuntimeError, "array sizes are different."); if (size != RARRAY_LEN(yy)) rb_raise(rb_eRuntimeError, "array sizes are different."); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { x = rb_ary_entry(xx, i); y = rb_ary_entry(yy, i); Need_Float(x); Need_Float(y); // rb_ary_store(ary, i, rb_float_new((*func)(RFLOAT(x)->value, RFLOAT(y)->value))); rb_ary_store(ary, i, rb_float_new((*func)(NUM2DBL(x), NUM2DBL(y)))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, nax); GetNArray(yy, nay); ptr1 = (double*) nax->ptr; ptr2 = (double*) nay->ptr; size = nax->total; ary = na_make_object(NA_DFLOAT, nax->rank, nax->shape, CLASS_OF(xx)); ptr3 = NA_PTR_TYPE(ary, double*); for (i = 0; i < size; i++) ptr3[i] = (*func)(ptr1[i], ptr2[i]); return ary; } #endif if (VECTOR_P(xx)) { CHECK_VECTOR(yy); Data_Get_Struct(xx, gsl_vector, v); Data_Get_Struct(yy, gsl_vector, v2); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, (*func)(gsl_vector_get(v, i), gsl_vector_get(v2, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { CHECK_MATRIX(yy); Data_Get_Struct(xx, gsl_matrix, m); Data_Get_Struct(yy, gsl_matrix, m2); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (*func)(gsl_matrix_get(m, i, j), gsl_matrix_get(m2, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type %s " "(Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; } static VALUE rb_gsl_sqrt(VALUE obj, VALUE x) { return rb_gsl_math_eval(sqrt, x); } static VALUE rb_gsl_log1p(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_log1p, x); } static VALUE rb_gsl_expm1(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_expm1, x); } static VALUE rb_gsl_hypot(VALUE obj, VALUE x, VALUE y) { return rb_gsl_math_eval2(gsl_hypot, x, y); } #ifdef GSL_1_10_LATER static VALUE rb_gsl_hypot3(VALUE obj, VALUE x, VALUE y, VALUE z) { Need_Float(x); Need_Float(y); Need_Float(z); return rb_float_new(gsl_hypot3(NUM2DBL(x), NUM2DBL(y), NUM2DBL(z))); } #endif static VALUE rb_gsl_acosh(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) return rb_gsl_math_complex_eval(gsl_complex_arccosh, x); return rb_gsl_math_eval(gsl_acosh, x); } static VALUE rb_gsl_asinh(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) return rb_gsl_math_complex_eval(gsl_complex_arcsinh, x); return rb_gsl_math_eval(gsl_asinh, x); } static VALUE rb_gsl_atanh(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) return rb_gsl_math_complex_eval(gsl_complex_arctanh, x); return rb_gsl_math_eval(gsl_atanh, x); } #include /* xx: Numeric, Complex, Vector, Matrix nn: Numeric, Complex */ VALUE rb_gsl_pow(VALUE obj, VALUE xx, VALUE nn) { VALUE x, ary, argv[2]; size_t i, j, size; double n; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(pow(NUM2DBL(xx), NUM2DBL(nn))); break; case T_ARRAY: n = NUM2DBL(nn); size = RARRAY_LEN(xx); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { x = rb_ary_entry(xx, i); Need_Float(x); rb_ary_store(ary, i, rb_float_new(pow(NUM2DBL(x), n))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { n = NUM2DBL(nn); GetNArray(xx, na); ptr1 = (double*) na->ptr; size = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < size; i++) ptr2[i] = pow(ptr1[i], n); return ary; } #endif if (VECTOR_P(xx)) { n = NUM2DBL(nn); Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, pow(gsl_vector_get(v, i), n)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } if (MATRIX_P(xx)) { n = NUM2DBL(nn); Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, pow(gsl_matrix_get(m, i, j), n)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } if (COMPLEX_P(xx) || VECTOR_COMPLEX_P(xx) || MATRIX_COMPLEX_P(xx)) { argv[0] = xx; argv[1] = nn; return rb_gsl_complex_pow(2, argv, obj); } rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx))); break; } /* never reach here */ return Qnil; } static VALUE rb_gsl_pow_int(VALUE obj, VALUE xx, VALUE nn) { VALUE x, ary, argv[2]; size_t i, j, size; int n; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(gsl_pow_int(NUM2DBL(xx), FIX2INT(nn))); break; case T_ARRAY: CHECK_FIXNUM(nn); n = FIX2INT(nn); size = RARRAY_LEN(xx); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { x = rb_ary_entry(xx, i); Need_Float(x); // rb_ary_store(ary, i, rb_float_new(gsl_pow_int(RFLOAT(x)->value, n))); rb_ary_store(ary, i, rb_float_new(gsl_pow_int(NUM2DBL(x), n))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { CHECK_FIXNUM(nn); n = FIX2INT(nn); GetNArray(xx, na); ptr1 = (double*) na->ptr; size = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < size; i++) ptr2[i] = gsl_pow_int(ptr1[i], n); return ary; } #endif if (VECTOR_P(xx)) { CHECK_FIXNUM(nn); n = FIX2INT(nn); Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, gsl_pow_int(gsl_vector_get(v, i), n)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { CHECK_FIXNUM(nn); n = FIX2INT(nn); Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, gsl_pow_int(gsl_matrix_get(m, i, j), n)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else if (COMPLEX_P(xx) || VECTOR_COMPLEX_P(xx) || MATRIX_COMPLEX_P(xx)) { argv[0] = xx; argv[1] = nn; return rb_gsl_complex_pow_real(2, argv, obj); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx))); } break; } /* never reach here */ return Qnil; } static VALUE rb_gsl_pow_2(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_2, x); } static VALUE rb_gsl_pow_3(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_3, x); } static VALUE rb_gsl_pow_4(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_4, x); } static VALUE rb_gsl_pow_5(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_5, x); } static VALUE rb_gsl_pow_6(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_6, x); } static VALUE rb_gsl_pow_7(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_7, x); } static VALUE rb_gsl_pow_8(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_8, x); } static VALUE rb_gsl_pow_9(VALUE obj, VALUE x) { return rb_gsl_math_eval(gsl_pow_9, x); } /*****/ static VALUE rb_GSL_SIGN(VALUE obj, VALUE x) { return INT2FIX(GSL_SIGN(NUM2DBL(x))); } static VALUE rb_GSL_IS_ODD(VALUE obj, VALUE n) { CHECK_FIXNUM(n); return INT2FIX(GSL_IS_ODD(FIX2INT(n))); } static VALUE rb_GSL_IS_ODD2(VALUE obj, VALUE n) { CHECK_FIXNUM(n); if (GSL_IS_ODD(FIX2INT(n))) return Qtrue; else return Qfalse; } static VALUE rb_GSL_IS_EVEN(VALUE obj, VALUE n) { CHECK_FIXNUM(n); return INT2FIX(GSL_IS_EVEN(FIX2INT(n))); } static VALUE rb_GSL_IS_EVEN2(VALUE obj, VALUE n) { CHECK_FIXNUM(n); if (GSL_IS_EVEN(FIX2INT(n))) return Qtrue; else return Qfalse; } static VALUE rb_GSL_MAX(VALUE obj, VALUE aa, VALUE bb) { double a, b; double max; /* Need_Float(aa); Need_Float(bb);*/ a = NUM2DBL(aa); b = NUM2DBL(bb); max = GSL_MAX_DBL(a, b); if (gsl_fcmp(max, a, 1.0e-10) == 0) return aa; else return bb; } static VALUE rb_GSL_MIN(VALUE obj, VALUE aa, VALUE bb) { double a, b; double min; /* Need_Float(aa); Need_Float(bb);*/ a = NUM2DBL(aa); b = NUM2DBL(bb); min = GSL_MIN_DBL(a, b); if (gsl_fcmp(min, a, 1.0e-10) == 0) return aa; else return bb; } static VALUE rb_GSL_MAX_DBL(VALUE obj, VALUE aa, VALUE bb) { Need_Float(aa); Need_Float(bb); return rb_float_new(GSL_MAX_DBL(NUM2DBL(aa), NUM2DBL(bb))); } static VALUE rb_GSL_MIN_DBL(VALUE obj, VALUE aa, VALUE bb) { Need_Float(aa); Need_Float(bb); return rb_float_new(GSL_MAX_DBL(NUM2DBL(aa), NUM2DBL(bb))); } static VALUE rb_GSL_MAX_INT(VALUE obj, VALUE aa, VALUE bb) { if (TYPE(aa) != T_FIXNUM || TYPE(bb) != T_FIXNUM) return rb_GSL_MAX(obj, aa, bb); else return INT2FIX(GSL_MAX_INT(FIX2INT(aa), FIX2INT(bb))); } static VALUE rb_GSL_MIN_INT(VALUE obj, VALUE aa, VALUE bb) { if (TYPE(aa) != T_FIXNUM || TYPE(bb) != T_FIXNUM) return rb_GSL_MIN(obj, aa, bb); return INT2FIX(GSL_MIN_INT(FIX2INT(aa), FIX2INT(bb))); } #ifdef GSL_1_3_LATER static VALUE rb_gsl_ldexp(VALUE obj, VALUE x, VALUE e) { return rb_float_new(gsl_ldexp(NUM2DBL(x), FIX2INT(e))); } static VALUE rb_gsl_frexp(VALUE obj, VALUE x) { int e; double val; Need_Float(x); val = gsl_frexp(NUM2DBL(x), &e); return rb_ary_new3(2, rb_float_new(val), INT2FIX(e)); } #endif static VALUE rb_gsl_fcmp(int argc, VALUE *argv, VALUE obj) { double a, b, epsilon = 1e-10; switch (argc) { case 3: epsilon = NUM2DBL(argv[2]); /* no break, do next */ case 2: a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } return INT2FIX(gsl_fcmp(a, b, epsilon)); } static VALUE rb_gsl_equal(int argc, VALUE *argv, VALUE obj) { double a, b, epsilon = 1e-10; int retval; switch (argc) { case 3: epsilon = NUM2DBL(argv[2]); /* no break, do next */ case 2: a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } retval = gsl_fcmp(a, b, epsilon); if (retval == 0) return Qtrue; else return Qfalse; } void Init_gsl_math(VALUE module) { rb_gsl_define_const(module); rb_define_module_function(module, "posinf", rb_GSL_POSINF, 0); rb_define_module_function(module, "neginf", rb_GSL_NEGINF, 0); rb_define_module_function(module, "nan", rb_GSL_NAN, 0); rb_define_module_function(module, "isnan", rb_gsl_isnan, 1); rb_define_module_function(module, "isnan?", rb_gsl_isnan2, 1); rb_define_module_function(module, "isinf", rb_gsl_isinf, 1); rb_define_module_function(module, "isinf?", rb_gsl_isinf2, 1); rb_define_module_function(module, "finite", rb_gsl_finite, 1); rb_define_module_function(module, "finite?", rb_gsl_finite2, 1); rb_define_module_function(module, "sqrt", rb_gsl_sqrt, 1); rb_define_module_function(module, "log1p", rb_gsl_log1p, 1); rb_define_module_function(module, "expm1", rb_gsl_expm1, 1); rb_define_module_function(module, "hypot", rb_gsl_hypot, 2); #ifdef GSL_1_10_LATER rb_define_module_function(module, "hypot3", rb_gsl_hypot3, 3); #endif rb_define_module_function(module, "acosh", rb_gsl_acosh, 1); rb_define_module_function(module, "asinh", rb_gsl_asinh, 1); rb_define_module_function(module, "atanh", rb_gsl_atanh, 1); rb_define_module_function(module, "pow", rb_gsl_pow, 2); rb_define_module_function(module, "pow_int", rb_gsl_pow_int, 2); rb_define_module_function(module, "pow_2", rb_gsl_pow_2, 1); rb_define_module_function(module, "pow_3", rb_gsl_pow_3, 1); rb_define_module_function(module, "pow_4", rb_gsl_pow_4, 1); rb_define_module_function(module, "pow_5", rb_gsl_pow_5, 1); rb_define_module_function(module, "pow_6", rb_gsl_pow_6, 1); rb_define_module_function(module, "pow_7", rb_gsl_pow_7, 1); rb_define_module_function(module, "pow_8", rb_gsl_pow_8, 1); rb_define_module_function(module, "pow_9", rb_gsl_pow_9, 1); rb_define_module_function(module, "sign", rb_GSL_SIGN, 1); rb_define_module_function(module, "SIGN", rb_GSL_SIGN, 1); rb_define_module_function(module, "is_odd", rb_GSL_IS_ODD, 1); rb_define_module_function(module, "IS_ODD", rb_GSL_IS_ODD, 1); rb_define_module_function(module, "is_odd?", rb_GSL_IS_ODD2, 1); rb_define_module_function(module, "IS_ODD?", rb_GSL_IS_ODD2, 1); rb_define_module_function(module, "is_even", rb_GSL_IS_EVEN, 1); rb_define_module_function(module, "IS_EVEN", rb_GSL_IS_EVEN, 1); rb_define_module_function(module, "is_even?", rb_GSL_IS_EVEN2, 1); rb_define_module_function(module, "IS_EVEN?", rb_GSL_IS_EVEN2, 1); rb_define_module_function(module, "max", rb_GSL_MAX, 2); rb_define_module_function(module, "MAX", rb_GSL_MAX, 2); rb_define_module_function(module, "min", rb_GSL_MIN, 2); rb_define_module_function(module, "MIN", rb_GSL_MIN, 2); rb_define_module_function(module, "max_dbl", rb_GSL_MAX_DBL, 2); rb_define_module_function(module, "MAX_DBL", rb_GSL_MAX_DBL, 2); rb_define_module_function(module, "min_dbl", rb_GSL_MIN_DBL, 2); rb_define_module_function(module, "MIN_DBL", rb_GSL_MIN_DBL, 2); rb_define_module_function(module, "max_int", rb_GSL_MAX_INT, 2); rb_define_module_function(module, "MAX_INT", rb_GSL_MAX_INT, 2); rb_define_module_function(module, "min_int", rb_GSL_MIN_INT, 2); rb_define_module_function(module, "MIN_INT", rb_GSL_MIN_INT, 2); rb_define_module_function(module, "fcmp", rb_gsl_fcmp, -1); rb_define_singleton_method(module, "equal?", rb_gsl_equal, -1); #ifdef GSL_1_3_LATER rb_define_module_function(module, "ldexp", rb_gsl_ldexp, 2); rb_define_module_function(module, "frexp", rb_gsl_frexp, 1); #endif } gsl-1.15.3/ext/array_complex.c0000644000175000017500000001663412220252463015565 0ustar boutilboutil/* array_complex.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_complex.h" #include "rb_gsl_array.h" enum { GSL_COMPLEX_ADD, GSL_COMPLEX_SUB, GSL_COMPLEX_MUL, GSL_COMPLEX_DIV, }; static VALUE rb_gsl_complex_arithmetics5(int flag, VALUE obj, VALUE bb); static VALUE rb_gsl_complex_arithmetics5(int flag, VALUE obj, VALUE bb) { gsl_complex *a = NULL, *b = NULL, *c = NULL, tmp, tmp2; gsl_matrix *m = NULL; gsl_matrix_complex *cm = NULL, *cmself = NULL; gsl_vector *v = NULL; gsl_vector_complex *cv = NULL, *cvnew = NULL; gsl_complex (*func1)(gsl_complex, gsl_complex); // local variables "func2" iand "func3" declared and set, but never used //int (*func2)(gsl_matrix_complex*, const gsl_matrix_complex*); //int (*func3)(gsl_matrix_complex*, const gsl_complex); int flagcm = 0; switch (flag) { case GSL_COMPLEX_ADD: func1 = gsl_complex_add; //func2 = gsl_matrix_complex_add; //func3 = gsl_matrix_complex_add_constant; break; case GSL_COMPLEX_SUB: func1 = gsl_complex_sub; //func2 = gsl_matrix_complex_sub; //func3 = gsl_matrix_complex_add_constant; break; case GSL_COMPLEX_MUL: func1 = gsl_complex_mul; //func2 = gsl_matrix_complex_mul_elements; //func3 = gsl_matrix_complex_scale; break; case GSL_COMPLEX_DIV: func1 = gsl_complex_div; //func2 = gsl_matrix_complex_div_elements; //func3 = gsl_matrix_complex_scale; break; default: rb_raise(rb_eRuntimeError, "undefined operation"); } CHECK_COMPLEX(obj); Data_Get_Struct(obj, gsl_complex, a); switch (TYPE(bb)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: tmp2 = gsl_complex_rect(NUM2DBL(bb), 0.0); b = &tmp2; tmp = (*func1)(*a, *b); switch (flag) { case GSL_COMPLEX_ADD: case GSL_COMPLEX_SUB: case GSL_COMPLEX_MUL: case GSL_COMPLEX_DIV: c = ALLOC(gsl_complex); *c = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, c); break; } break; default: if (COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_complex, b); tmp = (*func1)(*a, *b); switch (flag) { case GSL_COMPLEX_ADD: case GSL_COMPLEX_SUB: case GSL_COMPLEX_MUL: case GSL_COMPLEX_DIV: c = ALLOC(gsl_complex); *c = tmp; return Data_Wrap_Struct(cgsl_complex, 0, free, c); break; } } else { if (VECTOR_P(bb)) { Data_Get_Struct(bb, gsl_vector, v); cv = vector_to_complex(v); cvnew = gsl_vector_complex_alloc(v->size); if (cvnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_vector_complex_set_all(cvnew, *a); switch (flag) { case GSL_COMPLEX_ADD: gsl_vector_complex_add(cvnew, cv); break; case GSL_COMPLEX_SUB: gsl_vector_complex_sub(cvnew, cv); break; case GSL_COMPLEX_MUL: gsl_vector_complex_mul(cvnew, cv); break; case GSL_COMPLEX_DIV: gsl_vector_complex_add(cvnew, cv); break; } gsl_vector_complex_free(cv); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew); } if (VECTOR_COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_vector_complex, cv); cvnew = gsl_vector_complex_alloc(v->size); if (cvnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_vector_complex_set_all(cvnew, *a); switch (flag) { case GSL_COMPLEX_ADD: gsl_vector_complex_add(cvnew, cv); break; case GSL_COMPLEX_SUB: gsl_vector_complex_sub(cvnew, cv); break; case GSL_COMPLEX_MUL: gsl_vector_complex_mul(cvnew, cv); break; case GSL_COMPLEX_DIV: gsl_vector_complex_add(cvnew, cv); break; } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew); } if (MATRIX_P(bb)) { Data_Get_Struct(bb, gsl_matrix, m); cm = matrix_to_complex(m); flagcm = 1; } else if (MATRIX_COMPLEX_P(bb)) { Data_Get_Struct(bb, gsl_matrix_complex, cm); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(bb))); } cmself = gsl_matrix_complex_alloc(m->size1, m->size2); if (cmself == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_set_all(cmself, *a); switch (flag) { case GSL_COMPLEX_ADD: gsl_matrix_complex_add(cmself, cm); break; case GSL_COMPLEX_SUB: gsl_matrix_complex_sub(cmself, cm); break; case GSL_COMPLEX_MUL: gsl_matrix_complex_mul_elements(cmself, cm); break; case GSL_COMPLEX_DIV: gsl_matrix_complex_div_elements(cmself, cm); break; } if (flagcm == 1) gsl_matrix_complex_free(cm); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmself); } } /* never reach here */ return Qnil; } static VALUE rb_gsl_complex_add(VALUE obj, VALUE bb) { return rb_gsl_complex_arithmetics5(GSL_COMPLEX_ADD, obj, bb); } static VALUE rb_gsl_complex_sub(VALUE obj, VALUE bb) { return rb_gsl_complex_arithmetics5(GSL_COMPLEX_SUB, obj, bb); } static VALUE rb_gsl_complex_mul(VALUE obj, VALUE bb) { return rb_gsl_complex_arithmetics5(GSL_COMPLEX_MUL, obj, bb); } static VALUE rb_gsl_complex_div(VALUE obj, VALUE bb) { return rb_gsl_complex_arithmetics5(GSL_COMPLEX_DIV, obj, bb); } static VALUE rb_gsl_complex_coerce(VALUE obj, VALUE other) { gsl_complex *c = NULL; gsl_matrix *m = NULL; gsl_matrix_complex *cmnew = NULL, *cmself = NULL; VALUE vcmself, vcmnew; double x; switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: x = NUM2DBL(other); c = ALLOC(gsl_complex); *c = gsl_complex_rect(x, 0.0); return rb_ary_new3(2, Data_Wrap_Struct(cgsl_complex, 0, free, c), obj); break; default: if (MATRIX_P(other)) { Data_Get_Struct(other, gsl_matrix, m); cmnew = matrix_to_complex(m); vcmnew = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); cmself = gsl_matrix_complex_alloc(m->size1, m->size2); if (cmself == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); Data_Get_Struct(obj, gsl_complex, c); gsl_matrix_complex_set_all(cmself, *c); vcmself = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmself); return rb_ary_new3(2, vcmself, vcmnew); } if (MATRIX_COMPLEX_P(other)) { Data_Get_Struct(other, gsl_matrix_complex, cmnew); cmself = gsl_matrix_complex_alloc(cmnew->size1, cmnew->size2); if (cmself == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); vcmself = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmself); return rb_ary_new3(2, vcmself, other); } else { rb_raise(rb_eTypeError, "cannot coerce to GSL::Complex"); } } } void Init_gsl_array_complex(VALUE mgsl) { rb_define_method(cgsl_complex, "coerce", rb_gsl_complex_coerce, 1); rb_define_method(cgsl_complex, "add", rb_gsl_complex_add, 1); rb_define_alias(cgsl_complex, "+", "add"); rb_define_method(cgsl_complex, "sub", rb_gsl_complex_sub, 1); rb_define_alias(cgsl_complex, "-", "sub"); rb_define_method(cgsl_complex, "mul", rb_gsl_complex_mul, 1); rb_define_alias(cgsl_complex, "*", "mul"); rb_define_method(cgsl_complex, "div", rb_gsl_complex_div, 1); rb_define_alias(cgsl_complex, "/", "div"); } gsl-1.15.3/ext/linalg.c0000644000175000017500000037456412220252463014177 0ustar boutilboutil/* linalg.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include #include "rb_gsl_array.h" #include "rb_gsl_common.h" #include "rb_gsl_linalg.h" static VALUE cgsl_matrix_LU; static VALUE cgsl_matrix_QR; static VALUE cgsl_matrix_QRPT; static VALUE cgsl_vector_tau; static VALUE cgsl_matrix_Q; static VALUE cgsl_matrix_R; static VALUE cgsl_matrix_LQ; static VALUE cgsl_matrix_PTLQ; static VALUE cgsl_matrix_L; static VALUE cgsl_matrix_SV; static VALUE cgsl_matrix_U; static VALUE cgsl_matrix_V; static VALUE cgsl_vector_S; static VALUE cgsl_matrix_C; enum { LINALG_DECOMP, LINALG_DECOMP_BANG, }; #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_decomp_narray(int argc, VALUE *argv, VALUE obj, int flag); #endif static VALUE rb_gsl_linalg_LU_decomposition(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *mtmp = NULL, *m = NULL; gsl_permutation *p = NULL; int signum, itmp; size_t size; VALUE objp, objm, omatrix; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_LU_decomp_narray(argc, argv, obj, flag); #endif if (MATRIX_COMPLEX_P(argv[0])) return rb_gsl_linalg_complex_LU_decomp2(argc, argv, obj); omatrix = argv[0]; itmp = 1; break; default: if (MATRIX_COMPLEX_P(obj)) return rb_gsl_linalg_complex_LU_decomp2(argc, argv, obj); omatrix = obj; itmp = 0; break; } CHECK_MATRIX(omatrix); Data_Get_Struct(omatrix, gsl_matrix, mtmp); if (flag == LINALG_DECOMP_BANG) { m = mtmp; RBASIC(omatrix)->klass = cgsl_matrix_LU; objm = omatrix; } else { m = make_matrix_clone(mtmp); objm = Data_Wrap_Struct(cgsl_matrix_LU, 0, gsl_matrix_free, m); } size = m->size1; switch (argc-itmp) { case 0: p = gsl_permutation_alloc(size); gsl_linalg_LU_decomp(m, p, &signum); objp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); if (flag == LINALG_DECOMP_BANG) return rb_ary_new3(2, objp, INT2FIX(signum)); else return rb_ary_new3(3, objm, objp, INT2FIX(signum)); break; case 1: CHECK_PERMUTATION(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_permutation, p); gsl_linalg_LU_decomp(m, p, &signum); if (flag == LINALG_DECOMP_BANG) return INT2FIX(signum); else return rb_ary_new3(2, objm, INT2FIX(signum)); break; default: rb_raise(rb_eArgError, "Usage: LU_decomp() or LU_decomp(permutation)"); break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_linalg_LU_decomp(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_LU_decomposition(argc, argv, obj, LINALG_DECOMP); } static VALUE rb_gsl_linalg_LU_decomp_bang(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_LU_decomposition(argc, argv, obj, LINALG_DECOMP_BANG); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_decomp_narray(int argc, VALUE *argv, VALUE obj, int flag) { struct NARRAY *na, *na2; VALUE m; gsl_matrix_view mv; gsl_permutation *p; int signum; if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); GetNArray(argv[0], na); if (na->rank < 2) rb_raise(rb_eRuntimeError, "rank >= 2 required"); if (na->shape[0] != na->shape[1]) rb_raise(rb_eRuntimeError, "square matrix required"); if (flag == LINALG_DECOMP) { m = na_make_object(NA_DFLOAT, 2, na->shape, CLASS_OF(argv[0])); GetNArray(m, na2); memcpy((double*)na2->ptr, (double*)na->ptr, sizeof(double)*na2->total); mv = gsl_matrix_view_array((double*)na2->ptr, na->shape[1], na->shape[0]); } else { mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]); } p = gsl_permutation_alloc(mv.matrix.size1); gsl_linalg_LU_decomp(&mv.matrix, p, &signum); if (flag == LINALG_DECOMP) { return rb_ary_new3(3, m, Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p), INT2FIX(signum)); } else { return rb_ary_new3(3, argv[0], Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p), INT2FIX(signum)); } } #endif static gsl_matrix* get_matrix(VALUE obj, VALUE klass,int *flagm); static gsl_permutation* get_permutation(VALUE obj, size_t size, int *flagp); static gsl_vector* get_vector2(VALUE obj, int *flagv); static gsl_matrix* get_matrix(VALUE obj, VALUE klass, int *flagm) { gsl_matrix *mtmp = NULL, *m = NULL; #ifdef HAVE_NARRAY_H gsl_matrix_view mv; struct NARRAY *na; #endif if (CLASS_OF(obj) == klass) { Data_Get_Struct(obj, gsl_matrix, m); *flagm = 0; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(obj)) { GetNArray(obj, na); mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]); m = &mv.matrix; *flagm = -1; #endif } else { CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, mtmp); m = make_matrix_clone(mtmp); *flagm = 1; } return m; } static gsl_permutation* get_permutation(VALUE obj, size_t size, int *flagp) { gsl_permutation *p = NULL; if (CLASS_OF(obj) == cgsl_permutation) { Data_Get_Struct(obj, gsl_permutation, p); *flagp = 0; } else { p = gsl_permutation_alloc(size); *flagp = 1; } return p; } static gsl_vector* get_vector2(VALUE obj, int *flagv) { gsl_vector *v = NULL; #ifdef HAVE_NARRAY_H gsl_vector_view vv; struct NARRAY *na; #endif if (TYPE(obj) == T_ARRAY) { v = make_cvector_from_rarray(obj); *flagv = 1; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(obj)) { GetNArray(obj, na); vv = gsl_vector_view_array((double*) na->ptr, na->total); v = &vv.vector; *flagv = -1; #endif } else { CHECK_VECTOR(obj); Data_Get_Struct(obj, gsl_vector, v); *flagv = 0; } return v; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_solve_narray(int argc, VALUE *argv, VALUE obj); #endif VALUE rb_gsl_linalg_LU_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL; gsl_permutation *p = NULL; gsl_vector *b = NULL, *x = NULL; int signum, flagm = 0, flagp = 0, flagb = 0, flagx = 0, itmp; size_t size; VALUE bb; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2 || argc > 4) rb_raise(rb_eArgError, "Usage: solve(m, b), solve(m, b, x), solve(lu, p, b), solve(lu, p, b, x)"); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_LU_solve_narray(argc, argv, obj); #endif m = get_matrix(argv[0], cgsl_matrix_LU, &flagm); itmp = 1; break; default: if (argc < 1 || argc > 3) rb_raise(rb_eArgError, "Usage: LU_solve(b), LU_solve(p, b), LU_solve(b, x), solve(p, b, x)"); m = get_matrix(obj, cgsl_matrix_LU, &flagm); itmp = 0; break; } size = m->size1; p = get_permutation(argv[itmp], size, &flagp); if (flagp == 1 && flagm == 0) rb_raise(rb_eArgError, "permutation must be given"); if (flagp == 0) itmp++; bb = argv[itmp]; b = get_vector2(argv[itmp], &flagb); itmp++; if (itmp == argc) { x = gsl_vector_alloc(size); flagx = 1; } else { CHECK_VECTOR(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_vector, x); } if (flagm == 1) gsl_linalg_LU_decomp(m, p, &signum); gsl_linalg_LU_solve(m, p, b, x); if (flagm == 1) gsl_matrix_free(m); if (flagp == 1) gsl_permutation_free(p); if (flagb == 1) gsl_vector_free(b); if (flagx == 1) return Data_Wrap_Struct(VECTOR_ROW_COL(bb), 0, gsl_vector_free, x); else return argv[argc-1]; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_solve_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na, *b; VALUE ret; gsl_permutation *p; gsl_matrix_view mv; gsl_vector_view bv, xv; double *x; int shape[1]; if (argc < 3) rb_raise(rb_eArgError, "wrong number of arguments %d(NArray, GSL::Permutation and NArray expected", argc); GetNArray(argv[0], na); mv = gsl_matrix_view_array((double*) na->ptr, na->shape[1], na->shape[0]); CHECK_PERMUTATION(argv[1]); Data_Get_Struct(argv[1], gsl_permutation, p); GetNArray(argv[2], b); bv = gsl_vector_view_array((double*) b->ptr, b->total); if (argc == 3) { shape[0] = b->total; ret = na_make_object(NA_DFLOAT, 1, shape, CLASS_OF(argv[0])); } else { ret = argv[3]; } x = NA_PTR_TYPE(ret,double*); xv = gsl_vector_view_array(x, b->total); gsl_linalg_LU_solve(&mv.matrix, p, &bv.vector, &xv.vector); return ret; } #endif #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_svx_narray(int argc, VALUE *argv, VALUE obj); #endif /* bb must be Vector, it is replaced by the root of the system */ static VALUE rb_gsl_linalg_LU_svx(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL; gsl_permutation *p = NULL; gsl_vector *b = NULL; int signum, flagm = 0, flagp = 0, flagb = 0, itmp; size_t size; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2 || argc > 3) rb_raise(rb_eArgError, "Usage: svx(m, b), svx(lu, p, b)"); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_LU_svx_narray(argc, argv, obj); #endif m = get_matrix(argv[0], cgsl_matrix_LU, &flagm); itmp = 1; break; default: if (argc < 1 || argc > 2) rb_raise(rb_eArgError, "Usage: LU_svx(b), LU_svx(p, b)"); m = get_matrix(obj, cgsl_matrix_LU, &flagm); itmp = 0; break; } size = m->size1; p = get_permutation(argv[itmp], size, &flagp); if (flagp == 1 && flagm == 0) rb_raise(rb_eArgError, "permutation must be given"); if (flagp == 0) itmp++; CHECK_VECTOR(argv[itmp]); b = get_vector2(argv[itmp], &flagb); if (flagm == 1) gsl_linalg_LU_decomp(m, p, &signum); gsl_linalg_LU_svx(m, p, b); if (flagm == 1) gsl_matrix_free(m); if (flagp == 1) gsl_permutation_free(p); return argv[itmp]; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_svx_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na, *b; gsl_permutation *p; gsl_matrix_view mv; gsl_vector_view bv; if (argc != 3) rb_raise(rb_eArgError, "wrong number of arguments %d(NArray, GSL::Permutation and NArray expected", argc); GetNArray(argv[0], na); mv = gsl_matrix_view_array((double*) na->ptr, na->shape[1], na->shape[0]); CHECK_PERMUTATION(argv[1]); Data_Get_Struct(argv[1], gsl_permutation, p); GetNArray(argv[2], b); bv = gsl_vector_view_array((double*) b->ptr, b->total); gsl_linalg_LU_svx(&mv.matrix, p, &bv.vector); return argv[2]; } #endif /* singleton */ static VALUE rb_gsl_linalg_LU_refine(VALUE obj, VALUE vm, VALUE lu, VALUE pp, VALUE bb, VALUE xx) { gsl_matrix *m = NULL, *mlu = NULL; gsl_permutation *p = NULL; gsl_vector *b = NULL, *x = NULL, *r = NULL; int flagb = 0; VALUE vr; CHECK_MATRIX(vm); CHECK_MATRIX(lu); CHECK_PERMUTATION(pp); CHECK_VECTOR(xx); Data_Get_Struct(vm, gsl_matrix, m); Data_Get_Struct(lu, gsl_matrix, mlu); Data_Get_Struct(pp, gsl_permutation, p); if (TYPE(bb) == T_ARRAY) { b = make_cvector_from_rarray(bb); flagb = 1; } else { CHECK_VECTOR(bb); Data_Get_Struct(bb, gsl_vector, b); } Data_Get_Struct(xx, gsl_vector, x); r = gsl_vector_alloc(m->size1); gsl_linalg_LU_refine(m, mlu, p, b, x, r); vr = Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, r); if (flagb == 1) gsl_vector_free(b); return rb_ary_new3(2, xx, vr); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_invert_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_linalg_LU_invert(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL, *inverse = NULL; gsl_permutation *p = NULL; int signum, flagm = 0, flagp = 0, itmp; size_t size; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_LU_invert_narray(argc, argv, obj); #endif m = get_matrix(argv[0], cgsl_matrix_LU, &flagm); itmp = 1; break; default: m = get_matrix(obj, cgsl_matrix_LU, &flagm); itmp = 0; } size = m->size1; if (argc == itmp) { p = gsl_permutation_alloc(size); flagp = 1; } else { CHECK_PERMUTATION(argv[itmp]); p = get_permutation(argv[itmp], size, &flagp); } if (flagp == 1 && flagm == 0) rb_raise(rb_eArgError, "permutation must be given"); if (flagp == 0) itmp++; if (flagm == 1 || flagp == 1) { gsl_linalg_LU_decomp(m, p, &signum); } if (argc-1 == itmp) { CHECK_MATRIX(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_matrix, inverse); } else { inverse = gsl_matrix_alloc(size, size); } gsl_linalg_LU_invert(m, p, inverse); if (flagm == 1) gsl_matrix_free(m); if (flagp == 1) gsl_permutation_free(p); if (argc-1 == itmp) return argv[itmp]; else return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, inverse); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_LU_invert_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; VALUE inv; gsl_permutation *p; gsl_matrix_view mv1, mv2; if (argc != 2) { rb_raise(rb_eArgError, "Usage: LU.invert(lu, perm)"); } CHECK_PERMUTATION(argv[1]); GetNArray(argv[0], na); inv = na_make_object(NA_DFLOAT, 2, na->shape, CLASS_OF(argv[0])); mv1 = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]); mv2 = gsl_matrix_view_array(NA_PTR_TYPE(inv, double*), na->shape[1], na->shape[0]); CHECK_PERMUTATION(argv[1]); Data_Get_Struct(argv[1], gsl_permutation, p); gsl_linalg_LU_invert(&mv1.matrix, p, &mv2.matrix); return inv; } static VALUE rb_gsl_linalg_LU_det_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; gsl_matrix_view mv; int signum = 1; switch (argc) { case 2: signum = FIX2INT(argv[1]); /* no break */ case 1: GetNArray(argv[0], na); mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]); break; default: rb_raise(rb_eArgError, "Usage: LU.det(lu, perm)"); break; } return rb_float_new(gsl_linalg_LU_det(&mv.matrix, signum)); } static VALUE rb_gsl_linalg_LU_lndet_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; gsl_matrix_view mv; switch (argc) { case 1: GetNArray(argv[0], na); mv = gsl_matrix_view_array((double*)na->ptr, na->shape[1], na->shape[0]); break; default: rb_raise(rb_eArgError, "Usage: LU.lndet(lu)"); break; } return rb_float_new(gsl_linalg_LU_lndet(&mv.matrix)); } #endif static VALUE rb_gsl_linalg_LU_det(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL; gsl_permutation *p = NULL; int flagm = 0, flagp = 0, itmp, sign; size_t size; double det; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_LU_det_narray(argc, argv, obj); #endif m = get_matrix(argv[0], cgsl_matrix_LU, &flagm); itmp = 1; break; default: m = get_matrix(obj, cgsl_matrix_LU, &flagm); itmp = 0; break; } size = m->size1; if (flagm == 0) { if (argc-itmp == 1) sign = FIX2INT(argv[itmp]); else sign = 1; } else { if (argc-itmp >= 2) { get_permutation(argv[itmp], size, &flagp); } else { p = gsl_permutation_alloc(size); flagp = 1; } } if (flagm == 1) gsl_linalg_LU_decomp(m, p, &sign); det = gsl_linalg_LU_det(m, sign); if (flagm == 1) gsl_matrix_free(m); if (flagp == 1) gsl_permutation_free(p); return rb_float_new(det); } static VALUE rb_gsl_linalg_LU_lndet(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL; gsl_permutation *p = NULL; int flagm = 0, sign; double lndet; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_LU_lndet_narray(argc, argv, obj); #endif m = get_matrix(argv[0], cgsl_matrix_LU, &flagm); break; default: m = get_matrix(obj, cgsl_matrix_LU, &flagm); break; } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_LU_decomp(m, p, &sign); } lndet = gsl_linalg_LU_lndet(m); if (flagm == 1) { gsl_matrix_free(m); gsl_permutation_free(p); } return rb_float_new(lndet); } static VALUE rb_gsl_linalg_LU_sgndet(int argc, VALUE *argv, VALUE obj) { gsl_matrix *m = NULL; gsl_permutation *p = NULL; int flagm = 0, sign, signdet, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: m = get_matrix(argv[0], cgsl_matrix_LU, &flagm); itmp = 1; break; default: m = get_matrix(obj, cgsl_matrix_LU, &flagm); itmp = 0; break; } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_LU_decomp(m, p, &sign); } else { if (argc-itmp != 1) rb_raise(rb_eArgError, "sign must be given"); sign = FIX2INT(argv[itmp]); } signdet = gsl_linalg_LU_sgndet(m, sign); if (flagm == 1) { gsl_matrix_free(m); gsl_permutation_free(p); } return INT2FIX(signdet); } #ifdef GSL_1_6_LATER int gsl_linalg_LQ_solve_T(const gsl_matrix*, const gsl_vector*, const gsl_vector*, gsl_vector*); int gsl_linalg_LQ_svx_T (const gsl_matrix*, const gsl_vector*, gsl_vector*); int gsl_linalg_LQ_lssolve_T(const gsl_matrix * LQ, const gsl_vector * tau, const gsl_vector * b, gsl_vector * x, gsl_vector * residual); int gsl_linalg_LQ_Lsolve_T (const gsl_matrix * LQ, const gsl_vector * b, gsl_vector* x); int gsl_linalg_LQ_Lsvx_T (const gsl_matrix * LQ, gsl_vector * x); int gsl_linalg_L_solve_T (const gsl_matrix * L, const gsl_vector * b, gsl_vector * x); #endif enum { LINALG_QR_DECOMP, LINALG_QR_DECOMP_BANG, LINALG_LQ_DECOMP, LINALG_LQ_DECOMP_BANG, LINALG_QR_SOLVE, LINALG_LQ_SOLVE, LINALG_QR_QTvec, LINALG_QR_Qvec, LINALG_LQ_vecQ, LINALG_LQ_vecQT, LINALG_QR_RSOLVE, LINALG_LQ_LSOLVE, LINALG_QR_RSVX, LINALG_LQ_LSVX, LINALG_R_SOLVE, LINALG_R_SVX, LINALG_L_SOLVE, LINALG_L_SVX, LINALG_QR_UNPACK, LINALG_LQ_UNPACK, }; static VALUE rb_gsl_linalg_QR_LQ_decomposition(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *m = NULL, *mtmp = NULL; gsl_vector *tau = NULL; int (*fdecomp)(gsl_matrix *, gsl_vector *); int itmp, status; VALUE vtau, mdecomp, omatrix; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); omatrix = argv[0]; itmp = 1; break; default: omatrix = obj; itmp = 0; break; } CHECK_MATRIX(omatrix); Data_Get_Struct(omatrix, gsl_matrix, mtmp); switch (flag) { case LINALG_QR_DECOMP: fdecomp = &gsl_linalg_QR_decomp; m = make_matrix_clone(mtmp); mdecomp = Data_Wrap_Struct(cgsl_matrix_QR, 0, gsl_matrix_free, m); break; case LINALG_QR_DECOMP_BANG: fdecomp = &gsl_linalg_QR_decomp; m = mtmp; mdecomp = omatrix; RBASIC(mdecomp)->klass = cgsl_matrix_QR; break; #ifdef GSL_1_6_LATER case LINALG_LQ_DECOMP: fdecomp = &gsl_linalg_LQ_decomp; m = make_matrix_clone(mtmp); mdecomp = Data_Wrap_Struct(cgsl_matrix_LQ, 0, gsl_matrix_free, m); break; case LINALG_LQ_DECOMP_BANG: fdecomp = &gsl_linalg_LQ_decomp; m = mtmp; mdecomp = omatrix; RBASIC(mdecomp)->klass = cgsl_matrix_LQ; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } switch (argc - itmp) { case 0: tau = gsl_vector_alloc(GSL_MIN(mtmp->size1, mtmp->size2)); break; case 1: CHECK_VECTOR(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_vector, tau); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } status = (*fdecomp)(m, tau); switch (flag) { case LINALG_QR_DECOMP: case LINALG_LQ_DECOMP: if (argc == itmp) { vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); return rb_ary_new3(2, mdecomp, vtau); } else { RBASIC(argv[itmp])->klass = cgsl_vector_tau; return mdecomp; } break; case LINALG_QR_DECOMP_BANG: case LINALG_LQ_DECOMP_BANG: if (argc == itmp) { return Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); } else { RBASIC(argv[itmp])->klass = cgsl_vector_tau; return INT2FIX(status); } break; default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } return Qnil; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_QR_decomp_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_linalg_QR_decomp(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_NARRAY_H if (argc >= 1 && NA_IsNArray(argv[0])) return rb_gsl_linalg_QR_decomp_narray(argc, argv, obj); #endif return rb_gsl_linalg_QR_LQ_decomposition(argc, argv, obj, LINALG_QR_DECOMP); } static VALUE rb_gsl_linalg_QR_decomp_bang(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QR_LQ_decomposition(argc, argv, obj, LINALG_QR_DECOMP_BANG); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_LQ_decomp(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QR_LQ_decomposition(argc, argv, obj, LINALG_LQ_DECOMP); } static VALUE rb_gsl_linalg_LQ_decomp_bang(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QR_LQ_decomposition(argc, argv, obj, LINALG_LQ_DECOMP_BANG); } #endif static VALUE rb_gsl_linalg_QR_LQ_solve(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *m = NULL; gsl_vector *b = NULL, *x = NULL, *tau = NULL; VALUE omatrix; int flagm = 0, flagt = 0, flagb = 0, flagx = 0, itmp; size_t size; int (*fdecomp)(gsl_matrix*, gsl_vector*); int (*fsolve)(const gsl_matrix*, const gsl_vector*, const gsl_vector*, gsl_vector*); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); omatrix = argv[0]; itmp = 1; break; default: omatrix = obj; itmp = 0; break; } if (argc-itmp < 1 || argc-itmp > 3) rb_raise(rb_eArgError, "wrong number of arguments"); CHECK_MATRIX(omatrix); switch (flag) { case LINALG_QR_SOLVE: m = get_matrix(omatrix, cgsl_matrix_QR, &flagm); fdecomp = &gsl_linalg_QR_decomp; fsolve = &gsl_linalg_QR_solve; break; #ifdef GSL_1_6_LATER case LINALG_LQ_SOLVE: m = get_matrix(omatrix, cgsl_matrix_LQ, &flagm); fdecomp = &gsl_linalg_LQ_decomp; fsolve = &gsl_linalg_LQ_solve_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operatioin"); break; } size = m->size1; if (flagm == 0) { /* the matrix given is already decomped */ if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) rb_raise(rb_eArgError, "tau vector must be given"); Data_Get_Struct(argv[itmp], gsl_vector, tau); flagt = 0; itmp++; } else { if (CLASS_OF(argv[itmp]) == cgsl_vector_tau) { Data_Get_Struct(argv[itmp], gsl_vector, tau); flagt = 0; itmp++; } else { tau = gsl_vector_alloc(size); flagt = 1; } } b = get_vector2(argv[itmp], &flagb); itmp++; if (itmp == argc) { x = gsl_vector_alloc(m->size1); flagx = 1; } else { CHECK_VECTOR(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_vector, x); flagx = 0; } if (flagm == 1) (*fdecomp)(m, tau); (*fsolve)(m, tau, b, x); if (flagm == 1) gsl_matrix_free(m); if (flagt == 1) gsl_vector_free(tau); if (flagb == 1) gsl_vector_free(b); if (flagx == 1) return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); else return argv[itmp]; } static VALUE rb_gsl_linalg_QR_LQ_svx(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *m = NULL; gsl_vector *b = NULL, *tau = NULL; VALUE omatrix; int flagm = 0, flagt = 0, flagb = 0, itmp; size_t size; int (*fdecomp)(gsl_matrix*, gsl_vector*); int (*fsvx)(const gsl_matrix*, const gsl_vector*, gsl_vector*); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); omatrix = argv[0]; itmp = 1; break; default: omatrix = obj; itmp = 0; break; } if (argc-itmp < 1 || argc-itmp > 2) rb_raise(rb_eArgError, "wrong number of arguments"); CHECK_MATRIX(omatrix); switch (flag) { case LINALG_QR_SOLVE: m = get_matrix(omatrix, cgsl_matrix_QR, &flagm); fdecomp = &gsl_linalg_QR_decomp; fsvx = &gsl_linalg_QR_svx; break; #ifdef GSL_1_6_LATER case LINALG_LQ_SOLVE: m = get_matrix(omatrix, cgsl_matrix_LQ, &flagm); fdecomp = &gsl_linalg_LQ_decomp; fsvx = &gsl_linalg_LQ_svx_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operatioin"); break; } size = m->size1; if (flagm == 0) { /* the matrix given is already decomped */ if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) rb_raise(rb_eArgError, "tau vector must be given"); Data_Get_Struct(argv[itmp], gsl_vector, tau); flagt = 0; itmp++; } else { if (CLASS_OF(argv[itmp]) == cgsl_vector_tau) { Data_Get_Struct(argv[itmp], gsl_vector, tau); flagt = 0; itmp++; } else { tau = gsl_vector_alloc(size); flagt = 1; } } b = get_vector2(argv[itmp], &flagb); if (flagm == 1 && flagt == 1) (*fdecomp)(m, tau); (*fsvx)(m, tau, b); if (flagm == 1) gsl_matrix_free(m); if (flagt == 1) gsl_vector_free(tau); return argv[itmp]; } static VALUE rb_gsl_linalg_QR_LQ_lssolve(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *m = NULL; gsl_vector *b = NULL, *x = NULL, *tau = NULL, *r = NULL; VALUE omatrix; int flagm = 0, flagt = 0, flagb = 0, itmp, status; size_t size; int (*fdecomp)(gsl_matrix*, gsl_vector*); int (*flssolve)(const gsl_matrix*, const gsl_vector*, const gsl_vector*, gsl_vector*, gsl_vector*); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); omatrix = argv[0]; itmp = 1; break; default: omatrix = obj; itmp = 0; break; } if (argc-itmp < 1 || argc-itmp > 4) rb_raise(rb_eArgError, "wrong number of arguments"); CHECK_MATRIX(omatrix); switch (flag) { case LINALG_QR_SOLVE: m = get_matrix(omatrix, cgsl_matrix_QR, &flagm); fdecomp = &gsl_linalg_QR_decomp; flssolve = &gsl_linalg_QR_lssolve; break; #ifdef GSL_1_6_LATER case LINALG_LQ_SOLVE: m = get_matrix(omatrix, cgsl_matrix_LQ, &flagm); fdecomp = &gsl_linalg_LQ_decomp; flssolve = &gsl_linalg_LQ_lssolve_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operatioin"); break; } size = m->size1; if (flagm == 0) { /* the matrix given is already decomped */ if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) rb_raise(rb_eArgError, "tau vector must be given"); Data_Get_Struct(argv[itmp], gsl_vector, tau); flagt = 0; itmp++; } else { if (CLASS_OF(argv[itmp]) == cgsl_vector_tau) { Data_Get_Struct(argv[itmp], gsl_vector, tau); flagt = 0; itmp++; } else { tau = gsl_vector_alloc(size); flagt = 1; } } b = get_vector2(argv[itmp], &flagb); itmp++; switch (argc - itmp) { case 2: CHECK_VECTOR(argv[argc-2]); Data_Get_Struct(argv[argc-2], gsl_vector, x); CHECK_VECTOR(argv[argc-1]); Data_Get_Struct(argv[argc-1], gsl_vector, r); break; case 1: CHECK_VECTOR(argv[argc-1]); Data_Get_Struct(argv[argc-1], gsl_vector, x); r = gsl_vector_alloc(x->size); break; case 0: x = gsl_vector_alloc(m->size1); r = gsl_vector_alloc(m->size1); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } if (flagm == 1) (*fdecomp)(m, tau); status = (*flssolve)(m, tau, b, x, r); if (flagm == 1) gsl_matrix_free(m); if (flagt == 1) gsl_vector_free(tau); if (flagb == 1) gsl_vector_free(b); switch (argc - itmp) { case 2: return INT2FIX(status); break; case 1: return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, r); break; default: return rb_ary_new3(2, Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x), Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, r)); } return Qnil; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_QR_solve_narray(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_linalg_QR_svx_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_linalg_QR_solve(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_NARRAY_H if (argc == 3 && NA_IsNArray(argv[0])) return rb_gsl_linalg_QR_solve_narray(argc, argv, obj); #endif return rb_gsl_linalg_QR_LQ_solve(argc, argv, obj, LINALG_QR_SOLVE); } static VALUE rb_gsl_linalg_QR_svx(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_NARRAY_H if (argc == 2 && NA_IsNArray(argv[0])) return rb_gsl_linalg_QR_svx_narray(argc, argv, obj); #endif return rb_gsl_linalg_QR_LQ_svx(argc, argv, obj, LINALG_QR_SOLVE); } static VALUE rb_gsl_linalg_QR_lssolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QR_LQ_lssolve(argc, argv, obj, LINALG_QR_SOLVE); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_LQ_solve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QR_LQ_solve(argc, argv, obj, LINALG_LQ_SOLVE); } static VALUE rb_gsl_linalg_LQ_svx(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QR_LQ_svx(argc, argv, obj, LINALG_LQ_SOLVE); } static VALUE rb_gsl_linalg_LQ_lssolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QR_LQ_lssolve(argc, argv, obj, LINALG_LQ_SOLVE); } #endif static VALUE rb_gsl_linalg_QRLQ_QTvec(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL; gsl_vector *tau = NULL, *v = NULL; VALUE ret; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[0], gsl_matrix, QR); Data_Get_Struct(argv[1], gsl_vector, tau); Data_Get_Struct(argv[2], gsl_vector, v); ret = argv[2]; break; default: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[1]); Data_Get_Struct(obj, gsl_matrix, QR); Data_Get_Struct(argv[0], gsl_vector, tau); Data_Get_Struct(argv[1], gsl_vector, v); ret = argv[1]; break; } switch (flag) { case LINALG_QR_QTvec: gsl_linalg_QR_QTvec(QR, tau, v); break; case LINALG_QR_Qvec: gsl_linalg_QR_Qvec(QR, tau, v); break; #ifdef GSL_1_6_LATER case LINALG_LQ_vecQ: gsl_linalg_LQ_vecQ(QR, tau, v); break; case LINALG_LQ_vecQT: gsl_linalg_LQ_vecQT(QR, tau, v); break; #endif default: break; } return ret; } static VALUE rb_gsl_linalg_QR_QTvec(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_QTvec(argc, argv, obj, LINALG_QR_QTvec); } static VALUE rb_gsl_linalg_QR_Qvec(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_QTvec(argc, argv, obj, LINALG_QR_Qvec); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_LQ_vecQT(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_QTvec(argc, argv, obj, LINALG_LQ_vecQT); } static VALUE rb_gsl_linalg_LQ_vecQ(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_QTvec(argc, argv, obj, LINALG_LQ_vecQ); } #endif static VALUE rb_gsl_linalg_QRLQ_unpack(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL, *Q = NULL, *R = NULL; gsl_vector *tau = NULL; int itmp; VALUE vtmp, vQ, vR, klass; switch (flag) { case LINALG_QR_UNPACK: klass = cgsl_matrix_QR; break; case LINALG_LQ_UNPACK: klass = cgsl_matrix_LQ; break; default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); vtmp = argv[0]; itmp = 1; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); vtmp = obj; itmp = 0; break; } CHECK_MATRIX(vtmp); if (CLASS_OF(vtmp) != klass) { rb_raise(rb_eTypeError, "not a QR matrix"); } Data_Get_Struct(vtmp, gsl_matrix, QR); if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) rb_raise(rb_eTypeError, "tau vector must be given."); Data_Get_Struct(argv[itmp], gsl_vector, tau); Q = gsl_matrix_alloc(QR->size1, QR->size1); R = gsl_matrix_alloc(QR->size1, QR->size2); switch (flag) { case LINALG_QR_UNPACK: gsl_linalg_QR_unpack(QR, tau, Q, R); vQ = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, Q); vR = Data_Wrap_Struct(cgsl_matrix_R, 0, gsl_matrix_free, R); break; #ifdef GSL_1_6_LATER case LINALG_LQ_UNPACK: gsl_linalg_LQ_unpack(QR, tau, Q, R); vQ = Data_Wrap_Struct(cgsl_matrix_L, 0, gsl_matrix_free, Q); vR = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, R); break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } return rb_ary_new3(2, vQ, vR); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_QR_unpack_narray(int argc, VALUE *argv, VALUE obj); #endif static VALUE rb_gsl_linalg_QR_unpack(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_NARRAY_H if (argc == 2 && NA_IsNArray(argv[0])) return rb_gsl_linalg_QR_unpack_narray(argc, argv, obj); #endif return rb_gsl_linalg_QRLQ_unpack(argc, argv, obj, LINALG_QR_UNPACK); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_LQ_unpack(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_unpack(argc, argv, obj, LINALG_LQ_UNPACK); } #endif /* singleton */ static VALUE rb_gsl_linalg_QRLQ_QRLQsolve(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *Q = NULL, *R = NULL; gsl_vector *b = NULL, *x = NULL; int (*fsolve)(gsl_matrix*, gsl_matrix *, const gsl_vector*, gsl_vector *); int flagb = 0; VALUE retval; switch (argc) { case 3: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, Q); Data_Get_Struct(argv[1], gsl_matrix, R); x = gsl_vector_alloc(Q->size1); retval = Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); break; case 4: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); CHECK_VECTOR(argv[3]); Data_Get_Struct(argv[0], gsl_matrix, Q); Data_Get_Struct(argv[1], gsl_matrix, R); Data_Get_Struct(argv[3], gsl_vector, x); retval = argv[3]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); break; } switch (flag) { case LINALG_QR_DECOMP: if (CLASS_OF(argv[0]) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix"); if (CLASS_OF(argv[1]) != cgsl_matrix_R) rb_raise(rb_eTypeError, "not a R matrix"); fsolve = &gsl_linalg_QR_QRsolve; break; #ifdef GSL_1_6_LATER case LINALG_LQ_DECOMP: /* if (CLASS_OF(argv[0]) != cgsl_matrix_L) rb_raise(rb_eTypeError, "not a L matrix"); if (CLASS_OF(argv[1]) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix");*/ fsolve = &gsl_linalg_LQ_LQsolve; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } if (TYPE(argv[2]) == T_ARRAY) { b = make_cvector_from_rarray(argv[2]); flagb = 1; } else { CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, b); } (*fsolve)(Q, R, b, x); if (flagb == 1) gsl_vector_free(b); return retval; } /*****/ static VALUE rb_gsl_linalg_QRLQ_RLsolve(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL, *mtmp; gsl_vector *b = NULL, *x = NULL, *tau = NULL; size_t istart; int (*fsolve)(const gsl_matrix*, const gsl_vector*, gsl_vector *); int flagb = 0, flagq = 0; VALUE omatrix,retval; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); omatrix = argv[0]; istart = 1; break; default: omatrix = obj; istart = 0; break; } CHECK_MATRIX(omatrix); Data_Get_Struct(omatrix, gsl_matrix, mtmp); switch (argc - istart) { case 1: x = gsl_vector_alloc(mtmp->size1); retval = Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); break; case 2: Data_Get_Struct(argv[istart+1], gsl_vector, x); retval = argv[istart+1]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); break; } QR = mtmp; flagq = 0; switch (flag) { case LINALG_QR_RSOLVE: if (CLASS_OF(omatrix) != cgsl_matrix_QR) { QR = make_matrix_clone(mtmp); tau = gsl_vector_alloc(QR->size1); gsl_linalg_QR_decomp(QR, tau); flagq = 1; } fsolve = &gsl_linalg_QR_Rsolve; break; case LINALG_R_SOLVE: if (CLASS_OF(omatrix) != cgsl_matrix_QR) { QR = make_matrix_clone(mtmp); tau = gsl_vector_alloc(QR->size1); gsl_linalg_QR_decomp(QR, tau); flagq = 1; } fsolve = &gsl_linalg_R_solve; break; #ifdef GSL_1_6_LATER case LINALG_LQ_LSOLVE: if (CLASS_OF(omatrix) != cgsl_matrix_LQ) { QR = make_matrix_clone(mtmp); tau = gsl_vector_alloc(QR->size1); gsl_linalg_LQ_decomp(QR, tau); flagq = 1; } fsolve = &gsl_linalg_LQ_Lsolve_T; break; case LINALG_L_SOLVE: if (CLASS_OF(omatrix) != cgsl_matrix_LQ) { QR = make_matrix_clone(mtmp); tau = gsl_vector_alloc(QR->size1); gsl_linalg_LQ_decomp(QR, tau); flagq = 1; } fsolve = &gsl_linalg_L_solve_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } if (TYPE(argv[istart]) == T_ARRAY) { b = make_cvector_from_rarray(argv[istart]); flagb = 1; } else { CHECK_VECTOR(argv[istart]); Data_Get_Struct(argv[istart], gsl_vector, b); } (*fsolve)(QR, b, x); if (flagb == 1) gsl_vector_free(b); if (flagq == 1) { gsl_matrix_free(QR); gsl_vector_free(tau); } return retval; } static VALUE rb_gsl_linalg_QRLQ_RLsvx(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL, *mtmp; gsl_vector *x = NULL, *tau = NULL; size_t istart; int (*fsolve)(const gsl_matrix*, gsl_vector *); int flagq = 0; VALUE omatrix,retval; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); omatrix = argv[0]; istart = 1; break; default: omatrix = obj; istart = 0; break; } CHECK_MATRIX(omatrix); Data_Get_Struct(omatrix, gsl_matrix, mtmp); switch (argc - istart) { case 0: x = gsl_vector_alloc(mtmp->size1); retval = Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); break; case 1: Data_Get_Struct(argv[istart+1], gsl_vector, x); retval = argv[istart+1]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); break; } QR = mtmp; flagq = 0; switch (flag) { case LINALG_QR_RSVX: if (CLASS_OF(omatrix) != cgsl_matrix_QR) { QR = make_matrix_clone(mtmp); tau = gsl_vector_alloc(QR->size1); gsl_linalg_QR_decomp(QR, tau); flagq = 1; } fsolve = &gsl_linalg_QR_Rsvx; break; /* case LINALG_R_SVX: if (CLASS_OF(omatrix) != cgsl_matrix_QR) { QR = make_matrix_clone(mtmp); tau = gsl_vector_alloc(QR->size1); gsl_linalg_QR_decomp(QR, tau); flagq = 1; } fsolve = &gsl_linalg_R_svx; break; */ #ifdef GSL_1_6_LATER case LINALG_LQ_LSVX: if (CLASS_OF(omatrix) != cgsl_matrix_LQ) { QR = make_matrix_clone(mtmp); tau = gsl_vector_alloc(QR->size1); gsl_linalg_LQ_decomp(QR, tau); flagq = 1; } fsolve = &gsl_linalg_LQ_Lsvx_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } (*fsolve)(QR, x); if (flagq == 1) { gsl_matrix_free(QR); gsl_vector_free(tau); } return retval; } static VALUE rb_gsl_linalg_QR_Rsolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_RLsolve(argc, argv, obj, LINALG_QR_RSOLVE); } static VALUE rb_gsl_linalg_QR_Rsvx(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_RLsvx(argc, argv, obj, LINALG_QR_RSVX); } static VALUE rb_gsl_linalg_R_solve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_RLsolve(argc, argv, obj, LINALG_R_SOLVE); } /* singleton */ static VALUE rb_gsl_linalg_QR_QRsolve(int argc, VALUE *argv, VALUE obj, int flag) { return rb_gsl_linalg_QRLQ_QRLQsolve(argc, argv, obj, LINALG_QR_DECOMP); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_LQ_Lsolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_RLsolve(argc, argv, obj, LINALG_LQ_LSOLVE); } static VALUE rb_gsl_linalg_LQ_Lsvx(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_RLsvx(argc, argv, obj, LINALG_LQ_LSVX); } static VALUE rb_gsl_linalg_L_solve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQ_RLsolve(argc, argv, obj, LINALG_L_SOLVE); } /* singleton */ static VALUE rb_gsl_linalg_LQ_LQsolve(int argc, VALUE *argv, VALUE obj, int flag) { return rb_gsl_linalg_QRLQ_QRLQsolve(argc, argv, obj, LINALG_LQ_DECOMP); } #endif static VALUE rb_gsl_linalg_QRLQ_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww, VALUE vv, int flag) { gsl_matrix *Q = NULL, *R = NULL; gsl_vector *w = NULL, *v = NULL; int status; CHECK_MATRIX(qq); CHECK_MATRIX(rr); CHECK_VECTOR(ww); CHECK_VECTOR(vv); Data_Get_Struct(qq, gsl_matrix, Q); Data_Get_Struct(rr, gsl_matrix, R); Data_Get_Struct(ww, gsl_vector, w); Data_Get_Struct(vv, gsl_vector, v); switch (flag) { case LINALG_QR_DECOMP: status = gsl_linalg_QR_update(Q, R, w, v); break; #ifdef GSL_1_6_LATER case LINALG_LQ_DECOMP: status = gsl_linalg_LQ_update(Q, R, w, v); break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } return INT2FIX(status); } /* singleton */ static VALUE rb_gsl_linalg_QR_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww, VALUE vv) { return rb_gsl_linalg_QRLQ_update(obj, qq, rr, ww, vv, LINALG_QR_DECOMP); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_LQ_update(VALUE obj, VALUE qq, VALUE rr, VALUE ww, VALUE vv) { return rb_gsl_linalg_QRLQ_update(obj, qq, rr, ww, vv, LINALG_LQ_DECOMP); } #endif /******/ enum { LINALG_QRPT, LINALG_PTLQ, }; static VALUE rb_gsl_linalg_QRLQPT_decomp(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *A = NULL, *QR = NULL; gsl_vector *tau = NULL, *norm = NULL; gsl_permutation *p = NULL; int signum; size_t size0; VALUE vtau, vp, vA, vQR; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); vA = argv[0]; break; default: vA = obj; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, A); QR = make_matrix_clone(A); size0 = GSL_MIN(A->size1, A->size2); tau = gsl_vector_alloc(size0); p = gsl_permutation_alloc(size0); norm = gsl_vector_alloc(size0); switch (flag) { case LINALG_QRPT: vQR = Data_Wrap_Struct(cgsl_matrix_QRPT, 0, gsl_matrix_free, QR); vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); gsl_linalg_QRPT_decomp(QR, tau, p, &signum, norm); break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: vQR = Data_Wrap_Struct(cgsl_matrix_PTLQ, 0, gsl_matrix_free, QR); vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); gsl_linalg_PTLQ_decomp(QR, tau, p, &signum, norm); break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } gsl_vector_free(norm); return rb_ary_new3(4, vQR, vtau, vp, INT2FIX(signum)); } static VALUE rb_gsl_linalg_QRLQPT_decomp_bang(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *A = NULL; gsl_vector *tau = NULL, *norm = NULL; gsl_permutation *p = NULL; int signum; size_t size0; VALUE vtau, vp, vA; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); vA = argv[0]; break; default: vA = obj; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, A); size0 = GSL_MIN(A->size1, A->size2); tau = gsl_vector_alloc(size0); p = gsl_permutation_alloc(size0); norm = gsl_vector_alloc(size0); switch (flag) { case LINALG_QRPT: RBASIC(vA)->klass = cgsl_matrix_QRPT; vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); gsl_linalg_QRPT_decomp(A, tau, p, &signum, norm); break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: RBASIC(vA)->klass = cgsl_matrix_PTLQ; vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); gsl_linalg_PTLQ_decomp(A, tau, p, &signum, norm); break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } gsl_vector_free(norm); return rb_ary_new3(3, vtau, vp, INT2FIX(signum)); } static VALUE rb_gsl_linalg_QRPT_decomp(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_decomp(argc, argv, obj, LINALG_QRPT); } static VALUE rb_gsl_linalg_QRPT_decomp_bang(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_decomp_bang(argc, argv, obj, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_decomp(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_decomp(argc, argv, obj, LINALG_PTLQ); } static VALUE rb_gsl_linalg_PTLQ_decomp_bang(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_decomp_bang(argc, argv, obj, LINALG_PTLQ); } #endif static VALUE rb_gsl_linalg_QRLQPT_decomp2(int argc, VALUE *argv, VALUE obj,int flag) { gsl_matrix *A = NULL, *Q = NULL, *R = NULL; gsl_vector *tau = NULL, *norm = NULL; gsl_permutation *p = NULL; int signum; size_t size0; VALUE vtau, vp, vA, vQ, vR; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments"); vA = argv[0]; break; default: if (argc != 0) rb_raise(rb_eArgError, "wrong number of arguments"); vA = obj; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, A); Q = gsl_matrix_alloc(A->size1, A->size2); R = gsl_matrix_alloc(A->size1, A->size2); size0 = GSL_MIN(A->size1, A->size2); tau = gsl_vector_alloc(size0); p = gsl_permutation_alloc(size0); norm = gsl_vector_alloc(size0); /* vQ = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, Q); vR = Data_Wrap_Struct(cgsl_matrix_R, 0, gsl_matrix_free, R);*/ vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); vp = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); switch (flag) { case LINALG_QRPT: vQ = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, Q); vR = Data_Wrap_Struct(cgsl_matrix_R, 0, gsl_matrix_free, R); gsl_linalg_QRPT_decomp2(A, Q, R, tau, p, &signum, norm); break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: vR = Data_Wrap_Struct(cgsl_matrix_L, 0, gsl_matrix_free, R); vQ = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, Q); gsl_linalg_PTLQ_decomp2(A, Q, R, tau, p, &signum, norm); break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); } gsl_vector_free(norm); return rb_ary_new3(5, vQ, vR, vtau, vp, INT2FIX(signum)); } static VALUE rb_gsl_linalg_QRPT_decomp2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_decomp2(argc, argv, obj, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_decomp2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_decomp2(argc, argv, obj, LINALG_PTLQ); } #endif #ifdef GSL_1_6_LATER int gsl_linalg_PTLQ_solve_T(const gsl_matrix * QR, const gsl_vector * tau, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x); int gsl_linalg_PTLQ_svx_T(const gsl_matrix * LQ, const gsl_vector * tau, const gsl_permutation * p, gsl_vector * x); int gsl_linalg_PTLQ_LQsolve_T (const gsl_matrix * Q, const gsl_matrix * L, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x); int gsl_linalg_PTLQ_Lsolve_T (const gsl_matrix * LQ, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x); int gsl_linalg_PTLQ_Lsvx_T (const gsl_matrix * LQ, const gsl_permutation * p, gsl_vector * x); #endif static VALUE rb_gsl_linalg_QRLQPT_solve(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL, *A = NULL; gsl_vector *tau = NULL, *b = NULL, *x = NULL, *norm = NULL; gsl_permutation *p = NULL; int signum, itmp, flagb = 0, flagq = 0; VALUE vtmp, klass; size_t size0; int (*fdecomp)(gsl_matrix*, gsl_vector*, gsl_permutation*, int *, gsl_vector*); int (*fsolve)(const gsl_matrix*, const gsl_vector*, const gsl_permutation*, const gsl_vector*, gsl_vector *); switch (flag) { case LINALG_QRPT: klass = cgsl_matrix_QRPT; fdecomp = &gsl_linalg_QRPT_decomp; fsolve = &gsl_linalg_QRPT_solve; break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: klass = cgsl_matrix_PTLQ; fdecomp = &gsl_linalg_PTLQ_decomp; fsolve = &gsl_linalg_PTLQ_solve_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); vtmp = argv[0]; itmp = 1; break; default: vtmp = obj; itmp = 0; break; } CHECK_MATRIX(vtmp); if (CLASS_OF(vtmp) == klass) { if (argc-itmp != 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, 4-itmp); CHECK_VECTOR(argv[itmp]); if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) rb_raise(rb_eTypeError, "not a tau vector"); CHECK_PERMUTATION(argv[itmp+1]); Data_Get_Struct(argv[itmp], gsl_vector, tau); Data_Get_Struct(argv[itmp+1], gsl_permutation, p); Data_Get_Struct(vtmp, gsl_matrix, QR); size0 = GSL_MIN(QR->size1, QR->size2); itmp += 2; } else { if (argc-itmp != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, 2-itmp); Data_Get_Struct(vtmp, gsl_matrix, A); QR = make_matrix_clone(A); size0 = GSL_MIN(QR->size1, QR->size2); flagq = 1; p = gsl_permutation_alloc(size0); tau = gsl_vector_alloc(size0); } norm = gsl_vector_alloc(size0); if (TYPE(argv[itmp]) == T_ARRAY) { b = make_cvector_from_rarray(argv[itmp]); flagb = 1; } else { CHECK_VECTOR(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_vector, b); } x = gsl_vector_alloc(b->size); if (flagq == 1) (*fdecomp)(QR, tau, p, &signum, norm); (*fsolve)(QR, tau, p, b, x); if (flagb == 1) gsl_vector_free(b); if (flagq == 1) { gsl_matrix_free(QR); gsl_permutation_free(p); gsl_vector_free(tau); gsl_vector_free(norm); } return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_QRPT_solve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_solve(argc, argv, obj, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_solve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_solve(argc, argv, obj, LINALG_PTLQ); } #endif static VALUE rb_gsl_linalg_QRLQPT_svx(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL, *A = NULL; gsl_vector *tau = NULL, *b = NULL, *norm = NULL; gsl_permutation *p = NULL; int signum, itmp, flagq = 0; VALUE vtmp, klass; size_t size0; int (*fdecomp)(gsl_matrix*, gsl_vector*, gsl_permutation*, int *, gsl_vector*); int (*fsvx)(const gsl_matrix*, const gsl_vector*, const gsl_permutation*, gsl_vector *); switch (flag) { case LINALG_QRPT: klass = cgsl_matrix_QRPT; fdecomp = &gsl_linalg_QRPT_decomp; fsvx = &gsl_linalg_QRPT_svx; break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: klass = cgsl_matrix_PTLQ; fdecomp = &gsl_linalg_PTLQ_decomp; fsvx = &gsl_linalg_PTLQ_svx_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); vtmp = argv[0]; itmp = 1; break; default: vtmp = obj; itmp = 0; break; } CHECK_MATRIX(vtmp); if (CLASS_OF(vtmp) == klass) { if (argc-itmp != 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, 3+itmp); CHECK_VECTOR(argv[itmp]); if (CLASS_OF(argv[itmp]) != cgsl_vector_tau) rb_raise(rb_eTypeError, "not a tau vector"); CHECK_PERMUTATION(argv[itmp+1]); Data_Get_Struct(argv[itmp], gsl_vector, tau); Data_Get_Struct(argv[itmp+1], gsl_permutation, p); Data_Get_Struct(vtmp, gsl_matrix, QR); size0 = GSL_MIN(QR->size1, QR->size2); itmp += 2; } else { if (argc-itmp != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, 2+itmp); Data_Get_Struct(vtmp, gsl_matrix, A); QR = make_matrix_clone(A); size0 = GSL_MIN(QR->size1, QR->size2); flagq = 1; p = gsl_permutation_alloc(size0); tau = gsl_vector_alloc(size0); } norm = gsl_vector_alloc(size0); CHECK_VECTOR(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_vector, b); if (flagq == 1) (*fdecomp)(QR, tau, p, &signum, norm); (*fsvx)(QR, tau, p, b); if (flagq == 1) { gsl_matrix_free(QR); gsl_permutation_free(p); gsl_vector_free(tau); gsl_vector_free(norm); } return argv[itmp]; } static VALUE rb_gsl_linalg_QRPT_svx(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_svx(argc, argv, obj, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_svx(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_svx(argc, argv, obj, LINALG_PTLQ); } #endif /* singleton */ static VALUE rb_gsl_linalg_QRLQPT_QRLQsolve(VALUE obj, VALUE qq, VALUE rr, VALUE pp, VALUE bb, int flag) { gsl_matrix *Q = NULL, *R = NULL; gsl_vector *b = NULL, *x = NULL; gsl_permutation *p = NULL; int flagb = 0; int (*fsolve)(const gsl_matrix*, const gsl_matrix*, const gsl_permutation*, const gsl_vector*, gsl_vector*); switch (flag) { case LINALG_QRPT: if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix"); if (CLASS_OF(rr) != cgsl_matrix_R) rb_raise(rb_eTypeError, "not a R matrix"); fsolve = &gsl_linalg_QRPT_QRsolve; break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix"); if (CLASS_OF(rr) != cgsl_matrix_L) rb_raise(rb_eTypeError, "not a L matrix"); fsolve = &gsl_linalg_PTLQ_LQsolve_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } if (TYPE(bb) == T_ARRAY) { b = make_cvector_from_rarray(bb); flagb = 1; } else { CHECK_VECTOR(bb); Data_Get_Struct(bb, gsl_vector, b); } CHECK_PERMUTATION(pp); Data_Get_Struct(qq, gsl_matrix, Q); Data_Get_Struct(rr, gsl_matrix, R); Data_Get_Struct(pp, gsl_permutation, p); x = gsl_vector_alloc(b->size); (*fsolve)(Q, R, p, b, x); if (flagb == 1) gsl_vector_free(b); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_QRPT_QRsolve(VALUE obj, VALUE qq, VALUE rr, VALUE pp, VALUE bb) { return rb_gsl_linalg_QRLQPT_QRLQsolve(obj, qq, rr, pp, bb, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_LQsolve(VALUE obj, VALUE qq, VALUE rr, VALUE pp, VALUE bb) { return rb_gsl_linalg_QRLQPT_QRLQsolve(obj, qq, rr, pp, bb, LINALG_PTLQ); } #endif /* singleton */ static VALUE rb_gsl_linalg_QRLQPT_update(VALUE obj, VALUE qq, VALUE rr, VALUE pp, VALUE ww, VALUE vv, int flag) { gsl_matrix *Q = NULL, *R = NULL; gsl_vector *w = NULL, *v = NULL; gsl_permutation *p = NULL; switch (flag) { case LINALG_QRPT: if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix"); if (CLASS_OF(rr) != cgsl_matrix_R) rb_raise(rb_eTypeError, "not a R matrix"); break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: if (CLASS_OF(qq) != cgsl_matrix_Q) rb_raise(rb_eTypeError, "not a Q matrix"); if (CLASS_OF(rr) != cgsl_matrix_L) rb_raise(rb_eTypeError, "not a L matrix"); break; #endif } CHECK_PERMUTATION(pp); Data_Get_Struct(qq, gsl_matrix, Q); Data_Get_Struct(rr, gsl_matrix, R); Data_Get_Struct(pp, gsl_permutation, p); Data_Get_Struct(ww, gsl_vector, w); Data_Get_Struct(vv, gsl_vector, v); switch (flag) { case LINALG_QRPT: gsl_linalg_QRPT_update(Q, R, p, w, v); break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: gsl_linalg_PTLQ_update(Q, R, p, w, v); break; #endif } return obj; } static VALUE rb_gsl_linalg_QRPT_update(VALUE obj, VALUE qq, VALUE rr, VALUE pp, VALUE ww, VALUE vv) { return rb_gsl_linalg_QRLQPT_update(obj, qq, rr, pp, ww, vv, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_update(VALUE obj, VALUE qq, VALUE rr, VALUE pp, VALUE ww, VALUE vv) { return rb_gsl_linalg_QRLQPT_update(obj, qq, rr, pp, ww, vv, LINALG_PTLQ); } #endif static VALUE rb_gsl_linalg_QRLQPT_RLsolve(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL; gsl_vector *b = NULL, *x = NULL; gsl_permutation *p = NULL; int itmp, flagb = 0; VALUE vtmp, klass; int (*fsolve)(const gsl_matrix*, const gsl_permutation*, const gsl_vector*, gsl_vector*); switch (flag) { case LINALG_QRPT: klass = cgsl_matrix_QRPT; fsolve = &gsl_linalg_QRPT_Rsolve; break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: klass = cgsl_matrix_PTLQ; fsolve = &gsl_linalg_PTLQ_Lsolve_T; break; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); vtmp = argv[0]; itmp = 1; break; default: vtmp = obj; itmp = 0; break; } if (argc-itmp != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for %d)", argc, 2+itmp); CHECK_MATRIX(vtmp); if (CLASS_OF(vtmp) != klass) { rb_raise(rb_eArgError, "not a QR matrix"); } CHECK_PERMUTATION(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_permutation, p); Data_Get_Struct(vtmp, gsl_matrix, QR); itmp++; if (TYPE(argv[itmp]) == T_ARRAY) { b = make_cvector_from_rarray(argv[itmp]); flagb = 1; } else { CHECK_VECTOR(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_vector, b); } x = gsl_vector_alloc(b->size); (*fsolve)(QR, p, b, x); if (flagb == 1) gsl_vector_free(b); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_QRPT_Rsolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_RLsolve(argc, argv, obj, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_Lsolve(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_RLsolve(argc, argv, obj, LINALG_PTLQ); } #endif static VALUE rb_gsl_linalg_QRLQPT_RLsvx(int argc, VALUE *argv, VALUE obj, int flag) { gsl_matrix *QR = NULL; gsl_vector *b = NULL; gsl_permutation *p = NULL; int itmp; VALUE vtmp, klass; int (*fsvx)(const gsl_matrix*, const gsl_permutation*, gsl_vector*); switch (flag) { case LINALG_QRPT: klass = cgsl_matrix_QRPT; fsvx = &gsl_linalg_QRPT_Rsvx; break; #ifdef GSL_1_6_LATER case LINALG_PTLQ: klass = cgsl_matrix_PTLQ; fsvx = &gsl_linalg_PTLQ_Lsvx_T; #endif default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); vtmp = argv[0]; itmp = 1; break; default: vtmp = obj; itmp = 0; break; } if (argc-itmp != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for %d)", argc, 2+itmp); CHECK_MATRIX(vtmp); if (CLASS_OF(vtmp) != klass) { rb_raise(rb_eArgError, "not a QR matrix"); } CHECK_PERMUTATION(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_permutation, p); Data_Get_Struct(vtmp, gsl_matrix, QR); itmp++; if (TYPE(argv[itmp]) == T_ARRAY) { b = make_cvector_from_rarray(argv[itmp]); } else { CHECK_VECTOR(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_vector, b); } (*fsvx)(QR, p, b); return argv[itmp]; } static VALUE rb_gsl_linalg_QRPT_Rsvx(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_RLsvx(argc, argv, obj, LINALG_QRPT); } #ifdef GSL_1_6_LATER static VALUE rb_gsl_linalg_PTLQ_Lsvx(int argc, VALUE *argv, VALUE obj) { return rb_gsl_linalg_QRLQPT_RLsvx(argc, argv, obj, LINALG_PTLQ); } #endif /*******/ #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_SV_decomp_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *A; gsl_matrix_view uv, vv; gsl_vector_view sv; gsl_vector *work; VALUE u, s, v; int shape[2]; GetNArray(argv[0], A); shape[0] = A->shape[0]; shape[1] = A->shape[0]; u = na_make_object(NA_DFLOAT, 2, A->shape, CLASS_OF(argv[0])); v = na_make_object(NA_DFLOAT, 2, shape, CLASS_OF(argv[0])); s = na_make_object(NA_DFLOAT, 1, &(shape[0]), cNVector); uv = gsl_matrix_view_array(NA_PTR_TYPE(u,double*), A->shape[1], A->shape[0]); vv = gsl_matrix_view_array(NA_PTR_TYPE(v,double*), shape[1], shape[0]); sv = gsl_vector_view_array(NA_PTR_TYPE(s,double*), shape[0]); work = gsl_vector_alloc(shape[0]); memcpy(NA_PTR_TYPE(u,double*), (double*)A->ptr, sizeof(double)*A->total); gsl_linalg_SV_decomp(&uv.matrix, &vv.matrix, &sv.vector, work); gsl_vector_free(work); return rb_ary_new3(3, u, v, s); } static VALUE rb_gsl_linalg_SV_decomp_jacobi_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *A; gsl_matrix_view uv, vv; gsl_vector_view sv; VALUE u, s, v; int shape[2]; GetNArray(argv[0], A); shape[0] = A->shape[0]; shape[1] = A->shape[0]; u = na_make_object(NA_DFLOAT, 2, A->shape, CLASS_OF(argv[0])); v = na_make_object(NA_DFLOAT, 2, shape, CLASS_OF(argv[0])); s = na_make_object(NA_DFLOAT, 1, &(shape[0]), cNVector); uv = gsl_matrix_view_array(NA_PTR_TYPE(u,double*), A->shape[1], A->shape[0]); vv = gsl_matrix_view_array(NA_PTR_TYPE(v,double*), shape[1], shape[0]); sv = gsl_vector_view_array(NA_PTR_TYPE(s,double*), shape[0]); memcpy(NA_PTR_TYPE(u,double*), (double*)A->ptr, sizeof(double)*A->total); gsl_linalg_SV_decomp_jacobi(&uv.matrix, &vv.matrix, &sv.vector); return rb_ary_new3(3, u, v, s); } static VALUE rb_gsl_linalg_SV_solve_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *A; gsl_matrix_view uv, vv; gsl_vector_view sv, bv, xv; VALUE x; if (argc != 4) rb_raise(rb_eArgError, "Usage: SV.solve(u, v, s, b)"); GetNArray(argv[0], A); uv = gsl_matrix_view_array(NA_PTR_TYPE(argv[0],double*), A->shape[1], A->shape[0]); vv = gsl_matrix_view_array(NA_PTR_TYPE(argv[1],double*), A->shape[0], A->shape[0]); sv = gsl_vector_view_array(NA_PTR_TYPE(argv[2],double*), A->shape[0]); bv = gsl_vector_view_array(NA_PTR_TYPE(argv[3],double*), A->shape[0]); x = na_make_object(NA_DFLOAT, 1, &(A->shape[0]), CLASS_OF(argv[3])); xv = gsl_vector_view_array(NA_PTR_TYPE(x,double*), A->shape[0]); gsl_linalg_SV_solve(&uv.matrix, &vv.matrix, &sv.vector, &bv.vector, &xv.vector); return x; } #endif static VALUE rb_gsl_linalg_SV_decomp(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *V = NULL, *U = NULL; gsl_vector *w = NULL, *S = NULL; int flag = 1; VALUE vs, vv, vu; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, w); flag = 0; /* no break, do next */ case 1: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_SV_decomp_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } break; default: switch (argc) { case 0: /* do nothing */ break; case 1: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, w); flag = 0; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } Data_Get_Struct(obj, gsl_matrix, A); break; } U = make_matrix_clone(A); S = gsl_vector_alloc(A->size2); /* see manual p 123 */ V = gsl_matrix_alloc(A->size2, A->size2); if (flag == 1) w = gsl_vector_alloc(A->size2); gsl_linalg_SV_decomp(U, V, S, w); if (flag == 1) gsl_vector_free(w); vu = Data_Wrap_Struct(cgsl_matrix_U, 0, gsl_matrix_free, U); vv = Data_Wrap_Struct(cgsl_matrix_V, 0, gsl_matrix_free, V); vs = Data_Wrap_Struct(cgsl_vector_S, 0, gsl_vector_free, S); return rb_ary_new3(3, vu, vv, vs); } static VALUE rb_gsl_linalg_SV_decomp_mod(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *V = NULL, *U = NULL, *X = NULL; gsl_vector *w = NULL, *S = NULL; VALUE vs, vv, vu; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); break; default: Data_Get_Struct(obj, gsl_matrix, A); break; } U = make_matrix_clone(A); S = gsl_vector_alloc(A->size2); /* see manual p 123 */ V = gsl_matrix_alloc(A->size2, A->size2); X = gsl_matrix_alloc(A->size2, A->size2); w = gsl_vector_alloc(A->size2); gsl_linalg_SV_decomp_mod(U, X, V, S, w); gsl_vector_free(w); gsl_matrix_free(X); vu = Data_Wrap_Struct(cgsl_matrix_U, 0, gsl_matrix_free, U); vv = Data_Wrap_Struct(cgsl_matrix_V, 0, gsl_matrix_free, V); vs = Data_Wrap_Struct(cgsl_vector_S, 0, gsl_vector_free, S); return rb_ary_new3(3, vu, vv, vs); } static VALUE rb_gsl_linalg_SV_decomp_jacobi(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *V = NULL, *U = NULL; gsl_vector *S = NULL; VALUE vs, vv, vu; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_SV_decomp_jacobi_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); break; default: Data_Get_Struct(obj, gsl_matrix, A); break; } U = make_matrix_clone(A); S = gsl_vector_alloc(A->size2); /* see manual p 123 */ V = gsl_matrix_alloc(A->size2, A->size2); gsl_linalg_SV_decomp_jacobi(U, V, S); vu = Data_Wrap_Struct(cgsl_matrix_U, 0, gsl_matrix_free, U); vv = Data_Wrap_Struct(cgsl_matrix_V, 0, gsl_matrix_free, V); vs = Data_Wrap_Struct(cgsl_vector_S, 0, gsl_vector_free, S); return rb_ary_new3(3, vu, vv, vs); } static VALUE rb_gsl_linalg_SV_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *U = NULL, *V = NULL; gsl_vector *S = NULL, *b = NULL, *x = NULL; int flagb = 0, flagv = 0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_SV_solve_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); if (CLASS_OF(argv[0]) == cgsl_matrix_U) { if (argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); Data_Get_Struct(argv[0], gsl_matrix, U); CHECK_MATRIX(argv[1]); if (CLASS_OF(argv[1]) != cgsl_matrix_V) rb_raise(rb_eTypeError, "not a V matrix"); Data_Get_Struct(argv[1], gsl_matrix, V); CHECK_VECTOR(argv[2]); if (CLASS_OF(argv[2]) != cgsl_vector_S) rb_raise(rb_eTypeError, "not a S vector"); Data_Get_Struct(argv[2], gsl_vector, S); if (TYPE(argv[3]) == T_ARRAY) { b = make_cvector_from_rarray(argv[3]); flagb = 1; } else { CHECK_VECTOR(argv[3]); Data_Get_Struct(argv[3], gsl_vector, b); } } else { if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); Data_Get_Struct(argv[0], gsl_matrix, A); U = make_matrix_clone(A); if (TYPE(argv[1]) == T_ARRAY) { b = make_cvector_from_rarray(argv[1]); flagb = 1; } else { CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, b); } S = gsl_vector_alloc(A->size2); /* see manual p 123 */ V = gsl_matrix_alloc(A->size2, A->size2); gsl_linalg_SV_decomp_jacobi(U, V, S); flagv = 1; } break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Data_Get_Struct(obj, gsl_matrix, A); U = make_matrix_clone(A); if (TYPE(argv[0]) == T_ARRAY) { b = make_cvector_from_rarray(argv[0]); flagb = 1; } else { CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, b); } S = gsl_vector_alloc(A->size2); /* see manual p 123 */ V = gsl_matrix_alloc(A->size2, A->size2); gsl_linalg_SV_decomp_jacobi(U, V, S); flagv = 1; break; } // x = gsl_vector_alloc(b->size); // Bug report #25842 x = gsl_vector_alloc(S->size); gsl_linalg_SV_solve(U, V, S, b, x); if (flagv == 1) { gsl_matrix_free(U); gsl_matrix_free(V); gsl_vector_free(S); } if (flagb == 1) gsl_vector_free(b); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } /*****/ #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_cholesky_decomp_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; VALUE chol; gsl_matrix_view mv; GetNArray(argv[0], na); chol = na_make_object(NA_DFLOAT, 2, na->shape, CLASS_OF(argv[0])); memcpy(NA_PTR_TYPE(chol,double*), (double*)na->ptr, sizeof(double)*na->total); mv = gsl_matrix_view_array(NA_PTR_TYPE(chol,double*), na->shape[1], na->shape[0]); gsl_linalg_cholesky_decomp(&mv.matrix); return chol; } static VALUE rb_gsl_linalg_cholesky_solve_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *nm, *nb; VALUE x; gsl_matrix_view mv; gsl_vector_view bv, xv; switch (argc) { case 2: GetNArray(argv[0], nm); GetNArray(argv[1], nb); x = na_make_object(NA_DFLOAT, 1, nb->shape, CLASS_OF(argv[1])); break; case 3: GetNArray(argv[0], nm); GetNArray(argv[1], nb); x = argv[2]; break; default: rb_raise(rb_eArgError, "Usage: Cholesky.solve(chol, b) or Cholesky.solve(chol, b, x)"); break; } mv = gsl_matrix_view_array((double*)nm->ptr, nm->shape[1], nm->shape[0]); bv = gsl_vector_view_array((double*)nb->ptr, nb->shape[0]); xv = gsl_vector_view_array(NA_PTR_TYPE(x,double*), nb->shape[0]); gsl_linalg_cholesky_solve(&mv.matrix, &bv.vector, &xv.vector); return x; } static VALUE rb_gsl_linalg_cholesky_svx_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *nm, *nb; gsl_matrix_view mv; gsl_vector_view bv; GetNArray(argv[0], nm); GetNArray(argv[1], nb); mv = gsl_matrix_view_array((double*)nm->ptr, nm->shape[1], nm->shape[0]); bv = gsl_vector_view_array((double*)nb->ptr, nb->shape[0]); gsl_linalg_cholesky_svx(&mv.matrix, &bv.vector); return argv[1]; } #endif static VALUE rb_gsl_linalg_cholesky_decomp(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Atmp = NULL; switch(TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_cholesky_decomp_narray(argc, argv, obj); #endif CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, Atmp); break; default: CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, Atmp); break; } A = make_matrix_clone(Atmp); gsl_linalg_cholesky_decomp(A); return Data_Wrap_Struct(cgsl_matrix_C, 0, gsl_matrix_free, A); } static VALUE rb_gsl_linalg_cholesky_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Atmp = NULL; gsl_vector *b = NULL, *x = NULL; int flagb = 0, flaga = 0; VALUE vA, vb; switch(TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_cholesky_solve_narray(argc, argv, obj); #endif vA = argv[0]; vb = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); vA = obj; vb = argv[0]; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, Atmp); if (TYPE(vb) == T_ARRAY) { b = make_cvector_from_rarray(vb); flagb = 1; } else { CHECK_VECTOR(vb); Data_Get_Struct(vb, gsl_vector, b); } if (CLASS_OF(vA) == cgsl_matrix_C) { A = Atmp; } else { A = make_matrix_clone(Atmp); flaga = 1; gsl_linalg_cholesky_decomp(A); } x = gsl_vector_alloc(b->size); gsl_linalg_cholesky_solve(A, b, x); if (flaga == 1) gsl_matrix_free(A); if (flagb == 1) gsl_vector_free(b); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_cholesky_svx(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Atmp = NULL; gsl_vector *b = NULL; int flaga = 0; VALUE vA, vb; switch(TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_cholesky_svx_narray(argc, argv, obj); #endif vA = argv[0]; vb = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); vA = obj; vb = argv[0]; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, Atmp); CHECK_VECTOR(vb); Data_Get_Struct(vb, gsl_vector, b); if (CLASS_OF(vA) == cgsl_matrix_C) { A = Atmp; } else { A = make_matrix_clone(Atmp); flaga = 1; gsl_linalg_cholesky_decomp(A); } gsl_linalg_cholesky_svx(A, b); if (flaga == 1) gsl_matrix_free(A); return vb; } static VALUE rb_gsl_linalg_symmtd_decomp(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Atmp = NULL; gsl_vector *tau = NULL; VALUE vQ, vtau; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, Atmp); break; default: CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, Atmp); break; } A = make_matrix_clone(Atmp); tau = gsl_vector_alloc(A->size1); gsl_linalg_symmtd_decomp(A, tau); vQ = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, A); vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); return rb_ary_new3(2, vQ, vtau); } static VALUE rb_gsl_linalg_symmtd_decomp2(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *tau = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); break; default: CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, A); break; } tau = gsl_vector_alloc(A->size1); gsl_linalg_symmtd_decomp(A, tau); return Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); } static VALUE rb_gsl_linalg_symmtd_unpack(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Q = NULL; gsl_vector *tau = NULL, *d = NULL, *sd = NULL; VALUE vq, vd, vsd; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_vector, tau); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, A); Data_Get_Struct(argv[0], gsl_vector, tau); break; } Q = gsl_matrix_alloc(A->size1, A->size2); d = gsl_vector_alloc(tau->size); sd = gsl_vector_alloc(tau->size); gsl_linalg_symmtd_unpack(A, tau, Q, d, sd); vq = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, Q); vd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, d); vsd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, sd); return rb_ary_new3(3, vq, vd, vsd); } static VALUE rb_gsl_linalg_symmtd_unpack_T(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *d = NULL, *sd = NULL; VALUE vd, vsd; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); break; default: Data_Get_Struct(obj, gsl_matrix, A); break; } d = gsl_vector_alloc(A->size1); sd = gsl_vector_alloc(A->size1); gsl_linalg_symmtd_unpack_T(A, d, sd); vd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, d); vsd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, sd); return rb_ary_new3(2, vd, vsd); } /*****/ static VALUE rb_gsl_linalg_hermtd_decomp(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *Atmp = NULL; gsl_vector_complex *tau = NULL; VALUE vQ, vtau; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, Atmp); break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, Atmp); break; } A = make_matrix_complex_clone(Atmp); tau = gsl_vector_complex_alloc(A->size1); gsl_linalg_hermtd_decomp(A, tau); vQ = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, A); vtau = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, tau); return rb_ary_new3(2, vQ, vtau); } static VALUE rb_gsl_linalg_hermtd_decomp2(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector_complex *tau = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, A); break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, A); break; } tau = gsl_vector_complex_alloc(A->size1); gsl_linalg_hermtd_decomp(A, tau); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, tau); } static VALUE rb_gsl_linalg_hermtd_unpack(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *Q = NULL; gsl_vector_complex *tau = NULL; gsl_vector *d = NULL, *sd = NULL; VALUE vq, vd, vsd; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, A); Data_Get_Struct(argv[1], gsl_vector_complex, tau); break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, A); Data_Get_Struct(argv[0], gsl_vector_complex, tau); break; } Q = gsl_matrix_complex_alloc(A->size1, A->size2); d = gsl_vector_alloc(tau->size); sd = gsl_vector_alloc(tau->size); gsl_linalg_hermtd_unpack(A, tau, Q, d, sd); vq = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Q); vd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, d); vsd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, sd); return rb_ary_new3(3, vq, vd, vsd); } static VALUE rb_gsl_linalg_hermtd_unpack_T(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; gsl_vector *d = NULL, *sd = NULL; VALUE vd, vsd; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, A); break; default: Data_Get_Struct(obj, gsl_matrix_complex, A); break; } d = gsl_vector_alloc(A->size1); sd = gsl_vector_alloc(A->size1); gsl_linalg_hermtd_unpack_T(A, d, sd); vd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, d); vsd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, sd); return rb_ary_new3(2, vd, vsd); } /******/ static VALUE rb_gsl_linalg_bidiag_decomp(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Atmp = NULL; gsl_vector *tau_U = NULL, *tau_V = NULL; size_t size0; // local variable "status" was defined and set, but never used //int status; VALUE vu, vv, vA; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Data_Get_Struct(argv[0], gsl_matrix, Atmp); break; default: Data_Get_Struct(obj, gsl_matrix, Atmp); break; } A = make_matrix_clone(Atmp); size0 = GSL_MIN(A->size1, A->size2); tau_U = gsl_vector_alloc(size0); tau_V = gsl_vector_alloc(size0-1); /*status =*/ gsl_linalg_bidiag_decomp(A, tau_U, tau_V); vA = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, A); vu = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, tau_U); vv = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, tau_V); return rb_ary_new3(3, vA, vu, vv); } static VALUE rb_gsl_linalg_bidiag_decomp2(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *tau_U = NULL, *tau_V = NULL; size_t size0; VALUE vu, vv; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); Data_Get_Struct(argv[0], gsl_matrix, A); break; default: Data_Get_Struct(obj, gsl_matrix, A); break; } size0 = GSL_MIN(A->size1, A->size2); tau_U = gsl_vector_alloc(size0); tau_V = gsl_vector_alloc(size0-1); gsl_linalg_bidiag_decomp(A, tau_U, tau_V); vu = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, tau_U); vv = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, tau_V); return rb_ary_new3(2, vu, vv); } static VALUE rb_gsl_linalg_bidiag_unpack(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *U = NULL, *V = NULL; gsl_vector *tau_U = NULL, *tau_V = NULL, *d = NULL, *s = NULL; size_t size0; VALUE vu, vv, vd, vs; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_vector, tau_U); Data_Get_Struct(argv[2], gsl_vector, tau_V); break; default: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_MATRIX(obj); CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(obj, gsl_matrix, A); Data_Get_Struct(argv[0], gsl_vector, tau_U); Data_Get_Struct(argv[1], gsl_vector, tau_V); break; } size0 = GSL_MIN(A->size1, A->size2); U = gsl_matrix_alloc(A->size1, A->size2); V = gsl_matrix_alloc(size0, size0); d = gsl_vector_alloc(size0); s = gsl_vector_alloc(size0-1); gsl_linalg_bidiag_unpack(A, tau_U, U, tau_V, V, d, s); vu = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, U); vv = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, V); vd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, d); vs = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, s); return rb_ary_new3(4, vu, vv, vd, vs); } static VALUE rb_gsl_linalg_bidiag_unpack2(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *V = NULL; gsl_vector *tau_V = NULL, *tau_U = NULL; VALUE vv; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_vector, tau_U); Data_Get_Struct(argv[2], gsl_vector, tau_V); break; default: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_MATRIX(obj); CHECK_VECTOR(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(obj, gsl_matrix, A); Data_Get_Struct(argv[0], gsl_vector, tau_U); Data_Get_Struct(argv[1], gsl_vector, tau_V); break; } V = gsl_matrix_alloc(A->size2, A->size2); gsl_linalg_bidiag_unpack2(A, tau_U, tau_V, V); vv = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, V); return vv; } static VALUE rb_gsl_linalg_bidiag_unpack_B(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *d = NULL, *s = NULL; size_t size0; VALUE vd, vs; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); break; default: CHECK_MATRIX(obj); Data_Get_Struct(obj, gsl_matrix, A); break; } size0 = GSL_MIN(A->size1, A->size2); d = gsl_vector_alloc(size0); s = gsl_vector_alloc(size0); gsl_linalg_bidiag_unpack_B(A, d, s); vd = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, d); vs = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, s); return rb_ary_new3(2, vd, vs); } /* Householder Transformations 11.Jul.2004 */ static VALUE rb_gsl_linalg_householder_transform(int argc, VALUE *argv, VALUE obj) { gsl_vector *v = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, v); break; default: Data_Get_Struct(obj, gsl_vector, v); break; } return rb_float_new(gsl_linalg_householder_transform(v)); } /* singleton */ static VALUE rb_gsl_linalg_householder_hm(VALUE obj, VALUE t, VALUE vv, VALUE aa) { gsl_vector *v = NULL; double tau; gsl_matrix *A = NULL; CHECK_VECTOR(vv); CHECK_MATRIX(aa); tau = NUM2DBL(t); Data_Get_Struct(vv, gsl_vector, v); Data_Get_Struct(aa, gsl_matrix, A); gsl_linalg_householder_hm(tau, v, A); return aa; } static VALUE rb_gsl_linalg_householder_mh(VALUE obj, VALUE t, VALUE vv, VALUE aa) { gsl_vector *v = NULL; double tau; gsl_matrix *A = NULL; CHECK_VECTOR(vv); CHECK_MATRIX(aa); tau = NUM2DBL(t); Data_Get_Struct(vv, gsl_vector, v); Data_Get_Struct(aa, gsl_matrix, A); gsl_linalg_householder_mh(tau, v, A); return aa; } static VALUE rb_gsl_linalg_householder_hv(VALUE obj, VALUE t, VALUE vv, VALUE ww) { gsl_vector *v = NULL, *w = NULL; double tau; CHECK_VECTOR(vv); CHECK_VECTOR(ww); tau = NUM2DBL(t); Data_Get_Struct(vv, gsl_vector, v); Data_Get_Struct(ww, gsl_vector, w); gsl_linalg_householder_hv(tau, v, w); return ww; } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_HH_solve_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; gsl_vector_view bv, xv; VALUE x; gsl_matrix *mtmp; GetNArray(argv[0], na); bv = gsl_vector_view_array(NA_PTR_TYPE(argv[1],double*), na->shape[1]); x = na_make_object(NA_DFLOAT, 1, &na->shape[1], CLASS_OF(argv[1])); xv = gsl_vector_view_array(NA_PTR_TYPE(x,double*), na->shape[1]); mtmp = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(mtmp->data, (double*)na->ptr, sizeof(double)*na->total); gsl_linalg_HH_solve(mtmp, &bv.vector, &xv.vector); gsl_matrix_free(mtmp); return x; } static VALUE rb_gsl_linalg_HH_svx_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; gsl_matrix *mtmp; gsl_vector_view bv; GetNArray(argv[0], na); bv = gsl_vector_view_array(NA_PTR_TYPE(argv[1],double*), na->shape[1]); mtmp = gsl_matrix_alloc(na->shape[1], na->shape[0]); memcpy(mtmp->data, (double*)na->ptr, sizeof(double)*na->total); gsl_linalg_HH_svx(mtmp, &bv.vector); gsl_matrix_free(mtmp); return argv[1]; } #endif /* 17.Apr.2004 */ static VALUE rb_gsl_linalg_HH_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Atmp = NULL; gsl_vector *b = NULL, *x = NULL; int flagb = 0; VALUE vA, vb; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_HH_solve_narray(argc, argv, obj); #endif vA = argv[0]; vb = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); vA = obj; vb = argv[0]; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, Atmp); if (TYPE(vb) == T_ARRAY) { b = make_cvector_from_rarray(vb); flagb = 1; } else { CHECK_VECTOR(vb); Data_Get_Struct(vb, gsl_vector, b); } A = make_matrix_clone(Atmp); x = gsl_vector_alloc(b->size); gsl_linalg_HH_solve(A, b, x); gsl_matrix_free(A); if (flagb == 1) gsl_vector_free(b); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_HH_solve_bang(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *b = NULL, *x = NULL; int flagb = 0; VALUE vA, vb; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); vA = argv[0]; vb = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); vA = obj; vb = argv[0]; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, A); if (TYPE(vb) == T_ARRAY) { b = make_cvector_from_rarray(vb); flagb = 1; } else { CHECK_VECTOR(vb); Data_Get_Struct(vb, gsl_vector, b); } x = gsl_vector_alloc(b->size); gsl_linalg_HH_solve(A, b, x); if (flagb == 1) gsl_vector_free(b); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_HH_svx(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Atmp = NULL; gsl_vector *b = NULL; VALUE vA, vb; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) return rb_gsl_linalg_HH_svx_narray(argc, argv, obj); #endif vA = argv[0]; vb = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); vA = obj; vb = argv[0]; break; } CHECK_MATRIX(vA); Data_Get_Struct(vA, gsl_matrix, Atmp); CHECK_VECTOR(vb); Data_Get_Struct(vb, gsl_vector, b); A = make_matrix_clone(Atmp); gsl_linalg_HH_svx(A, b); gsl_matrix_free(A); return vb; } static VALUE rb_gsl_linalg_solve_symm_tridiag(VALUE obj, VALUE dd, VALUE ee, VALUE bb) { gsl_vector *b = NULL, *x = NULL, *d = NULL, *e = NULL; Data_Get_Struct(dd, gsl_vector, d); Data_Get_Struct(ee, gsl_vector, e); Data_Get_Struct(bb, gsl_vector, b); x = gsl_vector_alloc(b->size); gsl_linalg_solve_symm_tridiag(d, e, b, x); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } #ifdef GSL_1_2_LATER static VALUE rb_gsl_linalg_solve_tridiag(VALUE obj, VALUE dd, VALUE ee, VALUE ff, VALUE bb) { gsl_vector *b = NULL, *x = NULL, *d = NULL, *e = NULL, *f = NULL; Data_Get_Struct(dd, gsl_vector, d); Data_Get_Struct(ee, gsl_vector, e); Data_Get_Struct(ff, gsl_vector, f); Data_Get_Struct(bb, gsl_vector, b); x = gsl_vector_alloc(b->size); gsl_linalg_solve_tridiag(d, e, f, b, x); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_solve_symm_cyc_tridiag(VALUE obj, VALUE dd, VALUE ee, VALUE bb) { gsl_vector *b = NULL, *x = NULL, *d = NULL, *e = NULL; Data_Get_Struct(dd, gsl_vector, d); Data_Get_Struct(ee, gsl_vector, e); Data_Get_Struct(bb, gsl_vector, b); x = gsl_vector_alloc(b->size); gsl_linalg_solve_symm_cyc_tridiag(d, e, b, x); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } static VALUE rb_gsl_linalg_solve_cyc_tridiag(VALUE obj, VALUE dd, VALUE ee, VALUE ff, VALUE bb) { gsl_vector *b = NULL, *x = NULL, *d = NULL, *e = NULL, *f = NULL; Data_Get_Struct(dd, gsl_vector, d); Data_Get_Struct(ee, gsl_vector, e); Data_Get_Struct(ff, gsl_vector, f); Data_Get_Struct(bb, gsl_vector, b); x = gsl_vector_alloc(b->size); gsl_linalg_solve_cyc_tridiag(d, e, f, b, x); return Data_Wrap_Struct(cgsl_vector_col, 0, gsl_vector_free, x); } #endif static void rb_gsl_linalg_balance_columns_init(int argc, VALUE *argv, VALUE obj, VALUE *mat, VALUE *vec, gsl_matrix **M, gsl_vector **V) { gsl_matrix *A = NULL; gsl_vector *D = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_vector, D); *vec = argv[1]; break; case 1: CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); D = gsl_vector_alloc(A->size2); *vec = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, D); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } *mat = argv[0]; break; default: Data_Get_Struct(obj, gsl_matrix, A); switch (argc) { case 1: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, D); *vec = argv[0]; break; case 0: D = gsl_vector_alloc(A->size2); *vec = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, D); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } *mat = obj; break; } *M = A; *V = D; } static VALUE rb_gsl_linalg_balance_columns_bang(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL; gsl_vector *D = NULL; VALUE mat, vec; // local variable "status" was defined and set, but never used //int status; rb_gsl_linalg_balance_columns_init(argc, argv, obj, &mat, &vec, &A, &D); /*status =*/ gsl_linalg_balance_columns(A, D); return rb_ary_new3(2, mat, vec); } static VALUE rb_gsl_linalg_balance_columns(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *Anew; gsl_vector *D = NULL; VALUE mat, vec; // local variable "status" was defined and set, but never used //int status; rb_gsl_linalg_balance_columns_init(argc, argv, obj, &mat, &vec, &A, &D); Anew = make_matrix_clone(A); mat = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Anew); /*status =*/ gsl_linalg_balance_columns(Anew, D); return rb_ary_new3(2, mat, vec); } #ifdef HAVE_NARRAY_H static VALUE rb_gsl_linalg_QR_decomp_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *na; gsl_matrix_view mv; gsl_vector_view vv; int shapem[2], shapev[1]; VALUE qr, tau; if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); GetNArray(argv[0], na); shapem[0] = na->shape[1]; shapem[1] = na->shape[1]; shapev[0] = shapem[0]; qr = na_make_object(NA_DFLOAT, 2, shapem, CLASS_OF(argv[0])); tau = na_make_object(NA_DFLOAT, 1, shapev, cNVector); memcpy(NA_PTR_TYPE(qr,double*),na->ptr,sizeof(double)*shapem[0]*shapem[1]); mv = gsl_matrix_view_array(NA_PTR_TYPE(qr,double*), shapem[0], shapem[1]); vv = gsl_vector_view_array(NA_PTR_TYPE(tau,double*), shapev[0]); gsl_linalg_QR_decomp(&mv.matrix, &vv.vector); return rb_ary_new3(2, qr, tau); } static VALUE rb_gsl_linalg_QR_unpack_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *m, *tau; gsl_matrix_view mv, mq, mr; gsl_vector_view vv; int shape[2]; VALUE q, r; if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); GetNArray(argv[0], m); GetNArray(argv[1], tau); mv = gsl_matrix_view_array((double*)m->ptr, m->shape[1], m->shape[0]); vv = gsl_vector_view_array((double*)tau->ptr, tau->shape[0]); shape[0] = m->shape[1]; shape[1] = m->shape[1]; q = na_make_object(NA_DFLOAT, 2, shape, CLASS_OF(argv[0])); shape[0] = m->shape[1]; shape[1] = m->shape[0]; r = na_make_object(NA_DFLOAT, 2, shape, CLASS_OF(argv[0])); mq = gsl_matrix_view_array(NA_PTR_TYPE(q,double*), m->shape[1], m->shape[1]); mr = gsl_matrix_view_array(NA_PTR_TYPE(r,double*), m->shape[1], m->shape[0]); // printf("OK 4 %d %d\n", mq.matrix.size1, mr.matrix.size2); gsl_linalg_QR_unpack(&mv.matrix, &vv.vector, &mq.matrix, &mr.matrix); // printf("OK 5\n"); return rb_ary_new3(2, q, r); } static VALUE rb_gsl_linalg_QR_solve_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *qr, *tau, *b; VALUE x; gsl_matrix_view mv; gsl_vector_view tv, bv, xv; if (argc != 3) rb_raise(rb_eArgError, "Usage: QR.solve(qr, tau, b)"); GetNArray(argv[0], qr); GetNArray(argv[1], tau); GetNArray(argv[2], b); x = na_make_object(NA_DFLOAT, 1, b->shape, CLASS_OF(argv[2])); mv = gsl_matrix_view_array((double*)qr->ptr, qr->shape[1], qr->shape[0]); tv = gsl_vector_view_array((double*)tau->ptr, tau->shape[0]); bv = gsl_vector_view_array((double*)b->ptr, b->shape[0]); xv = gsl_vector_view_array(NA_PTR_TYPE(x,double*), b->shape[0]); gsl_linalg_QR_solve(&mv.matrix, &tv.vector, &bv.vector, &xv.vector); return x; } static VALUE rb_gsl_linalg_QR_svx_narray(int argc, VALUE *argv, VALUE obj) { struct NARRAY *qr, *tau, *b; gsl_matrix_view mv; gsl_vector_view tv, bv; if (argc != 3) rb_raise(rb_eArgError, "Usage: QR.solve(qr, tau, b)"); GetNArray(argv[0], qr); GetNArray(argv[1], tau); GetNArray(argv[2], b); mv = gsl_matrix_view_array((double*)qr->ptr, qr->shape[1], qr->shape[0]); tv = gsl_vector_view_array((double*)tau->ptr, tau->shape[0]); bv = gsl_vector_view_array((double*)b->ptr, b->shape[0]); gsl_linalg_QR_svx(&mv.matrix, &tv.vector, &bv.vector); return argv[2]; } #endif #ifdef GSL_1_9_LATER static VALUE rb_gsl_linalg_hessenberg_decomp(VALUE module, VALUE AA) { gsl_matrix *A = NULL, *Atmp = NULL; gsl_vector *tau = NULL; VALUE vH, vtau; CHECK_MATRIX(AA); Data_Get_Struct(AA, gsl_matrix, Atmp); A = make_matrix_clone(Atmp); tau = gsl_vector_alloc(A->size1); gsl_linalg_hessenberg_decomp(A, tau); vH = Data_Wrap_Struct(cgsl_matrix_Q, 0, gsl_matrix_free, A); vtau = Data_Wrap_Struct(cgsl_vector_tau, 0, gsl_vector_free, tau); return rb_ary_new3(2, vH, vtau); } static VALUE rb_gsl_linalg_hessenberg_unpack(VALUE module, VALUE HH, VALUE tt) { gsl_matrix *H = NULL, *U = NULL; gsl_vector *tau = NULL; CHECK_MATRIX(HH); CHECK_VECTOR(tt); Data_Get_Struct(HH, gsl_matrix, H); Data_Get_Struct(tt, gsl_vector, tau); U = gsl_matrix_alloc(H->size1, H->size2); gsl_linalg_hessenberg_unpack(H, tau, U); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, U); } static VALUE rb_gsl_linalg_hessenberg_unpack_accum(int argc, VALUE *argv, VALUE module) { gsl_matrix *H = NULL, *V = NULL; gsl_vector *tau = NULL; size_t i; VALUE val; switch (argc) { case 2: /* nothing to do */ break; case 3: CHECK_MATRIX(argv[2]); Data_Get_Struct(argv[2], gsl_matrix, V); val = argv[2]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 2 or 3)", argc); } CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, H); Data_Get_Struct(argv[1], gsl_vector, tau); if (argc == 2) { V = gsl_matrix_alloc(H->size1, H->size2); val = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, V); for (i = 0; i < V->size1; i++) gsl_matrix_set(V, i, i, 1.0); } gsl_linalg_hessenberg_unpack_accum(H, tau, V); return val; } static VALUE rb_gsl_linalg_hessenberg_set_zero(VALUE module, VALUE HH) { gsl_matrix *H; CHECK_MATRIX(HH); Data_Get_Struct(HH, gsl_matrix, H); return INT2FIX(gsl_linalg_hessenberg_set_zero(H)); /* gsl_linalg_hessenberg_set_zero(H); return INT2FIX(0);*/ } static VALUE rb_gsl_linalg_hesstri_decomp(int argc, VALUE *argv, VALUE module) { gsl_matrix *A = NULL, *B = NULL, *Anew, *Bnew; gsl_matrix *U = NULL, *V = NULL; gsl_vector *work = NULL; VALUE vH, vR, vU, vV, ary; int flag = 0; switch (argc) { case 2: flag = 1; break; case 3: CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, work); break; case 4: CHECK_MATRIX(argv[2]); CHECK_MATRIX(argv[3]); Data_Get_Struct(argv[2], gsl_matrix, U); Data_Get_Struct(argv[3], gsl_matrix, V); flag = 1; break; case 5: CHECK_MATRIX(argv[2]); CHECK_MATRIX(argv[3]); CHECK_VECTOR(argv[4]); Data_Get_Struct(argv[2], gsl_matrix, U); Data_Get_Struct(argv[3], gsl_matrix, V); Data_Get_Struct(argv[4], gsl_vector, work); vU = argv[2]; vV = argv[3]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 2-55)", argc); } CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_matrix, B); Anew = make_matrix_clone(A); Bnew = make_matrix_clone(B); if (flag == 1) work = gsl_vector_alloc(A->size1); gsl_linalg_hesstri_decomp(Anew, Bnew, U, V, work); if (flag == 1) gsl_vector_free(work); vH = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Anew); vR = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Bnew); if (argc == 2 || argc == 3) { ary = rb_ary_new3(2, vH, vR); } else { ary = rb_ary_new3(4, vH, vR, vU, vV); } return ary; } static VALUE rb_gsl_linalg_hesstri_decomp_bang(int argc, VALUE *argv, VALUE module) { gsl_matrix *A = NULL, *B = NULL; gsl_matrix *U = NULL, *V = NULL; gsl_vector *work = NULL; VALUE vH, vR, vU, vV, ary; int flag = 0; switch (argc) { case 2: flag = 1; break; case 3: CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, work); break; case 4: CHECK_MATRIX(argv[2]); CHECK_MATRIX(argv[3]); Data_Get_Struct(argv[2], gsl_matrix, U); Data_Get_Struct(argv[3], gsl_matrix, V); flag = 1; break; case 5: CHECK_MATRIX(argv[2]); CHECK_MATRIX(argv[3]); CHECK_VECTOR(argv[4]); Data_Get_Struct(argv[2], gsl_matrix, U); Data_Get_Struct(argv[3], gsl_matrix, V); Data_Get_Struct(argv[4], gsl_vector, work); vU = argv[2]; vV = argv[3]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 2-55)", argc); } CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_matrix, B); if (flag == 1) work = gsl_vector_alloc(A->size1); gsl_linalg_hesstri_decomp(A, B, U, V, work); if (flag == 1) gsl_vector_free(work); vH = argv[0]; vR = argv[1]; if (argc == 2 || argc == 3) { ary = rb_ary_new3(2, vH, vR); } else { ary = rb_ary_new3(4, vH, vR, vU, vV); } return ary; } static VALUE rb_gsl_linalg_balance_matrix(int argc, VALUE *argv, VALUE module) { gsl_matrix *A, *Anew; gsl_vector *D; VALUE vA, vD; switch (argc) { case 1: CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); Anew = make_matrix_clone(A); D = gsl_vector_alloc(A->size1); vD = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, D); break; case 2: CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_vector, D); Anew = make_matrix_clone(A); vD = argv[1]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)", argc); } gsl_linalg_balance_matrix(Anew, D); vA = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Anew); return rb_ary_new3(2, vA, vD); } static VALUE rb_gsl_linalg_balance_matrix2(int argc, VALUE *argv, VALUE module) { gsl_matrix *A; gsl_vector *D; switch (argc) { case 1: CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix, A); D = gsl_vector_alloc(A->size1); gsl_linalg_balance_matrix(A, D); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, D); break; case 2: CHECK_MATRIX(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_vector, D); return INT2FIX(gsl_linalg_balance_matrix(A, D)); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)", argc); } return Qtrue; } #endif void Init_gsl_linalg_complex(VALUE module); void Init_gsl_linalg(VALUE module) { VALUE mgsl_linalg; VALUE mgsl_linalg_LU; VALUE mgsl_linalg_QR; VALUE mgsl_linalg_QRPT; VALUE mgsl_linalg_LQ; VALUE mgsl_linalg_PTLQ; VALUE mgsl_linalg_SV; VALUE mgsl_linalg_cholesky; VALUE mgsl_linalg_symmtd; VALUE mgsl_linalg_hermtd; VALUE mgsl_linalg_bidiag; VALUE mgsl_linalg_tridiag; VALUE mgsl_linalg_HH; VALUE mgsl_linalg_Householder; mgsl_linalg = rb_define_module_under(module, "Linalg"); mgsl_linalg_LU = rb_define_module_under(mgsl_linalg, "LU"); cgsl_matrix_LU = rb_define_class_under(mgsl_linalg_LU, "LUMatrix", cgsl_matrix); mgsl_linalg_QR = rb_define_module_under(mgsl_linalg, "QR"); mgsl_linalg_QRPT = rb_define_module_under(mgsl_linalg, "QRPT"); cgsl_matrix_QR = rb_define_class_under(mgsl_linalg, "QRMatrix", cgsl_matrix); cgsl_matrix_QRPT = rb_define_class_under(mgsl_linalg, "QRPTMatrix", cgsl_matrix); cgsl_vector_tau = rb_define_class_under(mgsl_linalg, "TauVector", cgsl_vector); cgsl_matrix_Q = rb_define_class_under(mgsl_linalg, "QMatrix", cgsl_matrix); cgsl_matrix_R = rb_define_class_under(mgsl_linalg, "RMatrix", cgsl_matrix); mgsl_linalg_LQ = rb_define_module_under(mgsl_linalg, "LQ"); mgsl_linalg_PTLQ = rb_define_module_under(mgsl_linalg, "PTLQ"); cgsl_matrix_LQ = rb_define_class_under(mgsl_linalg, "LQMatrix", cgsl_matrix); cgsl_matrix_PTLQ = rb_define_class_under(mgsl_linalg, "PTLQMatrix", cgsl_matrix); cgsl_matrix_L = rb_define_class_under(mgsl_linalg, "LMatrix", cgsl_matrix); /*****/ mgsl_linalg_SV = rb_define_module_under(mgsl_linalg, "SV"); cgsl_matrix_SV = rb_define_class_under(mgsl_linalg_SV, "SVMatrix", cgsl_matrix); cgsl_matrix_U = rb_define_class_under(mgsl_linalg_SV, "UMatrix", cgsl_matrix); cgsl_matrix_V = rb_define_class_under(mgsl_linalg_SV, "VMatrix", cgsl_matrix); cgsl_vector_S = rb_define_class_under(mgsl_linalg_SV, "SingularValues", cgsl_vector); /*****/ mgsl_linalg_cholesky = rb_define_module_under(mgsl_linalg, "Cholesky"); cgsl_matrix_C = rb_define_class_under(mgsl_linalg_cholesky, "CholeskyMatrix", cgsl_matrix); mgsl_linalg_symmtd = rb_define_module_under(mgsl_linalg, "Symmtd"); mgsl_linalg_hermtd = rb_define_module_under(mgsl_linalg, "Hermtd"); mgsl_linalg_bidiag = rb_define_module_under(mgsl_linalg, "Bidiag"); mgsl_linalg_tridiag = rb_define_module_under(mgsl_linalg, "Tridiag"); mgsl_linalg_HH = rb_define_module_under(mgsl_linalg, "HH"); mgsl_linalg_Householder = rb_define_module_under(mgsl_linalg, "Householder"); /*****/ rb_define_module_function(mgsl_linalg, "LU_decomp!", rb_gsl_linalg_LU_decomp_bang, -1); rb_define_module_function(mgsl_linalg_LU, "decomp!", rb_gsl_linalg_LU_decomp_bang, -1); rb_define_module_function(mgsl_linalg, "LU_decomp", rb_gsl_linalg_LU_decomp, -1); rb_define_module_function(mgsl_linalg_LU, "decomp", rb_gsl_linalg_LU_decomp, -1); rb_define_method(cgsl_matrix, "LU_decomp!", rb_gsl_linalg_LU_decomp_bang, -1); rb_define_method(cgsl_matrix, "LU_decomp", rb_gsl_linalg_LU_decomp, -1); rb_define_module_function(mgsl_linalg, "LU_solve", rb_gsl_linalg_LU_solve, -1); rb_define_module_function(mgsl_linalg_LU, "solve", rb_gsl_linalg_LU_solve, -1); rb_define_method(cgsl_matrix, "LU_solve", rb_gsl_linalg_LU_solve, -1); rb_define_method(cgsl_matrix_LU, "solve", rb_gsl_linalg_LU_solve, -1); rb_define_module_function(mgsl_linalg, "LU_svx", rb_gsl_linalg_LU_svx, -1); rb_define_module_function(mgsl_linalg_LU, "svx", rb_gsl_linalg_LU_svx, -1); rb_define_method(cgsl_matrix, "LU_svx", rb_gsl_linalg_LU_svx, -1); rb_define_method(cgsl_matrix_LU, "svx", rb_gsl_linalg_LU_svx, -1); rb_define_module_function(mgsl_linalg, "LU_invert", rb_gsl_linalg_LU_invert, -1); rb_define_module_function(mgsl_linalg_LU, "invert", rb_gsl_linalg_LU_invert, -1); rb_define_module_function(mgsl_linalg_LU, "inv", rb_gsl_linalg_LU_invert, -1); rb_define_module_function(mgsl_linalg_LU, "refine", rb_gsl_linalg_LU_refine, 5); rb_define_method(cgsl_matrix, "invert", rb_gsl_linalg_LU_invert, -1); rb_define_alias(cgsl_matrix, "LU_invert", "invert"); rb_define_alias(cgsl_matrix, "inv", "invert"); rb_define_module_function(mgsl_linalg, "LU_det", rb_gsl_linalg_LU_det, -1); rb_define_module_function(mgsl_linalg_LU, "det", rb_gsl_linalg_LU_det, -1); rb_define_method(cgsl_matrix, "LU_det", rb_gsl_linalg_LU_det, -1); rb_define_alias(cgsl_matrix, "det", "LU_det"); rb_define_module_function(mgsl_linalg, "LU_lndet", rb_gsl_linalg_LU_lndet, -1); rb_define_module_function(mgsl_linalg_LU, "lndet", rb_gsl_linalg_LU_lndet, -1); rb_define_method(cgsl_matrix, "LU_lndet", rb_gsl_linalg_LU_lndet, -1); rb_define_alias(cgsl_matrix, "lndet", "LU_lndet"); rb_define_module_function(mgsl_linalg, "LU_sgndet", rb_gsl_linalg_LU_sgndet, -1); rb_define_module_function(mgsl_linalg_LU, "sgndet", rb_gsl_linalg_LU_sgndet, -1); rb_define_method(cgsl_matrix, "LU_sgndet", rb_gsl_linalg_LU_sgndet, -1); rb_define_alias(cgsl_matrix, "sgndet", "LU_sgndet"); /*****/ rb_define_module_function(mgsl_linalg, "QR_decomp", rb_gsl_linalg_QR_decomp, -1); rb_define_module_function(mgsl_linalg_QR, "decomp", rb_gsl_linalg_QR_decomp, -1); rb_define_method(cgsl_matrix, "QR_decomp", rb_gsl_linalg_QR_decomp, -1); rb_define_module_function(mgsl_linalg, "QR_decomp!", rb_gsl_linalg_QR_decomp_bang, -1); rb_define_module_function(mgsl_linalg_QR, "decomp!", rb_gsl_linalg_QR_decomp_bang, -1); rb_define_method(cgsl_matrix, "QR_decomp!", rb_gsl_linalg_QR_decomp_bang, -1); rb_define_module_function(mgsl_linalg, "QR_solve", rb_gsl_linalg_QR_solve, -1); rb_define_module_function(mgsl_linalg_QR, "solve", rb_gsl_linalg_QR_solve, -1); rb_define_module_function(mgsl_linalg, "QR_svx", rb_gsl_linalg_QR_svx, -1); rb_define_module_function(mgsl_linalg_QR, "svx", rb_gsl_linalg_QR_svx, -1); rb_define_method(cgsl_matrix, "QR_solve", rb_gsl_linalg_QR_solve, -1); rb_define_method(cgsl_matrix_QR, "solve", rb_gsl_linalg_QR_solve, -1); rb_define_method(cgsl_matrix, "QR_svx", rb_gsl_linalg_QR_svx, -1); rb_define_method(cgsl_matrix_QR, "svx", rb_gsl_linalg_QR_svx, -1); rb_define_module_function(mgsl_linalg_QR, "lssolve", rb_gsl_linalg_QR_lssolve, -1); rb_define_method(cgsl_matrix, "QR_lssolve", rb_gsl_linalg_QR_lssolve, -1); rb_define_method(cgsl_matrix_QR, "lssolve", rb_gsl_linalg_QR_lssolve, -1); rb_define_module_function(mgsl_linalg_QR, "QTvec", rb_gsl_linalg_QR_QTvec, -1); rb_define_method(cgsl_matrix_QR, "QTvec", rb_gsl_linalg_QR_QTvec, -1); rb_define_module_function(mgsl_linalg_QR, "Qvec", rb_gsl_linalg_QR_Qvec, -1); rb_define_method(cgsl_matrix_QR, "Qvec", rb_gsl_linalg_QR_Qvec, -1); rb_define_module_function(mgsl_linalg_QR, "Rsolve", rb_gsl_linalg_QR_Rsolve, -1); rb_define_method(cgsl_matrix, "QR_Rsolve", rb_gsl_linalg_QR_Rsolve, -1); rb_define_method(cgsl_matrix_QR, "Rsolve", rb_gsl_linalg_QR_Rsolve, -1); rb_define_module_function(mgsl_linalg_QR, "Rsvx", rb_gsl_linalg_QR_Rsvx, -1); rb_define_method(cgsl_matrix_QR, "Rsvx", rb_gsl_linalg_QR_Rsvx, 1); rb_define_module_function(mgsl_linalg_QR, "unpack", rb_gsl_linalg_QR_unpack, -1); rb_define_method(cgsl_matrix_QR, "unpack", rb_gsl_linalg_QR_unpack, -1); rb_define_module_function(mgsl_linalg_QR, "QRsolve", rb_gsl_linalg_QR_QRsolve, -1); rb_define_module_function(mgsl_linalg_QR, "update", rb_gsl_linalg_QR_update, 4); rb_define_method(mgsl_linalg, "R_solve", rb_gsl_linalg_R_solve, -1); rb_define_method(cgsl_matrix_R, "solve", rb_gsl_linalg_R_solve, -1); /* rb_define_method(cgsl_matrix_R, "svx", rb_gsl_linalg_R_svx, -1); */ rb_define_module_function(mgsl_linalg_QRPT, "decomp", rb_gsl_linalg_QRPT_decomp, -1); rb_define_method(cgsl_matrix, "QRPT_decomp", rb_gsl_linalg_QRPT_decomp, -1); rb_define_module_function(mgsl_linalg_QRPT, "decomp!", rb_gsl_linalg_QRPT_decomp_bang, -1); rb_define_method(cgsl_matrix, "QRPT_decomp!", rb_gsl_linalg_QRPT_decomp_bang, -1); rb_define_module_function(mgsl_linalg_QRPT, "decomp2", rb_gsl_linalg_QRPT_decomp2, -1); rb_define_method(cgsl_matrix, "QRPT_decomp2", rb_gsl_linalg_QRPT_decomp2, -1); rb_define_module_function(mgsl_linalg_QRPT, "solve", rb_gsl_linalg_QRPT_solve, -1); rb_define_method(cgsl_matrix, "QRPT_solve", rb_gsl_linalg_QRPT_solve, -1); rb_define_method(cgsl_matrix_QRPT, "solve", rb_gsl_linalg_QRPT_solve, -1); rb_define_module_function(mgsl_linalg_QRPT, "svx", rb_gsl_linalg_QRPT_svx, -1); rb_define_method(cgsl_matrix, "QRPT_svx", rb_gsl_linalg_QRPT_svx, -1); rb_define_method(cgsl_matrix_QRPT, "svx", rb_gsl_linalg_QRPT_svx, -1); rb_define_module_function(mgsl_linalg_QRPT, "QRsolve", rb_gsl_linalg_QRPT_QRsolve, 4); rb_define_module_function(mgsl_linalg_QRPT, "update", rb_gsl_linalg_QRPT_update, 5); rb_define_module_function(mgsl_linalg_QRPT, "Rsolve", rb_gsl_linalg_QRPT_Rsolve, -1); rb_define_method(cgsl_matrix_QRPT, "Rsolve", rb_gsl_linalg_QRPT_Rsolve, -1); rb_define_module_function(mgsl_linalg_QRPT, "Rsvx", rb_gsl_linalg_QRPT_Rsvx, -1); rb_define_method(cgsl_matrix_QRPT, "Rsvx", rb_gsl_linalg_QRPT_Rsvx, -1); /*****/ rb_define_module_function(mgsl_linalg_SV, "decomp", rb_gsl_linalg_SV_decomp, -1); rb_define_method(cgsl_matrix, "SV_decomp", rb_gsl_linalg_SV_decomp, -1); rb_define_alias(cgsl_matrix, "SVD", "SV_decomp"); rb_define_alias(cgsl_matrix, "svd", "SV_decomp"); rb_define_module_function(mgsl_linalg_SV, "decomp_mod", rb_gsl_linalg_SV_decomp_mod, -1); rb_define_method(cgsl_matrix, "SV_decomp_mod", rb_gsl_linalg_SV_decomp_mod, -1); rb_define_module_function(mgsl_linalg_SV, "decomp_jacobi", rb_gsl_linalg_SV_decomp_jacobi, -1); rb_define_method(cgsl_matrix, "SV_decomp_jacobi", rb_gsl_linalg_SV_decomp_jacobi, -1); rb_define_module_function(mgsl_linalg_SV, "solve", rb_gsl_linalg_SV_solve, -1); rb_define_method(cgsl_matrix, "SV_solve", rb_gsl_linalg_SV_solve, -1); /*****/ rb_define_module_function(mgsl_linalg_cholesky, "decomp", rb_gsl_linalg_cholesky_decomp, -1); rb_define_method(cgsl_matrix, "cholesky_decomp", rb_gsl_linalg_cholesky_decomp, -1); rb_define_module_function(mgsl_linalg_cholesky, "solve", rb_gsl_linalg_cholesky_solve, -1); rb_define_method(cgsl_matrix, "cholesky_solve", rb_gsl_linalg_cholesky_solve, -1); rb_define_method(cgsl_matrix_C, "solve", rb_gsl_linalg_cholesky_solve, -1); rb_define_module_function(mgsl_linalg_cholesky, "svx", rb_gsl_linalg_cholesky_svx, -1); rb_define_method(cgsl_matrix, "cholesky_svx", rb_gsl_linalg_cholesky_svx, -1); rb_define_method(cgsl_matrix_C, "svx", rb_gsl_linalg_cholesky_svx, -1); /*****/ rb_define_module_function(mgsl_linalg_symmtd, "decomp", rb_gsl_linalg_symmtd_decomp, -1); rb_define_method(cgsl_matrix, "symmtd_decomp", rb_gsl_linalg_symmtd_decomp, -1); rb_define_module_function(mgsl_linalg_symmtd, "decomp!", rb_gsl_linalg_symmtd_decomp2, -1); rb_define_method(cgsl_matrix, "symmtd_decomp!", rb_gsl_linalg_symmtd_decomp2, -1); rb_define_method(cgsl_matrix, "symmtd_unpack", rb_gsl_linalg_symmtd_unpack, -1); rb_define_method(cgsl_matrix, "symmtd_unpack_T", rb_gsl_linalg_symmtd_unpack_T, -1); rb_define_module_function(mgsl_linalg_symmtd, "unpack", rb_gsl_linalg_symmtd_unpack, -1); rb_define_module_function(mgsl_linalg_symmtd, "unpack_T", rb_gsl_linalg_symmtd_unpack_T, -1); /*****/ rb_define_module_function(mgsl_linalg_hermtd, "decomp", rb_gsl_linalg_hermtd_decomp, -1); rb_define_method(cgsl_matrix, "hermtd_decomp", rb_gsl_linalg_hermtd_decomp, -1); rb_define_module_function(mgsl_linalg_hermtd, "decomp!", rb_gsl_linalg_hermtd_decomp2, -1); rb_define_method(cgsl_matrix, "hermtd_decomp!", rb_gsl_linalg_hermtd_decomp2, -1); rb_define_method(cgsl_matrix_complex, "hermtd_unpack", rb_gsl_linalg_hermtd_unpack, -1); rb_define_module_function(mgsl_linalg_hermtd, "unpack", rb_gsl_linalg_hermtd_unpack, -1); rb_define_method(cgsl_matrix_complex, "hermtd_unpack_T", rb_gsl_linalg_hermtd_unpack_T, -1); rb_define_module_function(mgsl_linalg_hermtd, "unpack_T", rb_gsl_linalg_hermtd_unpack_T, -1); /*****/ rb_define_method(cgsl_matrix, "bidiag_decomp", rb_gsl_linalg_bidiag_decomp, -1); rb_define_method(cgsl_matrix, "bidiag_decomp!", rb_gsl_linalg_bidiag_decomp2, -1); rb_define_module_function(mgsl_linalg, "bidiag_decomp", rb_gsl_linalg_bidiag_decomp, -1); rb_define_module_function(mgsl_linalg, "bidiag_decomp!", rb_gsl_linalg_bidiag_decomp2, -1); rb_define_module_function(mgsl_linalg_bidiag, "decomp", rb_gsl_linalg_bidiag_decomp, -1); rb_define_module_function(mgsl_linalg_bidiag, "decomp!", rb_gsl_linalg_bidiag_decomp2, -1); rb_define_method(cgsl_matrix, "bidiag_unpack", rb_gsl_linalg_bidiag_unpack, -1); rb_define_method(cgsl_matrix, "bidiag_unpack2", rb_gsl_linalg_bidiag_unpack2, -1); rb_define_module_function(mgsl_linalg, "bidiag_unpack", rb_gsl_linalg_bidiag_unpack, -1); rb_define_module_function(mgsl_linalg, "bidiag_unpack2", rb_gsl_linalg_bidiag_unpack2, -1); rb_define_module_function(mgsl_linalg_bidiag, "unpack", rb_gsl_linalg_bidiag_unpack, -1); rb_define_module_function(mgsl_linalg_bidiag, "unpack2", rb_gsl_linalg_bidiag_unpack2, -1); rb_define_method(cgsl_matrix, "bidiag_unpack_B", rb_gsl_linalg_bidiag_unpack_B, -1); rb_define_module_function(mgsl_linalg, "bidiag_unpack_B", rb_gsl_linalg_bidiag_unpack_B, -1); rb_define_module_function(mgsl_linalg_bidiag, "unpack_B", rb_gsl_linalg_bidiag_unpack_B, -1); /*****/ rb_define_module_function(mgsl_linalg, "householder_transform", rb_gsl_linalg_householder_transform, -1); rb_define_module_function(mgsl_linalg_Householder, "transform", rb_gsl_linalg_householder_transform, -1); rb_define_module_function(mgsl_linalg_HH, "transform", rb_gsl_linalg_householder_transform, -1); rb_define_method(cgsl_vector, "householder_transform", rb_gsl_linalg_householder_transform, -1); rb_define_module_function(mgsl_linalg, "householder_hm", rb_gsl_linalg_householder_hm, 3); rb_define_module_function(mgsl_linalg_Householder, "hm", rb_gsl_linalg_householder_hm, 3); rb_define_module_function(mgsl_linalg_HH, "hm", rb_gsl_linalg_householder_hm, 3); rb_define_module_function(mgsl_linalg, "householder_mh", rb_gsl_linalg_householder_mh, 3); rb_define_module_function(mgsl_linalg_Householder, "mh", rb_gsl_linalg_householder_mh, 3); rb_define_module_function(mgsl_linalg_HH, "mh", rb_gsl_linalg_householder_mh, 3); rb_define_module_function(mgsl_linalg, "householder_hv", rb_gsl_linalg_householder_hv, 3); rb_define_module_function(mgsl_linalg_Householder, "hv", rb_gsl_linalg_householder_hv, 3); rb_define_module_function(mgsl_linalg_HH, "hv", rb_gsl_linalg_householder_hv, 3); rb_define_module_function(mgsl_linalg_HH, "solve", rb_gsl_linalg_HH_solve, -1); rb_define_module_function(mgsl_linalg_HH, "solve!", rb_gsl_linalg_HH_solve_bang, -1); rb_define_method(cgsl_matrix, "HH_solve", rb_gsl_linalg_HH_solve, -1); rb_define_method(cgsl_matrix, "HH_solve!", rb_gsl_linalg_HH_solve_bang, -1); rb_define_module_function(mgsl_linalg_HH, "svx", rb_gsl_linalg_HH_svx, -1); rb_define_method(cgsl_matrix, "HH_svx", rb_gsl_linalg_HH_svx, -1); /*****/ rb_define_module_function(mgsl_linalg, "solve_symm_tridiag", rb_gsl_linalg_solve_symm_tridiag, 3); rb_define_module_function(mgsl_linalg_tridiag, "solve_symm", rb_gsl_linalg_solve_symm_tridiag, 3); #ifdef GSL_1_2_LATER rb_define_module_function(mgsl_linalg, "solve_tridiag", rb_gsl_linalg_solve_tridiag, 4); rb_define_module_function(mgsl_linalg_tridiag, "solve", rb_gsl_linalg_solve_tridiag, 4); rb_define_module_function(mgsl_linalg, "solve_symm_cyc_tridiag", rb_gsl_linalg_solve_symm_cyc_tridiag, 3); rb_define_module_function(mgsl_linalg, "solve_cyc_tridiag", rb_gsl_linalg_solve_cyc_tridiag, 4); rb_define_module_function(mgsl_linalg_tridiag, "solve_symm_cyc", rb_gsl_linalg_solve_symm_cyc_tridiag, 3); rb_define_module_function(mgsl_linalg_tridiag, "solve_cyc", rb_gsl_linalg_solve_cyc_tridiag, 4); #endif /*****/ rb_define_module_function(mgsl_linalg, "balance_columns!", rb_gsl_linalg_balance_columns_bang, -1); rb_define_method(cgsl_matrix, "balance_columns!", rb_gsl_linalg_balance_columns_bang, -1); rb_define_module_function(mgsl_linalg, "balance_columns", rb_gsl_linalg_balance_columns, -1); rb_define_method(cgsl_matrix, "balance_columns", rb_gsl_linalg_balance_columns, -1); rb_define_alias(cgsl_matrix, "balance", "balance_columns"); rb_define_alias(cgsl_matrix, "balanc", "balance_columns"); /*****/ Init_gsl_linalg_complex(mgsl_linalg); /** GSL-1.6 **/ #ifdef GSL_1_6_LATER rb_define_module_function(mgsl_linalg, "LQ_decomp", rb_gsl_linalg_LQ_decomp, -1); rb_define_module_function(mgsl_linalg_LQ, "decomp", rb_gsl_linalg_LQ_decomp, -1); rb_define_method(cgsl_matrix, "LQ_decomp", rb_gsl_linalg_LQ_decomp, -1); rb_define_module_function(mgsl_linalg, "LQ_decomp!", rb_gsl_linalg_LQ_decomp_bang, -1); rb_define_module_function(mgsl_linalg_LQ, "decomp!", rb_gsl_linalg_LQ_decomp_bang, -1); rb_define_method(cgsl_matrix, "LQ_decomp!", rb_gsl_linalg_LQ_decomp_bang, -1); rb_define_module_function(mgsl_linalg, "LQ_solve_T", rb_gsl_linalg_LQ_solve, -1); rb_define_module_function(mgsl_linalg_LQ, "solve_T", rb_gsl_linalg_LQ_solve, -1); rb_define_module_function(mgsl_linalg, "LQ_svx_T", rb_gsl_linalg_LQ_svx, -1); rb_define_module_function(mgsl_linalg_LQ, "svx_T", rb_gsl_linalg_LQ_svx, -1); rb_define_method(cgsl_matrix, "LQ_solve_T", rb_gsl_linalg_LQ_solve, -1); rb_define_method(cgsl_matrix_LQ, "solve_T", rb_gsl_linalg_LQ_solve, -1); rb_define_method(cgsl_matrix, "LQ_svx_T", rb_gsl_linalg_LQ_svx, -1); rb_define_method(cgsl_matrix_LQ, "svx_T", rb_gsl_linalg_LQ_svx, -1); rb_define_module_function(mgsl_linalg_LQ, "lssolve_T", rb_gsl_linalg_LQ_lssolve, -1); rb_define_method(cgsl_matrix, "LQ_lssolve_T", rb_gsl_linalg_LQ_lssolve, -1); rb_define_method(cgsl_matrix_LQ, "lssolve_T", rb_gsl_linalg_LQ_lssolve, -1); rb_define_module_function(mgsl_linalg_LQ, "vecQT", rb_gsl_linalg_LQ_vecQT, -1); rb_define_method(cgsl_matrix_LQ, "vecQT", rb_gsl_linalg_LQ_vecQT, -1); rb_define_module_function(mgsl_linalg_LQ, "vecQ", rb_gsl_linalg_LQ_vecQ, -1); rb_define_method(cgsl_matrix_LQ, "vecQ", rb_gsl_linalg_LQ_vecQ, -1); rb_define_module_function(mgsl_linalg_LQ, "Lsolve_T", rb_gsl_linalg_LQ_Lsolve, -1); rb_define_method(cgsl_matrix, "LQ_Lsolve_T", rb_gsl_linalg_LQ_Lsolve, -1); rb_define_method(cgsl_matrix_LQ, "Lsolve_T", rb_gsl_linalg_LQ_Lsolve, -1); rb_define_module_function(mgsl_linalg_LQ, "Lsvx_T", rb_gsl_linalg_LQ_Lsvx, -1); rb_define_method(cgsl_matrix_LQ, "Lsvx_T", rb_gsl_linalg_LQ_Lsvx, 1); rb_define_module_function(mgsl_linalg_LQ, "unpack", rb_gsl_linalg_LQ_unpack, -1); rb_define_method(cgsl_matrix_LQ, "unpack", rb_gsl_linalg_LQ_unpack, -1); rb_define_module_function(mgsl_linalg_LQ, "LQsolve_T", rb_gsl_linalg_LQ_LQsolve, -1); rb_define_module_function(mgsl_linalg_LQ, "update", rb_gsl_linalg_LQ_update, 4); rb_define_method(mgsl_linalg, "L_solve_T", rb_gsl_linalg_L_solve, -1); rb_define_method(cgsl_matrix_L, "solve_T", rb_gsl_linalg_L_solve, -1); /* rb_define_method(cgsl_matrix_R, "svx", rb_gsl_linalg_R_svx, -1); */ rb_define_module_function(mgsl_linalg_PTLQ, "decomp", rb_gsl_linalg_PTLQ_decomp, -1); rb_define_method(cgsl_matrix, "PTLQ_decomp", rb_gsl_linalg_PTLQ_decomp, -1); rb_define_module_function(mgsl_linalg_PTLQ, "decomp!", rb_gsl_linalg_PTLQ_decomp_bang, -1); rb_define_method(cgsl_matrix, "PTLQ_decomp!", rb_gsl_linalg_PTLQ_decomp_bang, -1); rb_define_module_function(mgsl_linalg_PTLQ, "decomp2", rb_gsl_linalg_PTLQ_decomp2, -1); rb_define_method(cgsl_matrix, "PTLQ_decomp2", rb_gsl_linalg_PTLQ_decomp2, -1); rb_define_module_function(mgsl_linalg_PTLQ, "solve_T", rb_gsl_linalg_PTLQ_solve, -1); rb_define_method(cgsl_matrix, "PTLQ_solve_T", rb_gsl_linalg_PTLQ_solve, -1); rb_define_method(cgsl_matrix_PTLQ, "solve_T", rb_gsl_linalg_PTLQ_solve, -1); rb_define_module_function(mgsl_linalg_PTLQ, "svx_T", rb_gsl_linalg_PTLQ_svx, -1); rb_define_method(cgsl_matrix, "PTLQ_svx_T", rb_gsl_linalg_PTLQ_svx, -1); rb_define_method(cgsl_matrix_PTLQ, "svx_T", rb_gsl_linalg_PTLQ_svx, -1); rb_define_module_function(mgsl_linalg_PTLQ, "LQsolve_T", rb_gsl_linalg_PTLQ_LQsolve, 4); rb_define_module_function(mgsl_linalg_PTLQ, "update", rb_gsl_linalg_PTLQ_update, 5); rb_define_module_function(mgsl_linalg_PTLQ, "Lsolve_T", rb_gsl_linalg_PTLQ_Lsolve, -1); rb_define_method(cgsl_matrix_PTLQ, "Lsolve_T", rb_gsl_linalg_PTLQ_Lsolve, -1); rb_define_module_function(mgsl_linalg_PTLQ, "Lsvx_T", rb_gsl_linalg_PTLQ_Lsvx, -1); rb_define_method(cgsl_matrix_PTLQ, "Lsvx_T", rb_gsl_linalg_PTLQ_Lsvx, -1); #endif #ifdef GSL_1_9_LATER VALUE mhessen; mhessen = rb_define_module_under(mgsl_linalg, "Hessenberg"); rb_define_module_function(mhessen, "decomp", rb_gsl_linalg_hessenberg_decomp, 1); rb_define_module_function(mgsl_linalg, "heesenberg_decomp", rb_gsl_linalg_hessenberg_decomp, 1); rb_define_module_function(mhessen, "unpack", rb_gsl_linalg_hessenberg_unpack, 2); rb_define_module_function(mgsl_linalg, "hessenberg_unpack", rb_gsl_linalg_hessenberg_unpack, 2); rb_define_module_function(mhessen, "unpack_accum", rb_gsl_linalg_hessenberg_unpack_accum, -1); rb_define_module_function(mgsl_linalg, "hessenberg_unpack_accum", rb_gsl_linalg_hessenberg_unpack_accum, -1); rb_define_module_function(mhessen, "set_zero", rb_gsl_linalg_hessenberg_set_zero, 1); rb_define_module_function(mgsl_linalg, "hessenberg_set_zero", rb_gsl_linalg_hessenberg_set_zero, 1); rb_define_module_function(mgsl_linalg, "hesstri_decomp", rb_gsl_linalg_hesstri_decomp, -1); rb_define_module_function(mgsl_linalg, "hesstri_decomp!", rb_gsl_linalg_hesstri_decomp_bang, -1); rb_define_module_function(mgsl_linalg, "balance_matrix", rb_gsl_linalg_balance_matrix, -1); rb_define_module_function(mgsl_linalg, "balance_matrix!", rb_gsl_linalg_balance_matrix2, -1); rb_define_module_function(mgsl_linalg, "balance", rb_gsl_linalg_balance_matrix, -1); rb_define_module_function(mgsl_linalg, "balance!", rb_gsl_linalg_balance_matrix2, -1); #endif } gsl-1.15.3/ext/blas.c0000644000175000017500000000137212220252463013632 0ustar boutilboutil/* blas.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include #include "rb_gsl_common.h" #include "rb_gsl_array.h" void Init_gsl_blas1(VALUE module); void Init_gsl_blas2(VALUE module); void Init_gsl_blas3(VALUE module); void Init_gsl_blas(VALUE module) { VALUE mgsl_blas; mgsl_blas = rb_define_module_under(module, "Blas"); Init_gsl_blas1(mgsl_blas); Init_gsl_blas2(mgsl_blas); Init_gsl_blas3(mgsl_blas); } gsl-1.15.3/ext/block.c0000644000175000017500000000175712220252463014012 0ustar boutilboutil/* block.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ /* This code uses "templates_on.h" and "templates_off.h", which are provided by the GSL source. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_histogram.h" #include "rb_gsl_complex.h" #include "rb_gsl_poly.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif #define BASE_DOUBLE #include "templates_on.h" #include "block_source.c" #include "templates_off.h" #undef BASE_DOUBLE #define BASE_INT #include "templates_on.h" #include "block_source.c" #include "templates_off.h" #undef BASE_INT #define BASE_UCHAR #include "templates_on.h" #include "block_source.c" #include "templates_off.h" #undef BASE_UCHAR gsl-1.15.3/ext/sf_hyperg.c0000644000175000017500000001722212220252463014700 0ustar boutilboutil/* sf_hyperg.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" /* Checked with Mathematica. */ static VALUE rb_gsl_sf_hyperg_0F1(VALUE obj, VALUE c, VALUE x) { return rb_gsl_sf_eval_double_double(gsl_sf_hyperg_0F1, c, x); } static VALUE rb_gsl_sf_hyperg_0F1_e(VALUE obj, VALUE c, VALUE x) { return rb_gsl_sf_eval_e_double2(gsl_sf_hyperg_0F1_e, c, x); } static VALUE rb_gsl_sf_hyperg_1F1_int(VALUE obj, VALUE m, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_int_double(gsl_sf_hyperg_1F1_int, m, n, x); } static VALUE rb_gsl_sf_hyperg_1F1_int_e(VALUE obj, VALUE m, VALUE n, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(m); CHECK_FIXNUM(n); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_hyperg_1F1_int_e(FIX2INT(m), FIX2INT(n), NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_hyperg_1F1(VALUE obj, VALUE a, VALUE b, VALUE x) { return rb_gsl_sf_eval_double3(gsl_sf_hyperg_1F1, a, b, x); } static VALUE rb_gsl_sf_hyperg_1F1_e(VALUE obj, VALUE a, VALUE b, VALUE x) { return rb_gsl_sf_eval_e_double3(gsl_sf_hyperg_1F1_e, a, b, x); } static VALUE rb_gsl_sf_hyperg_U_int(VALUE obj, VALUE m, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_int_double(gsl_sf_hyperg_U_int, m, n, x); } static VALUE rb_gsl_sf_hyperg_U_int_e(VALUE obj, VALUE m, VALUE n, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(m); CHECK_FIXNUM(n); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_hyperg_U_int_e(FIX2INT(m), FIX2INT(n), NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_hyperg_U_int_e10_e(VALUE obj, VALUE m, VALUE n, VALUE x) { gsl_sf_result_e10 *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(m); CHECK_FIXNUM(n); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result_e10, gsl_sf_result_e10, 0, free, rslt); /*status =*/ gsl_sf_hyperg_U_int_e10_e(FIX2INT(m), FIX2INT(n), NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_hyperg_U(VALUE obj, VALUE a, VALUE b, VALUE x) { return rb_gsl_sf_eval_double3(gsl_sf_hyperg_U, a, b, x); } static VALUE rb_gsl_sf_hyperg_U_e(VALUE obj, VALUE a, VALUE b, VALUE x) { return rb_gsl_sf_eval_e_double3(gsl_sf_hyperg_U_e, a, b, x); } static VALUE rb_gsl_sf_hyperg_U_e10_e(VALUE obj, VALUE a, VALUE b, VALUE x) { gsl_sf_result_e10 *rslt = NULL; VALUE v; int status; Need_Float(a); Need_Float(b); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result_e10, gsl_sf_result_e10, 0, free, rslt); status = gsl_sf_hyperg_U_e10_e(NUM2DBL(a), NUM2DBL(b), NUM2DBL(x), rslt); return rb_ary_new3(2, v, INT2FIX(status)); } static VALUE rb_gsl_sf_hyperg_2F1(VALUE obj, VALUE a, VALUE b, VALUE c, VALUE x) { return rb_gsl_sf_eval_double4(gsl_sf_hyperg_2F1, a, b, c, x); } static VALUE rb_gsl_sf_hyperg_2F1_e(VALUE obj, VALUE a, VALUE b, VALUE c, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(a); Need_Float(b); Need_Float(c); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = gsl_sf_hyperg_2F1_e(NUM2DBL(a), NUM2DBL(b), NUM2DBL(c), NUM2DBL(x), rslt); return rb_ary_new3(2, v, INT2FIX(status)); } static VALUE rb_gsl_sf_hyperg_2F1_conj(VALUE obj, VALUE aR, VALUE aI, VALUE c, VALUE x) { return rb_gsl_sf_eval_double4(gsl_sf_hyperg_2F1_conj, aR, aI, c, x); } static VALUE rb_gsl_sf_hyperg_2F1_conj_e(VALUE obj, VALUE aR, VALUE aI, VALUE c, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(aR); Need_Float(aI); Need_Float(c); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_hyperg_2F1_conj_e(NUM2DBL(aR), NUM2DBL(aI), NUM2DBL(c), NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_hyperg_2F1_renorm(VALUE obj, VALUE a, VALUE b, VALUE c, VALUE x) { return rb_gsl_sf_eval_double4(gsl_sf_hyperg_2F1_renorm, a, b, c, x); } static VALUE rb_gsl_sf_hyperg_2F1_renorm_e(VALUE obj, VALUE a, VALUE b, VALUE c, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(a); Need_Float(b); Need_Float(c); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_hyperg_2F1_renorm_e(NUM2DBL(a), NUM2DBL(b), NUM2DBL(c), NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_hyperg_2F1_conj_renorm(VALUE obj, VALUE aR, VALUE aI, VALUE c, VALUE x) { return rb_gsl_sf_eval_double4(gsl_sf_hyperg_2F1_conj_renorm, aR, aI, c, x); } static VALUE rb_gsl_sf_hyperg_2F1_conj_renorm_e(VALUE obj, VALUE aR, VALUE aI, VALUE c, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(aR); Need_Float(aI); Need_Float(c); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_hyperg_2F1_conj_renorm_e(NUM2DBL(aR), NUM2DBL(aI), NUM2DBL(c), NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_hyperg_2F0(VALUE obj, VALUE a, VALUE b, VALUE x) { return rb_gsl_sf_eval_double3(gsl_sf_hyperg_2F0, a, b, x); } static VALUE rb_gsl_sf_hyperg_2F0_e(VALUE obj, VALUE a, VALUE b, VALUE x) { return rb_gsl_sf_eval_e_double3(gsl_sf_hyperg_2F0_e, a, b, x); } void Init_gsl_sf_hyperg(VALUE module) { rb_define_module_function(module, "hyperg_0F1", rb_gsl_sf_hyperg_0F1, 2); rb_define_module_function(module, "hyperg_0F1_e", rb_gsl_sf_hyperg_0F1_e, 2); rb_define_module_function(module, "hyperg_1F1_int", rb_gsl_sf_hyperg_1F1_int, 3); rb_define_module_function(module, "hyperg_1F1_int_e", rb_gsl_sf_hyperg_1F1_int_e, 3); rb_define_module_function(module, "hyperg_1F1", rb_gsl_sf_hyperg_1F1, 3); rb_define_module_function(module, "hyperg_1F1_e", rb_gsl_sf_hyperg_1F1_e, 3); rb_define_module_function(module, "hyperg_U_int", rb_gsl_sf_hyperg_U_int, 3); rb_define_module_function(module, "hyperg_U_int_e", rb_gsl_sf_hyperg_U_int_e, 3); rb_define_module_function(module, "hyperg_U_int_e10_e", rb_gsl_sf_hyperg_U_int_e10_e, 3); rb_define_module_function(module, "hyperg_U", rb_gsl_sf_hyperg_U, 3); rb_define_module_function(module, "hyperg_U_e", rb_gsl_sf_hyperg_U_e, 3); rb_define_module_function(module, "hyperg_U_e10_e", rb_gsl_sf_hyperg_U_e10_e, 3); rb_define_module_function(module, "hyperg_2F1", rb_gsl_sf_hyperg_2F1, 4); rb_define_module_function(module, "hyperg_2F1_e", rb_gsl_sf_hyperg_2F1_e, 4); rb_define_module_function(module, "hyperg_2F1_conj", rb_gsl_sf_hyperg_2F1_conj, 4); rb_define_module_function(module, "hyperg_2F1_conj_e", rb_gsl_sf_hyperg_2F1_conj_e, 4); rb_define_module_function(module, "hyperg_2F1_renorm", rb_gsl_sf_hyperg_2F1_renorm, 4); rb_define_module_function(module, "hyperg_2F1_renorm_e", rb_gsl_sf_hyperg_2F1_renorm_e, 4); rb_define_module_function(module, "hyperg_2F1_conj_renorm", rb_gsl_sf_hyperg_2F1_conj_renorm, 4); rb_define_module_function(module, "hyperg_2F1_conj_renorm_e", rb_gsl_sf_hyperg_2F1_conj_renorm_e, 4); rb_define_module_function(module, "hyperg_2F0", rb_gsl_sf_hyperg_2F0, 3); rb_define_module_function(module, "hyperg_2F0_e", rb_gsl_sf_hyperg_2F0_e, 3); } gsl-1.15.3/ext/permutation.c0000644000175000017500000004403412220252463015262 0ustar boutilboutil/* permutation.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include #include VALUE rb_gsl_permutation_alloc(VALUE klass, VALUE nn); /* * Creates a new permutation of size n. The permutation is not initialized * and its elements are undefined. Use the method calloc if you want to create * a permutation which is initialized to the identity. */ VALUE rb_gsl_permutation_alloc(VALUE klass, VALUE nn) { gsl_permutation *p = NULL; CHECK_FIXNUM(nn); p = gsl_permutation_calloc(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, gsl_permutation_free, p); } static VALUE rb_gsl_permutation_calloc(VALUE klass, VALUE nn) { gsl_permutation *p = NULL; CHECK_FIXNUM(nn); p = gsl_permutation_calloc(FIX2INT(nn)); return Data_Wrap_Struct(klass, 0, gsl_permutation_free, p); } static VALUE rb_gsl_permutation_size(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); return INT2FIX(p->size); } static VALUE rb_gsl_permutation_init(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); gsl_permutation_init(p); return obj; } void get_range_int_beg_en_n(VALUE range, int *beg, int *en, size_t *n, int *step); static VALUE rb_gsl_permutation_get(int argc, VALUE *argv, VALUE obj) { gsl_permutation *b, *bnew; gsl_index *p; int beg, en, i, step; size_t n, j, k; Data_Get_Struct(obj, gsl_permutation, b); switch (argc) { case 0: rb_raise(rb_eArgError, "too few arguments (%d for >= 1)", argc); break; case 1: switch (TYPE(argv[0])) { case T_FIXNUM: i = FIX2INT(argv[0]); if (i < 0) j = b->size + i; else j = (size_t) i; return INT2FIX((int) b->data[j]); break; case T_ARRAY: // n = RARRAY(argv[0])->len; n = RARRAY_LEN(argv[0]); bnew = gsl_permutation_alloc(n); for (j = 0; j < n; j++) { i = FIX2INT(rb_ary_entry(argv[0], j)); if (i < 0) k = b->size + i; else k = i; bnew->data[j] = b->data[k]; } return Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_permutation_free, bnew); break; default: if (PERMUTATION_P(argv[0])) { Data_Get_Struct(argv[0], gsl_index, p); bnew = gsl_permutation_alloc(p->size); for (j = 0; j < p->size; j++) bnew->data[j] = b->data[p->data[j]]; return Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_permutation_free, bnew); } else if (CLASS_OF(argv[0]) == rb_cRange) { get_range_int_beg_en_n(argv[0], &beg, &en, &n, &step); bnew = gsl_permutation_alloc(n); for (j = 0; j < n; j++) bnew->data[j] = b->data[beg+j]; return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_permutation_free, bnew); } else { rb_raise(rb_eArgError, "wrong argument type %s (Fixnum, Array, or Range expected)", rb_class2name(CLASS_OF(argv[0]))); break; } } break; default: bnew = gsl_permutation_alloc(argc); for (j = 0; j < argc; j++) { i = FIX2INT(argv[j]); if (i < 0) k = b->size + i; else k = i; bnew->data[j] = b->data[k]; } return Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_permutation_free, bnew); break; } return Qnil; } #ifdef GSL_1_1_LATER static VALUE rb_gsl_permutation_clone(VALUE obj) { gsl_permutation *p, *p2 = NULL; Data_Get_Struct(obj, gsl_permutation, p); p2 = gsl_permutation_alloc(p->size); gsl_permutation_memcpy(p2, p); return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_permutation_free, p2); } /* singleton */ static VALUE rb_gsl_permutation_memcpy(VALUE obj, VALUE pp1, VALUE pp2) { gsl_permutation *p1, *p2 = NULL; CHECK_PERMUTATION(pp1); CHECK_PERMUTATION(pp2); Data_Get_Struct(pp1, gsl_permutation, p1); Data_Get_Struct(pp2, gsl_permutation, p2); gsl_permutation_memcpy(p1, p2); return pp1; } #endif static VALUE rb_gsl_permutation_swap(VALUE obj, VALUE i, VALUE j) { gsl_permutation *p = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, gsl_permutation, p); gsl_permutation_swap(p, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE rb_gsl_permutation_valid(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); return INT2FIX(gsl_permutation_valid(p)); } static VALUE rb_gsl_permutation_valid2(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); if(gsl_permutation_valid(p)) return Qtrue; else return Qfalse; } /* to array */ static VALUE rb_gsl_permutation_to_a(VALUE obj) { gsl_permutation *p = NULL; size_t i; VALUE ary; Data_Get_Struct(obj, gsl_permutation, p); ary = rb_ary_new2(p->size); for (i = 0; i < p->size; i++) { rb_ary_store(ary, i, INT2FIX(gsl_permutation_get(p, i))); } return ary; } /* to vector */ static VALUE rb_gsl_permutation_to_v(VALUE obj) { gsl_permutation *p = NULL; gsl_vector *v; size_t size; size_t i; Data_Get_Struct(obj, gsl_permutation, p); size = p->size; v = gsl_vector_alloc(size); for (i = 0; i < size; i++) { gsl_vector_set(v, i, gsl_permutation_get(p, i)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_permutation_reverse(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); gsl_permutation_reverse(p); return obj; } static VALUE rb_gsl_permutation_inverse(VALUE obj) { gsl_permutation *p, *inv; Data_Get_Struct(obj, gsl_permutation, p); inv = gsl_permutation_alloc(p->size); gsl_permutation_inverse(inv, p); return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, inv); } static VALUE rb_gsl_permutation_next(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); return INT2FIX(gsl_permutation_next(p)); } static VALUE rb_gsl_permutation_prev(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); return INT2FIX(gsl_permutation_prev(p)); } static VALUE rb_gsl_permutation_permute_vector(VALUE obj, VALUE vv) { gsl_permutation *p = NULL; gsl_vector *v; int status; CHECK_VECTOR(vv); Data_Get_Struct(obj, gsl_permutation, p); Data_Get_Struct(vv, gsl_vector, v); status = gsl_permute_vector(p, v); return INT2FIX(status); } static VALUE rb_gsl_permutation_permute_vector_inverse(VALUE obj, VALUE vv) { gsl_permutation *p = NULL; gsl_vector *v; int status; CHECK_VECTOR(vv); Data_Get_Struct(obj, gsl_permutation, p); Data_Get_Struct(vv, gsl_vector, v); status = gsl_permute_vector_inverse(p, v); return INT2FIX(status); } /* singleton */ static VALUE rb_gsl_permute_vector(VALUE obj, VALUE pp, VALUE vv) { gsl_permutation *p = NULL; gsl_vector *v; int status; CHECK_VECTOR(vv); Data_Get_Struct(pp, gsl_permutation, p); Data_Get_Struct(vv, gsl_vector, v); status = gsl_permute_vector(p, v); return INT2FIX(status); } /* singleton */ static VALUE rb_gsl_permute_vector_inverse(VALUE obj, VALUE pp, VALUE vv) { gsl_permutation *p = NULL; gsl_vector *v; int status; CHECK_VECTOR(vv); Data_Get_Struct(pp, gsl_permutation, p); Data_Get_Struct(vv, gsl_vector, v); status = gsl_permute_vector_inverse(p, v); return INT2FIX(status); } /* singleton method */ #ifdef GSL_1_2_LATER static VALUE rb_gsl_permutation_mul(VALUE obj, VALUE ppa, VALUE ppb) { gsl_permutation *p = NULL; gsl_permutation *pa = NULL, *pb = NULL; int flag = 0; CHECK_PERMUTATION(ppa); CHECK_PERMUTATION(ppb); Data_Get_Struct(ppa, gsl_permutation, pa); Data_Get_Struct(ppb, gsl_permutation, pb); if (rb_obj_is_kind_of(obj, cgsl_permutation)) { Data_Get_Struct(obj, gsl_permutation, p); flag = 1; } else { p = gsl_permutation_alloc(pa->size); } gsl_permutation_mul(p, pa, pb); if (flag == 1) return obj; else return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); } #endif static VALUE rb_gsl_permutation_print(VALUE obj); static VALUE rb_gsl_permutation_print(VALUE obj) { gsl_permutation *p = NULL; size_t size, i; Data_Get_Struct(obj, gsl_permutation, p); size = p->size; for (i = 0; i < size; i++) { printf("%3d ", (int) gsl_permutation_get(p, i)); if ((i+1)%10 == 0) printf("\n"); } printf("\n"); return obj; } static VALUE rb_gsl_permutation_to_s(VALUE obj) { gsl_permutation *v = NULL; char buf[16]; size_t i; VALUE str; Data_Get_Struct(obj, gsl_permutation, v); str = rb_str_new2("["); for (i = 0; i < v->size; i++) { sprintf(buf, " %d", (int) gsl_permutation_get(v, i)); rb_str_cat(str, buf, strlen(buf)); } sprintf(buf, " ]"); rb_str_cat(str, buf, strlen(buf)); return str; } static VALUE rb_gsl_permutation_inspect(VALUE obj) { VALUE str; char buf[64]; sprintf(buf, "%s\n", rb_class2name(CLASS_OF(obj))); str = rb_str_new2(buf); return rb_str_concat(str, rb_gsl_permutation_to_s(obj)); } static VALUE rb_gsl_permutation_fwrite(VALUE obj, VALUE io) { gsl_permutation *h; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_permutation, h); f = rb_gsl_open_writefile(io, &flag); status = gsl_permutation_fwrite(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_permutation_fread(VALUE obj, VALUE io) { gsl_permutation *h; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_permutation, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_permutation_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_permutation_fprintf(int argc, VALUE *argv, VALUE obj) { gsl_permutation *h; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); Data_Get_Struct(obj, gsl_permutation, h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 1) { status = gsl_permutation_fprintf(fp, h, "%u\n"); } else { Check_Type(argv[1], T_STRING); status = gsl_permutation_fprintf(fp, h, STR2CSTR(argv[1])); } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_permutation_printf(int argc, VALUE *argv, VALUE obj) { gsl_permutation *h; int status; Data_Get_Struct(obj, gsl_permutation, h); if (argc == 0) { status = gsl_permutation_fprintf(stdout, h, "%u\n"); } else { Check_Type(argv[0], T_STRING); status = gsl_permutation_fprintf(stdout, h, STR2CSTR(argv[0])); } return INT2FIX(status); } static VALUE rb_gsl_permutation_fscanf(VALUE obj, VALUE io) { gsl_permutation *h; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_permutation, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_permutation_fscanf(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } #ifdef GSL_1_2_LATER static VALUE rb_gsl_permutation_linear_to_canonical(int argc, VALUE *argv, VALUE obj) { gsl_permutation *p, *q; Data_Get_Struct(obj, gsl_permutation, p); switch (argc) { case 0: q = gsl_permutation_alloc(p->size); gsl_permutation_linear_to_canonical(q, p); return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, q); break; case 1: CHECK_PERMUTATION(argv[0]); Data_Get_Struct(argv[0], gsl_permutation, q); gsl_permutation_linear_to_canonical(q, p); return obj; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); } return Qtrue; } static VALUE rb_gsl_permutation_canonical_to_linear(int argc, VALUE *argv, VALUE obj) { gsl_permutation *p, *q; Data_Get_Struct(obj, gsl_permutation, p); switch (argc) { case 0: q = gsl_permutation_alloc(p->size); gsl_permutation_canonical_to_linear(q, p); return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, q); break; case 1: CHECK_PERMUTATION(argv[0]); Data_Get_Struct(argv[0], gsl_permutation, q); gsl_permutation_canonical_to_linear(q, p); return obj; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); } return Qtrue; } static VALUE rb_gsl_permutation_inversions(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); return INT2FIX(gsl_permutation_inversions(p)); } static VALUE rb_gsl_permutation_linear_cycles(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); return INT2FIX(gsl_permutation_linear_cycles(p)); } static VALUE rb_gsl_permutation_canonical_cycles(VALUE obj) { gsl_permutation *p = NULL; Data_Get_Struct(obj, gsl_permutation, p); return INT2FIX(gsl_permutation_canonical_cycles(p)); } #endif static VALUE rb_gsl_vector_permute(VALUE obj, VALUE pp) { gsl_permutation *p = NULL; gsl_vector *v = NULL; int status; CHECK_PERMUTATION(pp); Data_Get_Struct(pp, gsl_permutation, p); Data_Get_Struct(obj, gsl_vector, v); status = gsl_permute_vector(p, v); return INT2FIX(status); } static VALUE rb_gsl_vector_permute_inverse(VALUE obj, VALUE pp) { gsl_permutation *p = NULL; gsl_vector *v = NULL; int status; CHECK_PERMUTATION(pp); Data_Get_Struct(pp, gsl_permutation, p); Data_Get_Struct(obj, gsl_vector, v); status = gsl_permute_vector_inverse(p, v); return INT2FIX(status); } static VALUE rb_gsl_permutation_set(VALUE obj, VALUE ii, VALUE val) { gsl_permutation *p = NULL; CHECK_FIXNUM(ii); CHECK_FIXNUM(val); Data_Get_Struct(obj, gsl_permutation, p); p->data[FIX2INT(ii)] = FIX2INT(val); return obj; } static VALUE rb_gsl_permutation_equal(VALUE obj, VALUE other) { gsl_permutation *p1 = NULL, *p2 = NULL; size_t i; CHECK_PERMUTATION(other); Data_Get_Struct(obj, gsl_permutation, p1); Data_Get_Struct(other, gsl_permutation, p2); if (p1->size != p2->size) return Qfalse; for (i = 0; i < p1->size; i++) if (p1->data[i] != p2->data[i]) return Qfalse; return Qtrue; } void Init_gsl_permutation(VALUE module) { rb_define_singleton_method(cgsl_permutation, "alloc", rb_gsl_permutation_alloc, 1); rb_define_singleton_method(cgsl_permutation, "calloc", rb_gsl_permutation_calloc, 1); rb_define_method(cgsl_permutation, "size", rb_gsl_permutation_size, 0); rb_define_method(cgsl_permutation, "init", rb_gsl_permutation_init, 0); rb_define_method(cgsl_permutation, "inspect", rb_gsl_permutation_inspect, 0); rb_define_method(cgsl_permutation, "to_s", rb_gsl_permutation_to_s, 0); rb_define_method(cgsl_permutation, "get", rb_gsl_permutation_get, -1); rb_define_alias(cgsl_permutation, "[]", "get"); rb_define_method(cgsl_permutation, "set", rb_gsl_permutation_set, 2); rb_define_alias(cgsl_permutation, "[]=", "set"); #ifdef GSL_1_1_LATER rb_define_singleton_method(cgsl_permutation, "memcpy", rb_gsl_permutation_memcpy, 2); rb_define_method(cgsl_permutation, "clone", rb_gsl_permutation_clone, 0); #endif rb_define_method(cgsl_permutation, "swap", rb_gsl_permutation_swap, 2); rb_define_method(cgsl_permutation, "valid", rb_gsl_permutation_valid, 0); rb_define_method(cgsl_permutation, "valid?", rb_gsl_permutation_valid2, 0); rb_define_method(cgsl_permutation, "to_a", rb_gsl_permutation_to_a, 0); rb_define_method(cgsl_permutation, "to_v", rb_gsl_permutation_to_v, 0); rb_define_method(cgsl_permutation, "reverse", rb_gsl_permutation_reverse, 0); rb_define_method(cgsl_permutation, "inverse", rb_gsl_permutation_inverse, 0); rb_define_alias(cgsl_permutation, "inv", "inverse"); rb_define_method(cgsl_permutation, "next", rb_gsl_permutation_next, 0); rb_define_method(cgsl_permutation, "prev", rb_gsl_permutation_prev, 0); rb_define_method(cgsl_permutation, "permute_vector", rb_gsl_permutation_permute_vector, 1); rb_define_alias(cgsl_permutation, "permute", "permute_vector"); rb_define_method(cgsl_permutation, "permute_vector_inverse", rb_gsl_permutation_permute_vector_inverse, 1); rb_define_alias(cgsl_permutation, "permute_inverse", "permute_vector_inverse"); rb_define_singleton_method(cgsl_permutation, "permute_vector", rb_gsl_permute_vector, 2); rb_define_singleton_method(cgsl_permutation, "permute_vector_inverse", rb_gsl_permute_vector_inverse, 2); rb_define_module_function(module, "permute_vector", rb_gsl_permute_vector, 2); rb_define_module_function(module, "permute_vector_inverse", rb_gsl_permute_vector_inverse, 2); rb_define_singleton_method(cgsl_permutation, "permute", rb_gsl_permute_vector, 2); rb_define_singleton_method(cgsl_permutation, "permute_inverse", rb_gsl_permute_vector_inverse, 2); rb_define_module_function(module, "permute", rb_gsl_permute_vector, 2); rb_define_module_function(module, "permute_inverse", rb_gsl_permute_vector_inverse, 2); rb_define_method(cgsl_permutation, "fwrite", rb_gsl_permutation_fwrite, 1); rb_define_method(cgsl_permutation, "fread", rb_gsl_permutation_fread, 1); rb_define_method(cgsl_permutation, "fprintf", rb_gsl_permutation_fprintf, -1); rb_define_method(cgsl_permutation, "printf", rb_gsl_permutation_printf, -1); rb_define_method(cgsl_permutation, "fscanf", rb_gsl_permutation_fscanf, 1); rb_define_method(cgsl_permutation, "print", rb_gsl_permutation_print, 0); #ifdef GSL_1_2_LATER rb_define_singleton_method(cgsl_permutation, "mul", rb_gsl_permutation_mul, 2); rb_define_method(cgsl_permutation, "mul", rb_gsl_permutation_mul, 2); rb_define_method(cgsl_permutation, "linear_to_canonical", rb_gsl_permutation_linear_to_canonical, -1); rb_define_alias(cgsl_permutation, "to_canonical", "linear_to_canonical"); rb_define_method(cgsl_permutation, "canonical_to_linear", rb_gsl_permutation_canonical_to_linear, -1); rb_define_alias(cgsl_permutation, "to_linear", "canonical_to_linear"); rb_define_method(cgsl_permutation, "inversions", rb_gsl_permutation_inversions, 0); rb_define_method(cgsl_permutation, "linear_cycles", rb_gsl_permutation_linear_cycles, 0); rb_define_method(cgsl_permutation, "canonical_cycles", rb_gsl_permutation_canonical_cycles, 0); #endif rb_define_method(cgsl_vector, "permute", rb_gsl_vector_permute, 1); rb_define_method(cgsl_vector, "permute_inverse", rb_gsl_vector_permute_inverse, 1); rb_define_method(cgsl_permutation, "equal?", rb_gsl_permutation_equal, 1); rb_define_alias(cgsl_permutation, "==", "equal?"); } gsl-1.15.3/ext/multifit.c0000644000175000017500000015215212220252463014551 0ustar boutilboutil/* multifit.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_fit.h" #include "rb_gsl_function.h" #include "rb_gsl_common.h" #ifdef HAVE_NDLINEAR_GSL_MULTIFIT_NDLINEAR_H #include void Init_ndlinear(VALUE module); #endif #ifndef CHECK_WORKSPACE #define CHECK_WORKSPACE(x) if(CLASS_OF(x)!=cgsl_multifit_workspace)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::MultiFit::Workspace expected)",\ rb_class2name(CLASS_OF(x))); #endif #ifndef CHECK_MULTIFIT_FUNCTION_FDF #define CHECK_MULTIFIT_FUNCTION_FDF(x) if(CLASS_OF(x)!=cgsl_multifit_function_fdf)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::MultiFit::Workspace expected)",\ rb_class2name(CLASS_OF(x))); #endif static VALUE cgsl_multifit_workspace; static VALUE cgsl_multifit_function_fdf; enum MultiFit_Solver_Type{ GSL_MULTIFIT_FDFSOLVER_LMSDER, GSL_MULTIFIT_FDFSOLVER_LMDER, }; static VALUE rb_gsl_multifit_workspace_new(VALUE klass, VALUE n, VALUE p) { gsl_multifit_linear_workspace *w = NULL; CHECK_FIXNUM(n); CHECK_FIXNUM(p); w = gsl_multifit_linear_alloc(FIX2INT(n), FIX2INT(p)); return Data_Wrap_Struct(cgsl_multifit_workspace, 0, gsl_multifit_linear_free, w); } static VALUE rb_gsl_multifit_linear(int argc, VALUE *argv, VALUE obj) { gsl_multifit_linear_workspace *space = NULL; gsl_matrix *x = NULL, *cov = NULL; gsl_vector *y = NULL, *c = NULL; double chisq; int status, flag = 0; VALUE vc, vcov; if (argc != 2 && argc != 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); Data_Get_Matrix(argv[0], x); Data_Get_Vector(argv[1], y); if (argc == 3) { CHECK_WORKSPACE(argv[2]); Data_Get_Struct(argv[2], gsl_multifit_linear_workspace, space); } else { space = gsl_multifit_linear_alloc(x->size1, x->size2); flag = 1; } cov = gsl_matrix_alloc(x->size2, x->size2); c = gsl_vector_alloc(x->size2); status = gsl_multifit_linear(x, y, c, cov, &chisq, space); if (flag == 1) gsl_multifit_linear_free(space); vc = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, c); vcov = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, cov); return rb_ary_new3(4, vc, vcov, rb_float_new(chisq), INT2FIX(status)); } static VALUE rb_gsl_multifit_wlinear(int argc, VALUE *argv, VALUE obj) { gsl_multifit_linear_workspace *space = NULL; gsl_matrix *x = NULL, *cov = NULL; gsl_vector *w = NULL, *y = NULL, *c = NULL; double chisq; int status, flag = 0; VALUE vc, vcov; if (argc != 3 && argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); Data_Get_Matrix(argv[0], x); Data_Get_Vector(argv[1], w); Data_Get_Vector(argv[2], y); if (argc == 4) { CHECK_WORKSPACE(argv[3]); Data_Get_Struct(argv[3], gsl_multifit_linear_workspace, space); } else { space = gsl_multifit_linear_alloc(x->size1, x->size2); flag = 1; } cov = gsl_matrix_alloc(x->size2, x->size2); c = gsl_vector_alloc(x->size2); status = gsl_multifit_wlinear(x, w, y, c, cov, &chisq, space); if (flag == 1) gsl_multifit_linear_free(space); vc = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, c); vcov = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, cov); return rb_ary_new3(4, vc, vcov, rb_float_new(chisq), INT2FIX(status)); } static void calc_X_power(gsl_matrix *X, gsl_vector *x, size_t order) { size_t i, j; double val; for (i = 0; i < x->size; i++) { val = 1.0; gsl_matrix_set(X, i, 0, val); for (j = 1; j <= order; j++) { val *= gsl_vector_get(x, i); gsl_matrix_set(X, i, j, val); } } } static void calc_X_legendre(gsl_matrix *X, gsl_vector *v, size_t order) { size_t i, n; double a, b, c, x; for (i = 0; i < v->size; i++) { a = 1.0; b = gsl_vector_get(v, i); gsl_matrix_set(X, i, 0, a); gsl_matrix_set(X, i, 1, b); for (n = 2; n <= order; n++) { x = gsl_vector_get(v, i); c = ((2*n-1)*x*b - (n-1)*a)/n; gsl_matrix_set(X, i, n, c); a = b; b = c; } } } static VALUE rb_gsl_multifit_XXXfit(int argc, VALUE *argv, VALUE obj, void (*fn)(gsl_matrix*, gsl_vector*,size_t)) { gsl_multifit_linear_workspace *space = NULL; gsl_matrix *X = NULL, *cov = NULL; gsl_vector *x, *y = NULL, *w, *c = NULL, *err; gsl_vector_view xx, yy, ww; size_t order, i; double chisq; int status, flag = 0, flagw = 0; VALUE vc, verr; if (argc != 3 && argc != 4 && argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); x = &xx.vector; w = &ww.vector; y = &yy.vector; Data_Get_Vector(argv[0], x); if (argc >= 3 && VECTOR_P(argv[2])) { Data_Get_Vector(argv[1], w); Data_Get_Vector(argv[2], y); order = NUM2INT(argv[3]); flagw = 1; } else { Data_Get_Vector(argv[1], y); order = NUM2INT(argv[2]); flagw = 0; } if (rb_obj_is_kind_of(argv[argc-1], cgsl_multifit_workspace)) { Data_Get_Struct(argv[argc-1], gsl_multifit_linear_workspace, space); } else { space = gsl_multifit_linear_alloc(x->size, order + 1); flag = 1; } cov = gsl_matrix_alloc(order + 1, order + 1); c = gsl_vector_alloc(order + 1); X = gsl_matrix_alloc(x->size, order + 1); (*fn)(X, x, order); if (flagw == 0) status = gsl_multifit_linear(X, y, c, cov, &chisq, space); else status = gsl_multifit_wlinear(X, w, y, c, cov, &chisq, space); if (flag == 1) gsl_multifit_linear_free(space); err = gsl_vector_alloc(order + 1); vc = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, c); verr = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, err); for (i = 0; i < err->size; i++) gsl_vector_set(err, i, sqrt(chisq/((double)x->size-err->size)*gsl_matrix_get(cov, i, i))); gsl_matrix_free(X); gsl_matrix_free(cov); return rb_ary_new3(4, vc, verr, rb_float_new(chisq), INT2FIX(status)); } static VALUE rb_gsl_multifit_polyfit(int argc, VALUE *argv, VALUE obj) { return rb_gsl_multifit_XXXfit(argc, argv, obj, calc_X_power); } static VALUE rb_gsl_multifit_legfit(int argc, VALUE *argv, VALUE obj) { return rb_gsl_multifit_XXXfit(argc, argv, obj, calc_X_legendre); } /**********/ static VALUE rb_gsl_multifit_fdfsolver_new(int argc, VALUE *argv, VALUE klass) { const gsl_multifit_fdfsolver_type *T; gsl_multifit_fdfsolver *solver = NULL; size_t n, p; char name[64]; switch (argc) { case 3: switch (TYPE(argv[0])) { case T_STRING: strcpy(name, STR2CSTR(argv[0])); if (str_tail_grep(name, "lmsder") == 0) { T = gsl_multifit_fdfsolver_lmsder; } else if (str_tail_grep(name, "lmder") == 0) { T = gsl_multifit_fdfsolver_lmder; } else { rb_raise(rb_eTypeError, "unknown solver type %s (lmsder of lmder)", name); } break; case T_FIXNUM: switch (FIX2INT(argv[0])) { case GSL_MULTIFIT_FDFSOLVER_LMSDER: T = gsl_multifit_fdfsolver_lmsder; break; case GSL_MULTIFIT_FDFSOLVER_LMDER: T = gsl_multifit_fdfsolver_lmder; break; default: rb_raise(rb_eTypeError, "unknown solver type (GSL::MultiFit::FdfSolver::LMSDER or LMDER expected)"); break; } break; default: rb_raise(rb_eTypeError, "wrong argument type %s (Fixnum or String)", rb_class2name(CLASS_OF(argv[0]))); break; } CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); n = FIX2INT(argv[1]); p = FIX2INT(argv[2]); break; case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); T = gsl_multifit_fdfsolver_lmsder; n = FIX2INT(argv[0]); p = FIX2INT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } solver = gsl_multifit_fdfsolver_alloc(T, n, p); return Data_Wrap_Struct(klass, 0, gsl_multifit_fdfsolver_free, solver); } static VALUE rb_gsl_multifit_fdfsolver_set(VALUE obj, VALUE ff, VALUE xx) { gsl_multifit_fdfsolver *solver = NULL; gsl_multifit_function_fdf *f = NULL; gsl_vector *x = NULL; int status; CHECK_MULTIFIT_FUNCTION_FDF(ff); Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); Data_Get_Struct(ff, gsl_multifit_function_fdf, f); Data_Get_Vector(xx, x); status = gsl_multifit_fdfsolver_set(solver, f, x); return INT2FIX(status); } static VALUE rb_gsl_multifit_fdfsolver_name(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return rb_str_new2(gsl_multifit_fdfsolver_name(solver)); } static VALUE rb_gsl_multifit_fdfsolver_iterate(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return INT2FIX(gsl_multifit_fdfsolver_iterate(solver)); } static VALUE rb_gsl_multifit_fdfsolver_position(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; gsl_vector *x = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); x = gsl_multifit_fdfsolver_position(solver); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, x); } static VALUE rb_gsl_multifit_fdfsolver_print_state(VALUE obj, VALUE i) { gsl_multifit_fdfsolver *solver = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); printf("iter: %d x = %15.8f %15.8f %15.8f |f(x)| = %g\n", (int) FIX2INT(i), gsl_vector_get(solver->x, 0), gsl_vector_get(solver->x, 1), gsl_vector_get(solver->x, 2), gsl_blas_dnrm2(solver->f)); return Qtrue; } static VALUE rb_gsl_multifit_fdfsolver_fdf(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return Data_Wrap_Struct(cgsl_multifit_function_fdf, 0, NULL, solver->fdf); } static VALUE rb_gsl_multifit_fdfsolver_test_delta(VALUE obj, VALUE r, VALUE a) { gsl_multifit_fdfsolver *solver = NULL; Need_Float(r); Need_Float(a); Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return INT2FIX(gsl_multifit_test_delta(solver->dx, solver->x, NUM2DBL(r), NUM2DBL(a))); } static VALUE rb_gsl_multifit_fdfsolver_test_gradient(int argc, VALUE *argv, VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; gsl_vector *g = NULL; int status; double epsabs; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); switch (argc) { case 1: Need_Float(argv[0]); g = gsl_vector_alloc(solver->x->size); gsl_multifit_gradient(solver->J, solver->f, g); epsabs = NUM2DBL(argv[0]); status = gsl_multifit_test_gradient(g, epsabs); gsl_vector_free(g); break; case 2: Need_Float(argv[1]); Data_Get_Vector(argv[0], g); epsabs = NUM2DBL(argv[1]); status = gsl_multifit_test_gradient(g, epsabs); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } return INT2FIX(status); } static VALUE rb_gsl_multifit_fdfsolver_gradient(int argc, VALUE *argv, VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; gsl_vector *g = NULL; // local variable "status" declared and set, but never used //int status; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); if (argc == 1) { Data_Get_Vector(argv[0], g); return INT2FIX(gsl_multifit_gradient(solver->J, solver->f, g)); } else { g = gsl_vector_alloc(solver->x->size); /*status =*/ gsl_multifit_gradient(solver->J, solver->f, g); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, g); } } static VALUE rb_gsl_multifit_fdfsolver_covar(int argc, VALUE *argv, VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; gsl_matrix *covar = NULL; double epsrel; // local variable "status" declared and set, but never used //int status; if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); Need_Float(argv[0]); Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); epsrel = NUM2DBL(argv[0]); switch (argc) { case 1: covar = gsl_matrix_alloc(solver->x->size, solver->x->size); /*status =*/ gsl_multifit_covar(solver->J, epsrel, covar); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, covar); break; case 2: Data_Get_Matrix(argv[1], covar); return INT2FIX(gsl_multifit_covar(solver->J, epsrel, covar)); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } } static VALUE rb_gsl_multifit_fdfsolver_x(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, solver->x); } static VALUE rb_gsl_multifit_fdfsolver_dx(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, solver->dx); } static VALUE rb_gsl_multifit_fdfsolver_f(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, solver->f); } static VALUE rb_gsl_multifit_fdfsolver_J(VALUE obj) { gsl_multifit_fdfsolver *solver = NULL; Data_Get_Struct(obj, gsl_multifit_fdfsolver, solver); return Data_Wrap_Struct(cgsl_matrix_view_ro, 0, NULL, solver->J); } /* singleton */ static VALUE rb_gsl_multifit_test_delta(VALUE obj, VALUE ddx, VALUE xx, VALUE a, VALUE r) { gsl_vector *dx = NULL, *x = NULL; Need_Float(a); Need_Float(r); Data_Get_Vector(ddx, dx); Data_Get_Vector(xx, x); return INT2FIX(gsl_multifit_test_delta(dx, x, NUM2DBL(a), NUM2DBL(r))); } static VALUE rb_gsl_multifit_test_gradient(VALUE obj, VALUE gg, VALUE a) { gsl_vector *g = NULL; Need_Float(a); Data_Get_Vector(gg, g); return INT2FIX(gsl_multifit_test_gradient(g, NUM2DBL(a))); } static VALUE rb_gsl_multifit_gradient(int argc, VALUE *argv, VALUE obj) { gsl_vector *g = NULL, *f = NULL; gsl_matrix *J = NULL; // local variable "status" declared and set, but never used //int status; switch (argc) { case 2: Data_Get_Matrix(argv[0], J); Data_Get_Vector(argv[1], f); g = gsl_vector_alloc(f->size); /*status =*/ gsl_multifit_gradient(J, f, g); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, g); break; case 3: Data_Get_Matrix(argv[0], J); Data_Get_Vector(argv[1], f); Data_Get_Vector(argv[2], g); return INT2FIX(gsl_multifit_gradient(J, f, g)); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } } static VALUE rb_gsl_multifit_covar(int argc, VALUE *argv, VALUE obj) { gsl_matrix *J = NULL, *covar = NULL; double epsrel; int status; switch (argc) { case 2: Need_Float(argv[1]); Data_Get_Matrix(argv[0], J); epsrel = NUM2DBL(argv[1]); covar = gsl_matrix_alloc(J->size2, J->size2); /*status =*/ gsl_multifit_covar(J, epsrel, covar); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, covar); break; case 3: Need_Float(argv[1]); Data_Get_Matrix(argv[0], J); epsrel = NUM2DBL(argv[1]); Data_Get_Matrix(argv[2], covar); status = gsl_multifit_covar(J, epsrel, covar); return INT2FIX(status); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } } static void rb_gsl_multifit_define_const(VALUE klass) { rb_define_const(klass, "LMSDER", INT2FIX(GSL_MULTIFIT_FDFSOLVER_LMSDER)); rb_define_const(klass, "LMDER", INT2FIX(GSL_MULTIFIT_FDFSOLVER_LMDER)); rb_define_const(klass, "Lmsder", INT2FIX(GSL_MULTIFIT_FDFSOLVER_LMSDER)); rb_define_const(klass, "Lmder", INT2FIX(GSL_MULTIFIT_FDFSOLVER_LMDER)); } static void gsl_multifit_function_fdf_free(gsl_multifit_function_fdf *f); static void gsl_multifit_function_fdf_free(gsl_multifit_function_fdf *f) { free((gsl_multifit_function_fdf *) f); } static void gsl_multifit_function_fdf_mark(gsl_multifit_function_fdf *F); static void gsl_multifit_function_fdf_mark(gsl_multifit_function_fdf *F) { rb_gc_mark((VALUE) F->params); } static int gsl_multifit_function_fdf_f(const gsl_vector *x, void *params, gsl_vector *f); static int gsl_multifit_function_fdf_df(const gsl_vector *x, void *params, gsl_matrix *J); static int gsl_multifit_function_fdf_fdf(const gsl_vector *x, void *params, gsl_vector *f, gsl_matrix *J); static VALUE rb_gsl_multifit_function_fdf_set_procs(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_multifit_function_fdf_new(int argc, VALUE *argv, VALUE klass) { gsl_multifit_function_fdf *func = NULL; VALUE obj; func = ALLOC(gsl_multifit_function_fdf); func->f = &gsl_multifit_function_fdf_f; func->df = &gsl_multifit_function_fdf_df; func->fdf = &gsl_multifit_function_fdf_fdf; func->params = NULL; obj = Data_Wrap_Struct(klass, gsl_multifit_function_fdf_mark, gsl_multifit_function_fdf_free, func); switch (argc) { case 0: case 1: break; case 2: case 3: rb_gsl_multifit_function_fdf_set_procs(argc, argv, obj); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-3)", argc); break; } return obj; } static VALUE rb_gsl_multifit_function_fdf_set_procs(int argc, VALUE *argv, VALUE obj) { gsl_multifit_function_fdf *func = NULL; VALUE ary; Data_Get_Struct(obj, gsl_multifit_function_fdf, func); if (func->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) func->params = ary;*/ func->params = (void *) ary; } else { ary = (VALUE) func->params; } rb_ary_store(ary, 0, argv[0]); rb_ary_store(ary, 1, argv[1]); switch (argc) { case 2: break; case 3: if (TYPE(argv[2]) == T_FIXNUM) { func->p = FIX2INT(argv[2]); rb_ary_store(ary, 2, Qnil); } else rb_ary_store(ary, 2, argv[2]); break; case 4: if (TYPE(argv[2]) == T_FIXNUM) { func->p = FIX2INT(argv[2]); rb_ary_store(ary, 2, argv[3]); } else { func->p = FIX2INT(argv[3]); rb_ary_store(ary, 2, argv[2]); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); break; } return obj; } static VALUE rb_gsl_multifit_function_fdf_set_data(int argc, VALUE *argv, VALUE obj) { VALUE ary, ary2; gsl_multifit_function_fdf *func = NULL; Data_Get_Struct(obj, gsl_multifit_function_fdf, func); if (func->params == NULL) { ary = rb_ary_new2(4); /* (VALUE) func->params = ary;*/ func->params = (void *) ary; } else { ary = (VALUE) func->params; } switch (argc) { case 2: ary2 = rb_ary_new3(2, argv[0], argv[1]); /* t, y */ break; case 3: ary2 = rb_ary_new3(3, argv[0], argv[1], argv[2]); /* t, y, sigma */ break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } func->n = NUM2INT(rb_funcall(argv[0], rb_intern("size"), 0)); rb_ary_store(ary, 3, ary2); return obj; } static int gsl_multifit_function_fdf_f(const gsl_vector *x, void *params, gsl_vector *f) { VALUE vt_y_sigma, vt, vy, vsigma, vf, vx, proc, ary; ary = (VALUE) params; vt_y_sigma = rb_ary_entry(ary, 3); proc = rb_ary_entry(ary, 0); vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vf = Data_Wrap_Struct(cgsl_vector, 0, NULL, f); switch (RARRAY_LEN(vt_y_sigma)) { case 2: vt = rb_ary_entry(vt_y_sigma, 0); vy = rb_ary_entry(vt_y_sigma, 1); rb_funcall(proc, RBGSL_ID_call, 4, vx, vt, vy, vf); break; case 3: vt = rb_ary_entry(vt_y_sigma, 0); vy = rb_ary_entry(vt_y_sigma, 1); vsigma = rb_ary_entry(vt_y_sigma,2); rb_funcall(proc, RBGSL_ID_call, 5, vx, vt, vy, vsigma, vf); break; default: rb_raise(rb_eArgError, "bad argument"); break; } return GSL_SUCCESS; } static int gsl_multifit_function_fdf_df(const gsl_vector *x, void *params, gsl_matrix *J) { VALUE vt_y_sigma, vt, vy, vsigma, vJ, vx, proc, ary; ary = (VALUE) params; vt_y_sigma = rb_ary_entry(ary, 3); proc = rb_ary_entry(ary, 1); vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vJ = Data_Wrap_Struct(cgsl_matrix, 0, NULL, J); switch (RARRAY_LEN(vt_y_sigma)) { case 2: vt = rb_ary_entry(vt_y_sigma, 0); vy = rb_ary_entry(vt_y_sigma, 1); rb_funcall(proc, RBGSL_ID_call, 4, vx, vt, vy, vJ); break; case 3: vt = rb_ary_entry(vt_y_sigma, 0); vy = rb_ary_entry(vt_y_sigma, 1); vsigma = rb_ary_entry(vt_y_sigma,2); rb_funcall(proc, RBGSL_ID_call, 5, vx, vt, vy, vsigma, vJ); break; default: rb_raise(rb_eArgError, "bad argument"); break; } return GSL_SUCCESS; } static int gsl_multifit_function_fdf_fdf(const gsl_vector *x, void *params, gsl_vector *f, gsl_matrix *J) { VALUE vt_y_sigma, vt, vy, vsigma, vf, vJ, vx, proc_f, proc_df, proc_fdf; VALUE ary; ary = (VALUE) params; vt_y_sigma = rb_ary_entry(ary, 3); proc_f = rb_ary_entry(ary, 0); proc_df = rb_ary_entry(ary, 1); proc_fdf = rb_ary_entry(ary, 2); vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x); vf = Data_Wrap_Struct(cgsl_vector, 0, NULL, f); vJ = Data_Wrap_Struct(cgsl_matrix, 0, NULL, J); switch (RARRAY_LEN(vt_y_sigma)) { case 2: vt = rb_ary_entry(vt_y_sigma, 0); vy = rb_ary_entry(vt_y_sigma, 1); if (NIL_P(proc_fdf)) { rb_funcall(proc_f, RBGSL_ID_call, 4, vx, vt, vy, vf); rb_funcall(proc_df, RBGSL_ID_call, 4, vx, vt, vy, vJ); } else rb_funcall(proc_fdf, RBGSL_ID_call, 5, vx, vt, vy, vf, vJ); break; case 3: vt = rb_ary_entry(vt_y_sigma, 0); vy = rb_ary_entry(vt_y_sigma, 1); vsigma = rb_ary_entry(vt_y_sigma,2); if (NIL_P(proc_fdf)) { rb_funcall(proc_f, RBGSL_ID_call, 5, vx, vt, vy, vsigma, vf); rb_funcall(proc_df, RBGSL_ID_call, 5, vx, vt, vy, vsigma, vJ); } else rb_funcall(proc_fdf, RBGSL_ID_call, 6, vx, vt, vy, vsigma, vf, vJ); break; default: rb_raise(rb_eArgError, "bad argument"); break; } return GSL_SUCCESS; } static VALUE rb_gsl_multifit_function_fdf_params(VALUE obj) { gsl_multifit_function_fdf *f = NULL; Data_Get_Struct(obj, gsl_multifit_function_fdf, f); return (VALUE) f->params; } static VALUE rb_gsl_multifit_function_fdf_n(VALUE obj) { gsl_multifit_function_fdf *f = NULL; Data_Get_Struct(obj, gsl_multifit_function_fdf, f); return INT2FIX(f->n); } static VALUE rb_gsl_multifit_function_fdf_set_n(VALUE obj, VALUE n) { gsl_multifit_function_fdf *f = NULL; Data_Get_Struct(obj, gsl_multifit_function_fdf, f); f->n = FIX2INT(n); return obj; } static VALUE rb_gsl_multifit_function_fdf_p(VALUE obj) { gsl_multifit_function_fdf *f = NULL; Data_Get_Struct(obj, gsl_multifit_function_fdf, f); return INT2FIX(f->p); } /*****/ struct fitting_xydata { gsl_vector *x, *y, *w; }; /* Gaussian fit y = y0 + A exp(-(x-x0/sigma)^2) v[0] = y0 v[1] = A v[2] = x0 v[3] = var = sigma^2 */ static int Gaussian_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A, x0, var, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; var = gsl_vector_get(v, 3); x0 = gsl_vector_get(v, 2); A = gsl_vector_get(v, 1); y0 = gsl_vector_get(v, 0); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); yi = gsl_vector_get(y, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; gsl_vector_set(f, i, (A*exp(-(xi - x0)*(xi - x0)/var/2.0) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Gaussian_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A, x0, var, xi, yy, wi; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; var = gsl_vector_get(v, 3); x0 = gsl_vector_get(v, 2); A = gsl_vector_get(v, 1); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yy = exp(-(xi - x0)*(xi - x0)/var/2.0); gsl_matrix_set(J, i, 3, A*yy*(xi - x0)*(xi - x0)/2/var/var*wi); gsl_matrix_set(J, i, 2, A*yy*(xi - x0)/var*wi); gsl_matrix_set(J, i, 1, yy*wi); gsl_matrix_set(J, i, 0, 1.0*wi); } return GSL_SUCCESS; } static int Gaussian_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Gaussian_f(v, data, f); Gaussian_df(v, data, J); return GSL_SUCCESS; } /* 2 Gaussian fit y = y0 + A1 exp(-(x-x01/sigma1)^2) + A2 exp(-(x-x02/sigma2)^2) v[0] = y0 v[1] = A1 v[2] = x01 v[3] = var1 = sigma1^2 v[4] = A2 v[5] = x02 v[6] = var2 = sigma2^2 */ static int Gaussian_2peaks_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A1, x01, var1, A2, x02, var2, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); A1 = gsl_vector_get(v, 1); x01 = gsl_vector_get(v, 2); var1 = gsl_vector_get(v, 3); A2 = gsl_vector_get(v, 4); x02 = gsl_vector_get(v, 5); var2 = gsl_vector_get(v, 6); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); yi = gsl_vector_get(y, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; gsl_vector_set(f, i, (A1*exp(-(xi - x01)*(xi - x01)/var1/2.0) + A2*exp(-(xi - x02)*(xi - x02)/var2/2.0) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Gaussian_2peaks_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A1, x01, var1, A2, x02, var2, xi, yy, wi; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; A1 = gsl_vector_get(v, 1); x01 = gsl_vector_get(v, 2); var1 = gsl_vector_get(v, 3); A2 = gsl_vector_get(v, 4); x02 = gsl_vector_get(v, 5); var2 = gsl_vector_get(v, 6); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yy = exp(-(xi - x01)*(xi - x01)/var1/2.0); gsl_matrix_set(J, i, 0, 1.0*wi); gsl_matrix_set(J, i, 1, yy*wi); gsl_matrix_set(J, i, 2, A1*yy*(xi - x01)/var1*wi); gsl_matrix_set(J, i, 3, A1*yy*(xi - x01)*(xi - x01)/2/var1/var1*wi); yy = exp(-(xi - x02)*(xi - x02)/var2/2.0); gsl_matrix_set(J, i, 4, yy*wi); gsl_matrix_set(J, i, 5, A2*yy*(xi - x02)/var2*wi); gsl_matrix_set(J, i, 6, A2*yy*(xi - x02)*(xi - x02)/2/var2/var2*wi); } return GSL_SUCCESS; } static int Gaussian_2peaks_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Gaussian_2peaks_f(v, data, f); Gaussian_2peaks_df(v, data, J); return GSL_SUCCESS; } /* Exponential fit y = y0 + A exp(-bx) v[0] = y0 v[1] = A v[2] = b */ static int Exponential_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A, b, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); A = gsl_vector_get(v, 1); b = gsl_vector_get(v, 2); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, (A*exp(-b*xi) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Exponential_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A, b, xi, yy, wi; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; A = gsl_vector_get(v, 1); b = gsl_vector_get(v, 2); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yy = exp(-xi*b); gsl_matrix_set(J, i, 0, 1.0*wi); gsl_matrix_set(J, i, 1, yy*wi); gsl_matrix_set(J, i, 2, -A*yy*xi*wi); } return GSL_SUCCESS; } static int Exponential_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Exponential_f(v, data, f); Exponential_df(v, data, J); return GSL_SUCCESS; } /* Double Exponential fit y = y0 + A1 exp(-b1 x) + A2 exp(-b2 x) v[0] = y0 v[1] = A1 v[2] = b1 v[3] = A2 v[4] = b2 */ static int DblExponential_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A1, b1, A2, b2, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); A1 = gsl_vector_get(v, 1); b1 = gsl_vector_get(v, 2); A2 = gsl_vector_get(v, 3); b2 = gsl_vector_get(v, 4); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, (A1*exp(-b1*xi) + A2*exp(-b2*xi) + y0 - yi)*wi); } return GSL_SUCCESS; } static int DblExponential_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A1, b1, A2, b2, xi, yy1, yy2, wi; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; A1 = gsl_vector_get(v, 1); b1 = gsl_vector_get(v, 2); A2 = gsl_vector_get(v, 3); b2 = gsl_vector_get(v, 4); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yy1 = exp(-xi*b1); yy2 = exp(-xi*b2); gsl_matrix_set(J, i, 0, 1.0*wi); gsl_matrix_set(J, i, 1, yy1*wi); gsl_matrix_set(J, i, 2, -A1*yy1*xi*wi); gsl_matrix_set(J, i, 3, yy2*wi); gsl_matrix_set(J, i, 4, -A2*yy2*xi*wi); } return GSL_SUCCESS; } static int DblExponential_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { DblExponential_f(v, data, f); DblExponential_df(v, data, J); return GSL_SUCCESS; } /* Lorentzian fit y = y0 + A/((x-x0)^2 + B) v[0] = y0 v[1] = A v[2] = x0 v[3] = B */ static int Lorentzian_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A, x0, B, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); A = gsl_vector_get(v, 1); x0 = gsl_vector_get(v, 2); B = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, (A/(gsl_pow_2(xi-x0)+B) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Lorentzian_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A, B, x0, xi, yy, wi; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; A = gsl_vector_get(v, 1); x0 = gsl_vector_get(v, 2); B = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yy = gsl_pow_2(xi-x0)+B; gsl_matrix_set(J, i, 0, 1.0*wi); gsl_matrix_set(J, i, 1, 1.0/yy*wi); gsl_matrix_set(J, i, 2, 2.0*A*(xi-x0)/yy/yy*wi); gsl_matrix_set(J, i, 3, -A/yy/yy*wi); } return GSL_SUCCESS; } static int Lorentzian_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Lorentzian_f(v, data, f); Lorentzian_df(v, data, J); return GSL_SUCCESS; } /* Sinusoldal fit y = y0 + A sin(fc x + phi) v[0] = y0 v[1] = A v[2] = fc v[3] = phi */ static int Sin_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A, fc, phi, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); A = gsl_vector_get(v, 1); fc = gsl_vector_get(v, 2); phi = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, (A*sin(fc*xi+phi) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Sin_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A, fc, phi, xi, ys, yc, wi; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; A = gsl_vector_get(v, 1); fc = gsl_vector_get(v, 2); phi = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; ys = sin(fc*xi + phi); yc = cos(fc*xi + phi); gsl_matrix_set(J, i, 0, 1.0*wi); gsl_matrix_set(J, i, 1, ys*wi); gsl_matrix_set(J, i, 2, A*yc*xi*wi); gsl_matrix_set(J, i, 3, A*yc*wi); } return GSL_SUCCESS; } static int Sin_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Sin_f(v, data, f); Sin_df(v, data, J); return GSL_SUCCESS; } /* Hill's equation fit y = y0 + (m - y0)/(1 + (xhalf/x)^r) v[0] = y0 v[1] = m v[2] = xhalf v[3] = r */ static int Hill_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, m, xhalf, r, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); m = gsl_vector_get(v, 1); xhalf = gsl_vector_get(v, 2); r = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, ((m-y0)/(1.0+pow(xhalf/xi, r)) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Hill_df(const gsl_vector *v, void *data, gsl_matrix *J) { double y0, m, xhalf, r, yy, xi, wi, a; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; y0 = gsl_vector_get(v, 0); m = gsl_vector_get(v, 1); xhalf = gsl_vector_get(v, 2); r = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; a = pow(xhalf/xi, r); yy = (1.0 + a); gsl_matrix_set(J, i, 0, (1.0 - 1.0/yy)*wi); gsl_matrix_set(J, i, 1, 1.0/yy*wi); gsl_matrix_set(J, i, 2, -(m-y0)*r/xhalf*a/yy/yy*wi); gsl_matrix_set(J, i, 3, -(m-y0)/yy/yy*a*log(xhalf/xi)*wi); } return GSL_SUCCESS; } static int Hill_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Hill_f(v, data, f); Hill_df(v, data, J); return GSL_SUCCESS; } /* Sigmoidal fit y = y0 + m/(1 + exp((x0-x)/r)) v[0] = y0 v[1] = m v[2] = x0 v[3] = r */ static int Sigmoid_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, m, x0, r, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); m = gsl_vector_get(v, 1); x0 = gsl_vector_get(v, 2); r = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, (m/(1.0+exp((x0-xi)/r)) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Sigmoid_df(const gsl_vector *v, void *data, gsl_matrix *J) { double m, x0, r, xi, wi, a, yy; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; m = gsl_vector_get(v, 1); x0 = gsl_vector_get(v, 2); r = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; a = exp((x0 - xi)/r); yy = 1.0 + a; gsl_matrix_set(J, i, 0, wi); gsl_matrix_set(J, i, 1, 1.0/yy*wi); gsl_matrix_set(J, i, 2, -m*a/r/yy/yy*wi); gsl_matrix_set(J, i, 3, m*a*(x0-xi)/r/r/yy/yy*wi); } return GSL_SUCCESS; } static int Sigmoid_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Sigmoid_f(v, data, f); Sigmoid_df(v, data, J); return GSL_SUCCESS; } /* Power-law fit y = y0 + A x^r v[0] = y0 v[1] = A v[2] = r */ static int Power_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A, r, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); A = gsl_vector_get(v, 1); r = gsl_vector_get(v, 2); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, (A*pow(xi, r) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Power_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A, r, xi, wi, a; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; A = gsl_vector_get(v, 1); r = gsl_vector_get(v, 2); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; a = pow(xi, r); gsl_matrix_set(J, i, 0, wi); gsl_matrix_set(J, i, 1, a*wi); gsl_matrix_set(J, i, 2, A*a*log(xi)*wi); } return GSL_SUCCESS; } static int Power_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Power_f(v, data, f); Power_df(v, data, J); return GSL_SUCCESS; } /* Lognormal fit y = y0 + A exp[ -(log(x/x0)/width)^2 ] v[0] = y0 v[1] = A v[2] = x0 v[3] = width */ static int Lognormal_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double y0, A, x0, width, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; y0 = gsl_vector_get(v, 0); A = gsl_vector_get(v, 1); x0 = gsl_vector_get(v, 2); width = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yi = gsl_vector_get(y, i); gsl_vector_set(f, i, (A*exp(-gsl_pow_2(log(xi/x0)/width)) + y0 - yi)*wi); } return GSL_SUCCESS; } static int Lognormal_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A, x0, width, xi, wi, a, b; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; A = gsl_vector_get(v, 1); x0 = gsl_vector_get(v, 2); width = gsl_vector_get(v, 3); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; a = log(xi/x0)/width; b = exp(-a*a); gsl_matrix_set(J, i, 0, wi); gsl_matrix_set(J, i, 1, b*wi); gsl_matrix_set(J, i, 2, 2.0*A*b*a*a*a/width/x0*wi); gsl_matrix_set(J, i, 3, 2.0*A*b*a*a*a*a/width*wi); } return GSL_SUCCESS; } static int Lognormal_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Lognormal_f(v, data, f); Lognormal_df(v, data, J); return GSL_SUCCESS; } /* Rayleigh fit y = A exp(-x*x/2/var) v[0] = A v[1] = var = sigma^2 */ static int Rayleigh_f(const gsl_vector *v, void *data, gsl_vector *f) { gsl_vector *x, *y, *w; double A, var, xi, yi, wi; size_t i; struct fitting_xydata *xydata; xydata = (struct fitting_xydata*) data; x = xydata->x; y = xydata->y; w = xydata->w; var = gsl_vector_get(v, 1); A = gsl_vector_get(v, 0); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); yi = gsl_vector_get(y, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; gsl_vector_set(f, i, (A*xi*exp(-xi*xi/var/2.0) - yi)*wi); } return GSL_SUCCESS; } static int Rayleigh_df(const gsl_vector *v, void *data, gsl_matrix *J) { double A, var, xi, yy, wi; size_t i; struct fitting_xydata *xydata; gsl_vector *x, *w; xydata = (struct fitting_xydata*) data; x = xydata->x; w = xydata->w; var = gsl_vector_get(v, 1); A = gsl_vector_get(v, 0); for (i = 0; i < x->size; i++) { xi = gsl_vector_get(x, i); if (w) wi = gsl_vector_get(w, i); else wi = 1.0; yy = xi*exp(-xi*xi/var/2.0); gsl_matrix_set(J, i, 1, A*yy*xi*xi/2/var/var*wi); gsl_matrix_set(J, i, 0, yy*wi); } return GSL_SUCCESS; } static int Rayleigh_fdf(const gsl_vector *v, void *data, gsl_vector *f, gsl_matrix *J) { Rayleigh_f(v, data, f); Rayleigh_df(v, data, J); return GSL_SUCCESS; } static void set_fittype(gsl_multifit_function_fdf *f, const char *fittype, size_t *p, gsl_vector **v, int *flag) { if (str_tail_grep(fittype, "aussian_2peaks") == 0) { f->f = Gaussian_2peaks_f; f->df = Gaussian_2peaks_df; f->fdf = Gaussian_2peaks_fdf; *p = 7; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); /* y0 = 0 */ gsl_vector_set(*v, 1, 1); /* A = 1 */ gsl_vector_set(*v, 2, 0.0); /* x0 = 0 */ gsl_vector_set(*v, 3, 1); /* initial values, var = 1 */ gsl_vector_set(*v, 4, 1); /* A = 1 */ gsl_vector_set(*v, 5, 1.0); /* x0 = 1 */ gsl_vector_set(*v, 6, 1); /* initial values, var = 1 */ *flag = 1; } } else if (str_head_grep(fittype, "gaus") == 0) { f->f = Gaussian_f; f->df = Gaussian_df; f->fdf = Gaussian_fdf; *p = 4; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 3, 1); /* initial values, var = 1 */ gsl_vector_set(*v, 2, 0.0); /* x0 = 0 */ gsl_vector_set(*v, 1, 1); /* A = 1 */ gsl_vector_set(*v, 0, 0); /* y0 = 0 */ *flag = 1; } } else if (str_head_grep(fittype, "exp") == 0) { f->f = Exponential_f; f->df = Exponential_df; f->fdf = Exponential_fdf; *p = 3; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); /* y0 = 0 */ gsl_vector_set(*v, 1, 1); /* A = 1 */ gsl_vector_set(*v, 2, 1); *flag = 1; } } else if (str_head_grep(fittype, "rayleigh") == 0) { f->f = Rayleigh_f; f->df = Rayleigh_df; f->fdf = Rayleigh_fdf; *p = 2; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 1); /* A = 1 */ gsl_vector_set(*v, 1, 1); /* sigma = 1 */ *flag = 1; } } else if (str_head_grep(fittype, "dblexp") == 0) { f->f = DblExponential_f; f->df = DblExponential_df; f->fdf = DblExponential_fdf; *p = 5; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); /* y0 = 0 */ gsl_vector_set(*v, 1, 1); /* A = 1 */ gsl_vector_set(*v, 2, 1); gsl_vector_set(*v, 3, 1); /* A = 1 */ gsl_vector_set(*v, 4, 1); *flag = 1; } } else if (str_head_grep(fittype, "lor") == 0) { f->f = Lorentzian_f; f->df = Lorentzian_df; f->fdf = Lorentzian_fdf; *p = 4; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); gsl_vector_set(*v, 1, 1); gsl_vector_set(*v, 2, 0); gsl_vector_set(*v, 3, 1); *flag = 1; } } else if (str_head_grep(fittype, "sin") == 0) { f->f = Sin_f; f->df = Sin_df; f->fdf = Sin_fdf; *p = 4; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); gsl_vector_set(*v, 1, 1); gsl_vector_set(*v, 2, 1); gsl_vector_set(*v, 3, 0); *flag = 1; } } else if (str_head_grep(fittype, "hill") == 0) { f->f = Hill_f; f->df = Hill_df; f->fdf = Hill_fdf; *p = 4; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); gsl_vector_set(*v, 1, 1); gsl_vector_set(*v, 2, 1); gsl_vector_set(*v, 3, 1); *flag = 1; } } else if (str_head_grep(fittype, "sigmoid") == 0 || str_head_grep(fittype, "fermi") == 0) { f->f = Sigmoid_f; f->df = Sigmoid_df; f->fdf = Sigmoid_fdf; *p = 4; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); gsl_vector_set(*v, 1, 1); gsl_vector_set(*v, 2, 0); gsl_vector_set(*v, 3, 1); *flag = 1; } } else if (str_head_grep(fittype, "power") == 0) { f->f = Power_f; f->df = Power_df; f->fdf = Power_fdf; *p = 3; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); gsl_vector_set(*v, 1, 1); gsl_vector_set(*v, 2, -1); *flag = 1; } } else if (str_head_grep(fittype, "lognormal") == 0) { f->f = Lognormal_f; f->df = Lognormal_df; f->fdf = Lognormal_fdf; *p = 4; if (*v == NULL) { *v = gsl_vector_alloc(*p); gsl_vector_set(*v, 0, 0); gsl_vector_set(*v, 1, 1); gsl_vector_set(*v, 2, 1); gsl_vector_set(*v, 3, 1); *flag = 1; } } else { rb_raise(rb_eRuntimeError, "Unknown fit type (gaussian expected)"); } } /* Singleton method */ static VALUE rb_gsl_multifit_fit(int argc, VALUE *argv, VALUE klass) { const gsl_multifit_fdfsolver_type *T; gsl_multifit_fdfsolver *solver; int status; size_t iter = 0, i; size_t n, dof; /* # of data points */ size_t p; /* # of fitting parameters */ gsl_multifit_function_fdf f; gsl_matrix *covar = NULL; gsl_vector *v = NULL; gsl_vector *x, *y, *w = NULL; gsl_vector_view xx, yy, ww; gsl_vector *vout, *verr; int flag = 0; double chi2; char fittype[256]; struct fitting_xydata xydata; if (argc < 3) rb_raise(rb_eArgError, "too few arguments"); switch (TYPE(argv[argc-1])) { case T_ARRAY: v = get_vector(argv[argc-1]); flag = 1; argc--; break; case T_STRING: /* do nothing */ break; default: Data_Get_Vector(argv[argc-1], v); flag = 0; argc--; break; } x = &xx.vector; y = &yy.vector; w = &ww.vector; switch (argc) { case 3: Data_Get_Vector(argv[0], x); Data_Get_Vector(argv[1], y); w = NULL; strcpy(fittype, STR2CSTR(argv[2])); break; case 4: Data_Get_Vector(argv[0], x); Data_Get_Vector(argv[1], w); Data_Get_Vector(argv[2], y); strcpy(fittype, STR2CSTR(argv[3])); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); break; } xydata.x = x; xydata.y = y; xydata.w = w; n = x->size; set_fittype(&f, fittype, &p, &v, &flag); f.n = n; f.p = p; f.params = &xydata; T = gsl_multifit_fdfsolver_lmsder; solver = gsl_multifit_fdfsolver_alloc(T, n, p); gsl_multifit_fdfsolver_set(solver, &f, v); do { iter++; status = gsl_multifit_fdfsolver_iterate(solver); if (status) break; status = gsl_multifit_test_delta(solver->dx, solver->x, 1e-6, 1e-6); } while (status == GSL_CONTINUE); vout = gsl_vector_alloc(p); verr = gsl_vector_alloc(p); gsl_vector_memcpy(vout, solver->x); covar = gsl_matrix_alloc(p, p); chi2 = gsl_pow_2(gsl_blas_dnrm2(solver->f)); /* not reduced chi-square */ dof = n - p; gsl_multifit_covar(solver->J, 0.0, covar); for (i = 0; i < p; i++) gsl_vector_set(verr, i, sqrt(chi2/dof*gsl_matrix_get(covar, i, i))); gsl_matrix_free(covar); if (flag == 1) gsl_vector_free(v); gsl_multifit_fdfsolver_free(solver); return rb_ary_new3(4, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vout), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr), rb_float_new(chi2), INT2FIX(dof)); } #ifdef GSL_1_8_LATER static VALUE rb_gsl_multifit_linear_est(VALUE module, VALUE xx, VALUE cc, VALUE ccov) { gsl_vector *x, *c; gsl_matrix *cov; double y, y_err; Data_Get_Vector(xx, x); Data_Get_Vector(cc, c); Data_Get_Matrix(ccov, cov); gsl_multifit_linear_est(x, c, cov, &y, &y_err); return rb_ary_new3(2, rb_float_new(y), rb_float_new(y_err)); } #endif #ifdef GSL_1_11_LATER static VALUE rb_gsl_multifit_linear_residuals(int argc, VALUE argv[], VALUE module) { gsl_vector *y, *c, *r; gsl_matrix *X; VALUE ret; switch (argc) { case 3: Data_Get_Matrix(argv[0], X); Data_Get_Vector(argv[1], y); Data_Get_Vector(argv[2], c); r = gsl_vector_alloc(y->size); ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r); break; case 4: Data_Get_Matrix(argv[0], X); Data_Get_Vector(argv[1], y); Data_Get_Vector(argv[2], c); Data_Get_Vector(argv[3], r); ret = argv[3]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments %d (3 or 4).\n", argc); } gsl_multifit_linear_residuals(X, y, c, r); return ret; } #endif void Init_gsl_multifit(VALUE module) { VALUE mgsl_multifit; VALUE cgsl_multifit_fdfsolver; VALUE cgsl_multifit_solver; mgsl_multifit = rb_define_module_under(module, "MultiFit"); cgsl_multifit_workspace = rb_define_class_under(mgsl_multifit, "Workspace", cGSL_Object); rb_define_singleton_method(cgsl_multifit_workspace, "new", rb_gsl_multifit_workspace_new, 2); rb_define_singleton_method(cgsl_multifit_workspace, "alloc", rb_gsl_multifit_workspace_new, 2); rb_define_singleton_method(mgsl_multifit, "alloc", rb_gsl_multifit_workspace_new, 2); rb_define_module_function(mgsl_multifit, "linear", rb_gsl_multifit_linear, -1); rb_define_module_function(mgsl_multifit, "wlinear", rb_gsl_multifit_wlinear, -1); cgsl_multifit_solver = rb_define_class_under(mgsl_multifit, "Solver", cGSL_Object); cgsl_multifit_fdfsolver = rb_define_class_under(mgsl_multifit, "FdfSolver", cgsl_multifit_solver); cgsl_multifit_function_fdf = rb_define_class_under(mgsl_multifit, "Function_fdf", cGSL_Object); /*****/ rb_define_singleton_method(cgsl_multifit_fdfsolver, "new", rb_gsl_multifit_fdfsolver_new, -1); rb_define_singleton_method(cgsl_multifit_fdfsolver, "alloc", rb_gsl_multifit_fdfsolver_new, -1); rb_define_singleton_method(cgsl_multifit_function_fdf, "new", rb_gsl_multifit_function_fdf_new, -1); rb_define_singleton_method(cgsl_multifit_function_fdf, "alloc", rb_gsl_multifit_function_fdf_new, -1); /*****/ rb_define_method(cgsl_multifit_fdfsolver, "set", rb_gsl_multifit_fdfsolver_set, 2); rb_define_method(cgsl_multifit_fdfsolver, "name", rb_gsl_multifit_fdfsolver_name, 0); rb_define_method(cgsl_multifit_fdfsolver, "iterate", rb_gsl_multifit_fdfsolver_iterate, 0); rb_define_method(cgsl_multifit_fdfsolver, "position", rb_gsl_multifit_fdfsolver_position, 0); // rb_define_alias(cgsl_multifit_fdfsolver, "x", "position"); rb_define_method(cgsl_multifit_fdfsolver, "print_state", rb_gsl_multifit_fdfsolver_print_state, 1); rb_define_method(cgsl_multifit_fdfsolver, "fdf", rb_gsl_multifit_fdfsolver_fdf, 0); rb_define_method(cgsl_multifit_fdfsolver, "test_delta", rb_gsl_multifit_fdfsolver_test_delta, 2); rb_define_method(cgsl_multifit_fdfsolver, "test_gradient", rb_gsl_multifit_fdfsolver_test_gradient, -1); rb_define_method(cgsl_multifit_fdfsolver, "covar", rb_gsl_multifit_fdfsolver_covar, -1); rb_define_method(cgsl_multifit_fdfsolver, "gradient", rb_gsl_multifit_fdfsolver_gradient, -1); rb_define_method(cgsl_multifit_fdfsolver, "x", rb_gsl_multifit_fdfsolver_x, 0); rb_define_method(cgsl_multifit_fdfsolver, "dx", rb_gsl_multifit_fdfsolver_dx, 0); rb_define_method(cgsl_multifit_fdfsolver, "f", rb_gsl_multifit_fdfsolver_f, 0); rb_define_method(cgsl_multifit_fdfsolver, "J", rb_gsl_multifit_fdfsolver_J, 0); rb_define_alias(cgsl_multifit_fdfsolver, "jac", "J"); rb_define_alias(cgsl_multifit_fdfsolver, "jacobian", "J"); rb_define_alias(cgsl_multifit_fdfsolver, "Jacobian", "J"); /*****/ rb_define_module_function(mgsl_multifit, "polyfit", rb_gsl_multifit_polyfit, -1); rb_define_module_function(mgsl_multifit, "legfit", rb_gsl_multifit_legfit, -1); /*****/ rb_define_singleton_method(mgsl_multifit, "test_delta", rb_gsl_multifit_test_delta, 4); rb_define_singleton_method(mgsl_multifit, "test_gradient", rb_gsl_multifit_test_gradient, 2); rb_define_singleton_method(mgsl_multifit, "gradient", rb_gsl_multifit_gradient, -1); rb_define_singleton_method(mgsl_multifit, "covar", rb_gsl_multifit_covar, -1); rb_gsl_multifit_define_const(cgsl_multifit_fdfsolver); rb_define_method(cgsl_multifit_function_fdf, "set_procs", rb_gsl_multifit_function_fdf_set_procs, -1); rb_define_method(cgsl_multifit_function_fdf, "set_data", rb_gsl_multifit_function_fdf_set_data, -1); rb_define_method(cgsl_multifit_function_fdf, "params", rb_gsl_multifit_function_fdf_params, 0); rb_define_alias(cgsl_multifit_function_fdf, "param", "params"); rb_define_method(cgsl_multifit_function_fdf, "n", rb_gsl_multifit_function_fdf_n, 0); rb_define_method(cgsl_multifit_function_fdf, "set_n", rb_gsl_multifit_function_fdf_set_n, 1); rb_define_alias(cgsl_multifit_function_fdf, "n=", "set_n"); rb_define_method(cgsl_multifit_function_fdf, "p", rb_gsl_multifit_function_fdf_p, 0); rb_define_alias(cgsl_multifit_function_fdf, "np", "p"); /*****/ rb_define_singleton_method(cgsl_multifit_fdfsolver, "fit", rb_gsl_multifit_fit, -1); /***/ #ifdef GSL_1_8_LATER rb_define_module_function(mgsl_multifit, "linear_est", rb_gsl_multifit_linear_est, 3); rb_define_module_function(module, "multifit_linear_est", rb_gsl_multifit_linear_est, 3); #endif #ifdef GSL_1_11_LATER rb_define_module_function(mgsl_multifit, "linear_residuals", rb_gsl_multifit_linear_residuals, -1); rb_define_module_function(module, "multifit_linear_residuals", rb_gsl_multifit_linear_residuals, -1); #endif #ifdef HAVE_NDLINEAR_GSL_MULTIFIT_NDLINEAR_H Init_ndlinear(mgsl_multifit); #endif } #ifdef CHECK_WORKSPACE #undef CHECK_WORKSPACE #endif #ifdef CHECK_MULTIFIT_FUNCTION_FDF #undef CHECK_MULTIFIT_FUNCTION_FDF #endif gsl-1.15.3/ext/sf_mathieu.c0000644000175000017500000002040712220252463015035 0ustar boutilboutil#include "rb_gsl.h" #ifdef GSL_1_9_LATER static VALUE cWorkspace; static VALUE rb_gsl_sf_mathieu_alloc(VALUE klass, VALUE n, VALUE q) { gsl_sf_mathieu_workspace *w; w = gsl_sf_mathieu_alloc((size_t) FIX2INT(n), NUM2DBL(q)); return Data_Wrap_Struct(klass, 0, gsl_sf_mathieu_free, w); } static VALUE sf_mathieu_eval(VALUE order, VALUE qq, int (*f)(int, double, gsl_sf_result*)) { gsl_sf_result r; (*f)(FIX2INT(order), NUM2DBL(qq), &r); return rb_float_new(r.val); } static VALUE sf_mathieu_eval2(VALUE n1, VALUE n2, VALUE q, VALUE x, int (*f)(int, int, double, double, gsl_sf_result*)) { gsl_sf_result r; (*f)(FIX2INT(n1),FIX2INT(n2), NUM2DBL(q), NUM2DBL(x), &r); return rb_float_new(r.val); } static VALUE sf_mathieu_array_eval(int argc, VALUE *argv, int (*f)(int, int, double, gsl_sf_mathieu_workspace*, double[])) { gsl_sf_mathieu_workspace *w; gsl_vector *v; int n1, n2; double q; switch (argc) { case 4: if (!rb_obj_is_kind_of(argv[3], cWorkspace)) { rb_raise(rb_eTypeError, "Wrong argument type 3 (%s detected, %s expected)", rb_class2name(CLASS_OF(argv[3])), rb_class2name(cWorkspace)); } n1 = FIX2INT(argv[0]); n2 = FIX2INT(argv[1]); q = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_sf_mathieu_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments. (%d for 4)", argc); } v = gsl_vector_alloc(n2 - n1 + 1); (*f)(n1, n2, q, w, v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE sf_mathieu_array_eval2(int argc, VALUE *argv, int (*f)(int, int, double, double, gsl_sf_mathieu_workspace*, double[])) { gsl_sf_mathieu_workspace *w; gsl_vector *v; int n1, n2; double q, x; switch (argc) { case 5: if (!rb_obj_is_kind_of(argv[4], cWorkspace)) { rb_raise(rb_eTypeError, "Wrong argument type 4 (%s detected, %s expected)", rb_class2name(CLASS_OF(argv[4])), rb_class2name(cWorkspace)); } n1 = FIX2INT(argv[0]); n2 = FIX2INT(argv[1]); q = NUM2DBL(argv[2]); x = NUM2DBL(argv[3]); Data_Get_Struct(argv[4], gsl_sf_mathieu_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments. (%d for 5)", argc); } v = gsl_vector_alloc(n2 - n1 + 1); (*f)(n1, n2, q, x, w, v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE sf_mathieu_array_eval3(int argc, VALUE *argv, int (*f)(int, int, int, double, double, gsl_sf_mathieu_workspace*, double[])) { gsl_sf_mathieu_workspace *w; gsl_vector *v; int n1, n2, n3; double q, x; switch (argc) { case 6: if (!rb_obj_is_kind_of(argv[5], cWorkspace)) { rb_raise(rb_eTypeError, "Wrong argument type 5 (%s detected, %s expected)", rb_class2name(CLASS_OF(argv[5])), rb_class2name(cWorkspace)); } n1 = FIX2INT(argv[0]); n2 = FIX2INT(argv[1]); n3 = FIX2INT(argv[2]); q = NUM2DBL(argv[3]); x = NUM2DBL(argv[4]); Data_Get_Struct(argv[5], gsl_sf_mathieu_workspace, w); break; default: rb_raise(rb_eArgError, "Wrong number of arguments. (%d for 6)", argc); } v = gsl_vector_alloc(n3 - n2 + 1); (*f)(n1, n2, n3, q, x, w, v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE sf_mathieu_eval_int_double2(VALUE order, VALUE qq, VALUE zz, int (*f)(int, double, double, gsl_sf_result*)) { gsl_sf_result r; (*f)(FIX2INT(order), NUM2DBL(qq), NUM2DBL(zz), &r); return rb_float_new(r.val); } static VALUE sf_mathieu_eval_e_int_double2(VALUE order, VALUE qq, VALUE zz, int (*f)(int, double, double, gsl_sf_result*)) { gsl_sf_result *r; VALUE val; val = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r); (*f)(FIX2INT(order), NUM2DBL(qq), NUM2DBL(zz), r); return val; } static VALUE sf_mathieu_eval_e_int2_double2(VALUE n1, VALUE n2, VALUE qq, VALUE zz, int (*f)(int, int, double, double, gsl_sf_result*)) { gsl_sf_result *r; VALUE val; val = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r); (*f)(FIX2INT(n1), FIX2INT(n2), NUM2DBL(qq), NUM2DBL(zz), r); return val; } /**********/ static VALUE rb_gsl_sf_mathieu_a_e(VALUE module, VALUE order, VALUE qq) { return rb_gsl_sf_eval_e_int_double(gsl_sf_mathieu_a, order, qq); } static VALUE rb_gsl_sf_mathieu_a(VALUE module, VALUE order, VALUE qq) { return sf_mathieu_eval(order, qq, gsl_sf_mathieu_a); } static VALUE rb_gsl_sf_mathieu_a_array(VALUE module, int argc, VALUE *argv) { return sf_mathieu_array_eval(argc, argv, gsl_sf_mathieu_a_array); } static VALUE rb_gsl_sf_mathieu_b_e(VALUE module, VALUE order, VALUE qq) { return rb_gsl_sf_eval_e_int_double(gsl_sf_mathieu_b, order, qq); } static VALUE rb_gsl_sf_mathieu_b(VALUE module, VALUE order, VALUE qq) { return sf_mathieu_eval(order, qq, gsl_sf_mathieu_b); } static VALUE rb_gsl_sf_mathieu_b_array(VALUE module, int argc, VALUE *argv) { return sf_mathieu_array_eval(argc, argv, gsl_sf_mathieu_b_array); } static VALUE rb_gsl_sf_mathieu_ce_e(VALUE module, VALUE order, VALUE qq, VALUE zz) { return sf_mathieu_eval_e_int_double2(order, qq, zz, gsl_sf_mathieu_ce); } static VALUE rb_gsl_sf_mathieu_ce(VALUE module, VALUE order, VALUE qq, VALUE zz) { return sf_mathieu_eval_int_double2(order, qq, zz, gsl_sf_mathieu_ce); } static VALUE rb_gsl_sf_mathieu_ce_array(VALUE module, int argc, VALUE *argv) { return sf_mathieu_array_eval2(argc, argv, gsl_sf_mathieu_ce_array); } static VALUE rb_gsl_sf_mathieu_se_e(VALUE module, VALUE order, VALUE qq, VALUE zz) { return sf_mathieu_eval_e_int_double2(order, qq, zz, gsl_sf_mathieu_se); } static VALUE rb_gsl_sf_mathieu_se(VALUE module, VALUE order, VALUE qq, VALUE zz) { return sf_mathieu_eval_int_double2(order, qq, zz, gsl_sf_mathieu_se); } static VALUE rb_gsl_sf_mathieu_se_array(VALUE module, int argc, VALUE *argv) { return sf_mathieu_array_eval2(argc, argv, gsl_sf_mathieu_se_array); } /*****/ static VALUE rb_gsl_sf_mathieu_Mc_e(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x) { return sf_mathieu_eval_e_int2_double2(n1, n2, q, x, gsl_sf_mathieu_Mc); } static VALUE rb_gsl_sf_mathieu_Mc(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x) { return sf_mathieu_eval2(n1, n2, q, x, gsl_sf_mathieu_Mc); } static VALUE rb_gsl_sf_mathieu_Mc_array(VALUE module, int argc, VALUE *argv) { return sf_mathieu_array_eval3(argc, argv, gsl_sf_mathieu_Mc_array); } static VALUE rb_gsl_sf_mathieu_Ms_e(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x) { return sf_mathieu_eval_e_int2_double2(n1, n2, q, x, gsl_sf_mathieu_Ms); } static VALUE rb_gsl_sf_mathieu_Ms(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x) { return sf_mathieu_eval2(n1, n2, q, x, gsl_sf_mathieu_Ms); } static VALUE rb_gsl_sf_mathieu_Ms_array(VALUE module, int argc, VALUE *argv) { return sf_mathieu_array_eval3(argc, argv, gsl_sf_mathieu_Ms_array); } /*****/ void Init_sf_mathieu(VALUE module) { VALUE mMathieu; mMathieu = rb_define_module_under(module, "Mathieu"); cWorkspace = rb_define_class_under(mMathieu, "Workspace", cGSL_Object); rb_define_singleton_method(cWorkspace, "alloc", rb_gsl_sf_mathieu_alloc, 2); rb_define_module_function(module, "mathieu_a", rb_gsl_sf_mathieu_a, 2); rb_define_module_function(module, "mathieu_a_e", rb_gsl_sf_mathieu_a_e, 2); rb_define_module_function(module, "mathieu_a_array", rb_gsl_sf_mathieu_a_array, -1); rb_define_module_function(module, "mathieu_b", rb_gsl_sf_mathieu_b, 2); rb_define_module_function(module, "mathieu_b_e", rb_gsl_sf_mathieu_b_e, 2); rb_define_module_function(module, "mathieu_b_array", rb_gsl_sf_mathieu_b_array, -1); rb_define_module_function(module, "mathieu_ce", rb_gsl_sf_mathieu_ce, 3); rb_define_module_function(module, "mathieu_ce_e", rb_gsl_sf_mathieu_ce_e, 3); rb_define_module_function(module, "mathieu_ce_array", rb_gsl_sf_mathieu_ce_array, -1); rb_define_module_function(module, "mathieu_se", rb_gsl_sf_mathieu_se, 3); rb_define_module_function(module, "mathieu_se_e", rb_gsl_sf_mathieu_se_e, 3); rb_define_module_function(module, "mathieu_se_array", rb_gsl_sf_mathieu_se_array, -1); rb_define_module_function(module, "mathieu_Mc", rb_gsl_sf_mathieu_Mc, 4); rb_define_module_function(module, "mathieu_Mc_e", rb_gsl_sf_mathieu_Mc_e, 4); rb_define_module_function(module, "mathieu_Mc_array", rb_gsl_sf_mathieu_Mc_array, -1); rb_define_module_function(module, "mathieu_Ms", rb_gsl_sf_mathieu_Ms, 4); rb_define_module_function(module, "mathieu_Ms_e", rb_gsl_sf_mathieu_Ms_e, 4); rb_define_module_function(module, "mathieu_Ms_array", rb_gsl_sf_mathieu_Ms_array, -1); } #endif gsl-1.15.3/ext/poly2.c0000644000175000017500000001616412220252463013763 0ustar boutilboutil/* poly2.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_poly.h" #include "rb_gsl_math.h" #include "rb_gsl_array.h" #include static gsl_poly_int* mygsl_poly_hermite(int n1) { size_t n; gsl_vector_int *p1, *p2, *p0; int coef1[2] = {0, 2}; int coef2[3] = {-2, 0, 4}; if (n1 < 0) rb_raise(rb_eArgError, "order must be >= 0"); p0 = gsl_vector_int_calloc(n1 + 1); switch (n1) { case 0: gsl_vector_int_set(p0, 0, 1); break; case 1: memcpy(p0->data, coef1, 2*sizeof(int)); break; case 2: memcpy(p0->data, coef2, 3*sizeof(int)); break; default: p1 = gsl_vector_int_calloc(n1 + 1); p2 = gsl_vector_int_calloc(n1 + 1); memcpy(p1->data, coef2, 3*sizeof(int)); memcpy(p2->data, coef1, 2*sizeof(int)); for (n = 2; n < n1; n++) { gsl_vector_int_memcpy(p0, p1); mygsl_vector_int_shift_scale2(p0, n); gsl_vector_int_scale(p2, 2*n); gsl_vector_int_sub(p0, p2); /* save for the next iteration */ gsl_vector_int_memcpy(p2, p1); gsl_vector_int_memcpy(p1, p0); } gsl_vector_int_free(p2); gsl_vector_int_free(p1); break; } return p0; } static gsl_poly_int* mygsl_poly_cheb(int n1) { size_t n; gsl_vector_int *p1, *p2, *p0; int coef1[2] = {0, 1}; int coef2[3] = {-1, 0, 2}; if (n1 < 0) rb_raise(rb_eArgError, "order must be >= 0"); p0 = gsl_vector_int_calloc(n1 + 1); switch (n1) { case 0: gsl_vector_int_set(p0, 0, 1); break; case 1: memcpy(p0->data, coef1, 2*sizeof(int)); break; case 2: memcpy(p0->data, coef2, 3*sizeof(int)); break; default: p1 = gsl_vector_int_calloc(n1 + 1); p2 = gsl_vector_int_calloc(n1 + 1); memcpy(p1->data, coef2, 3*sizeof(int)); memcpy(p2->data, coef1, 2*sizeof(int)); for (n = 2; n < n1; n++) { gsl_vector_int_memcpy(p0, p1); mygsl_vector_int_shift_scale2(p0, n); gsl_vector_int_sub(p0, p2); /* save for the next iteration */ gsl_vector_int_memcpy(p2, p1); gsl_vector_int_memcpy(p1, p0); } gsl_vector_int_free(p2); gsl_vector_int_free(p1); break; } return p0; } static gsl_poly_int* mygsl_poly_chebII(int n1) { size_t n; gsl_vector_int *p1, *p2, *p0; int coef1[2] = {0, 2}; int coef2[3] = {-1, 0, 4}; if (n1 < 0) rb_raise(rb_eArgError, "order must be >= 0"); p0 = gsl_vector_int_calloc(n1 + 1); switch (n1) { case 0: gsl_vector_int_set(p0, 0, 1); break; case 1: memcpy(p0->data, coef1, 2*sizeof(int)); break; case 2: memcpy(p0->data, coef2, 3*sizeof(int)); break; default: p1 = gsl_vector_int_calloc(n1 + 1); p2 = gsl_vector_int_calloc(n1 + 1); memcpy(p1->data, coef2, 3*sizeof(int)); memcpy(p2->data, coef1, 2*sizeof(int)); for (n = 2; n < n1; n++) { gsl_vector_int_memcpy(p0, p1); mygsl_vector_int_shift_scale2(p0, n); gsl_vector_int_sub(p0, p2); /* save for the next iteration */ gsl_vector_int_memcpy(p2, p1); gsl_vector_int_memcpy(p1, p0); } gsl_vector_int_free(p2); gsl_vector_int_free(p1); break; } return p0; } static gsl_poly_int* mygsl_poly_laguerre(int n) { size_t m, k; int val; gsl_vector_int *p0; if (n < 0) rb_raise(rb_eArgError, "order must be >= 0"); p0 = gsl_vector_int_calloc(n + 1); switch (n) { case 0: gsl_vector_int_set(p0, 0, 1); break; case 1: gsl_vector_int_set(p0, 0, 1); gsl_vector_int_set(p0, 1, -1); break; default: k = gsl_sf_fact(n); for (m = 0; m <= n; m++) { val = k*k/gsl_sf_fact(n-m)/gsl_pow_2(gsl_sf_fact(m)); if (m%2 == 1) val *= -1; gsl_vector_int_set(p0, m, val); } break; } return p0; } static gsl_poly_int* mygsl_poly_bessel(int n) { size_t k; gsl_vector_int *p0; if (n < 0) rb_raise(rb_eArgError, "order must be >= 0"); p0 = gsl_vector_int_calloc(n + 1); for (k = 0; k <= n; k++) { gsl_vector_int_set(p0, k, gsl_sf_fact(n+k)/gsl_sf_fact(n-k)/gsl_sf_fact(k)/((int) pow(2, k))); } return p0; } static gsl_poly_int* mygsl_poly_bell(int n1) { size_t n, j; gsl_vector_int *p1, *p0; int coef1[2] = {0, 1}; int coef2[3] = {0, 1, 1}; if (n1 < 0) rb_raise(rb_eArgError, "order must be >= 0"); p0 = gsl_vector_int_calloc(n1 + 1); switch (n1) { case 0: gsl_vector_int_set(p0, 0, 1); break; case 1: memcpy(p0->data, coef1, 2*sizeof(int)); break; case 2: memcpy(p0->data, coef2, 3*sizeof(int)); break; default: p1 = gsl_vector_int_calloc(n1 + 1); memcpy(p1->data, coef2, 3*sizeof(int)); for (n = 2; n < n1; n++) { gsl_vector_int_memcpy(p0, p1); mygsl_vector_int_shift(p0, n); for (j = 0; j < n; j++) { gsl_vector_int_set(p1, j, gsl_vector_int_get(p1, j+1)*(j+1)); } gsl_vector_int_set(p1, n, 0); mygsl_vector_int_shift(p1, n); gsl_vector_int_add(p0, p1); /* save for the next iteration */ gsl_vector_int_memcpy(p1, p0); } gsl_vector_int_free(p1); break; } return p0; } static VALUE rb_gsl_poly_define_poly(VALUE klass, VALUE order, gsl_poly_int* (*f)(int n1)) { int n1; gsl_poly_int *pnew = NULL; CHECK_FIXNUM(order); n1 = FIX2INT(order); if (n1 < 0) rb_raise(rb_eArgError, "order must be >= 0"); pnew = (*f)(n1); return Data_Wrap_Struct(cgsl_poly_int, 0, gsl_vector_int_free, pnew); } static VALUE rb_gsl_poly_hermite(VALUE klass, VALUE order) { return rb_gsl_poly_define_poly(klass, order, mygsl_poly_hermite); } static VALUE rb_gsl_poly_cheb(VALUE klass, VALUE order) { return rb_gsl_poly_define_poly(klass, order, mygsl_poly_cheb); } static VALUE rb_gsl_poly_chebII(VALUE klass, VALUE order) { return rb_gsl_poly_define_poly(klass, order, mygsl_poly_chebII); } static VALUE rb_gsl_poly_laguerre(VALUE klass, VALUE order) { return rb_gsl_poly_define_poly(klass, order, mygsl_poly_laguerre); } static VALUE rb_gsl_poly_bessel(VALUE klass, VALUE order) { return rb_gsl_poly_define_poly(klass, order, mygsl_poly_bessel); } static VALUE rb_gsl_poly_bell(VALUE klass, VALUE order) { return rb_gsl_poly_define_poly(klass, order, mygsl_poly_bell); } void Init_gsl_poly2(VALUE module) { rb_define_singleton_method(cgsl_poly, "hermite", rb_gsl_poly_hermite, 1); rb_define_singleton_method(cgsl_poly, "cheb", rb_gsl_poly_cheb, 1); rb_define_singleton_method(cgsl_poly, "chebyshev", rb_gsl_poly_cheb, 1); rb_define_singleton_method(cgsl_poly, "cheb_I", rb_gsl_poly_cheb, 1); rb_define_singleton_method(cgsl_poly, "chebyshev_I", rb_gsl_poly_cheb, 1); rb_define_singleton_method(cgsl_poly, "cheb_II", rb_gsl_poly_chebII, 1); rb_define_singleton_method(cgsl_poly, "chebyshev_II", rb_gsl_poly_chebII, 1); rb_define_singleton_method(cgsl_poly, "bessel", rb_gsl_poly_bessel, 1); rb_define_singleton_method(cgsl_poly, "bell", rb_gsl_poly_bell, 1); rb_define_singleton_method(cgsl_poly, "laguerre", rb_gsl_poly_laguerre, 1); } gsl-1.15.3/ext/gsl.c0000644000175000017500000001706012220252463013477 0ustar boutilboutil/* gsl.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl.h" #include ID rb_gsl_id_beg, rb_gsl_id_end, rb_gsl_id_excl, rb_gsl_id_to_a; static ID rb_gsl_id_name, rb_gsl_id_size; VALUE cGSL_Object; static void rb_gsl_define_intern(VALUE module); static void rb_gsl_define_const(VALUE module); static void rb_gsl_define_methods(VALUE module); static VALUE rb_gsl_object_inspect(VALUE obj) { char buf[256]; sprintf(buf, "%s", rb_class2name(CLASS_OF(obj))); return rb_str_new2(buf); } static VALUE rb_gsl_call_rescue(VALUE obj) { return Qfalse; } static VALUE rb_gsl_call_name(VALUE obj) { return rb_funcall(obj, rb_gsl_id_name, 0); } static VALUE rb_gsl_call_size(VALUE obj) { return rb_funcall(obj, rb_gsl_id_size, 0); } static VALUE rb_gsl_object_info(VALUE obj) { char buf[256]; VALUE s; sprintf(buf, "Class: %s\n", rb_class2name(CLASS_OF(obj))); #ifdef RUBY_1_9_LATER sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj)))); #else sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super)); #endif s = rb_rescue(rb_gsl_call_name, obj, rb_gsl_call_rescue, obj); if (s) sprintf(buf, "%sType: %s\n", buf, STR2CSTR(s)); s = rb_rescue(rb_gsl_call_size, obj, rb_gsl_call_rescue, obj); if (s) sprintf(buf, "%sSize: %d\n", buf, (int) FIX2INT(s)); return rb_str_new2(buf); } static VALUE rb_gsl_not_implemeted(VALUE obj) { rb_raise(rb_eNotImpError, "%s#dup is not implemented", rb_class2name(CLASS_OF(obj))); return Qnil; } void Init_rb_gsl() { VALUE mgsl; mgsl = rb_define_module("GSL"); cGSL_Object = rb_define_class_under(mgsl, "Object", rb_cObject); rb_define_method(cGSL_Object, "inspect", rb_gsl_object_inspect, 0); rb_define_method(cGSL_Object, "info", rb_gsl_object_info, 0); // Override Object#dup to prevent invalid dup-ing of GSL_Objects. // Subclasses (e.g. GSL::Vector) must provide their own implementation of // #dup if desired. rb_define_method(cGSL_Object, "dup", rb_gsl_not_implemeted, 0); rb_gsl_define_intern(mgsl); Init_gsl_error(mgsl); Init_gsl_math(mgsl); Init_gsl_complex(mgsl); Init_gsl_array(mgsl); Init_gsl_blas(mgsl); Init_gsl_sort(mgsl); Init_gsl_poly(mgsl); /* this must be called after the Vector class defined */ Init_gsl_poly_int(mgsl); Init_gsl_poly2(mgsl); Init_gsl_rational(mgsl); Init_gsl_sf(mgsl); Init_gsl_linalg(mgsl); /* Init_gsl_linalg_complex() is called in Init_gsl_linalg() */ Init_gsl_eigen(mgsl); Init_gsl_fft(mgsl); Init_gsl_signal(mgsl); Init_gsl_function(mgsl); Init_gsl_integration(mgsl); Init_gsl_rng(mgsl); Init_gsl_qrng(mgsl); Init_gsl_ran(mgsl); #ifdef GSL_1_4_LATER Init_gsl_cdf(mgsl); #endif Init_gsl_stats(mgsl); Init_gsl_histogram(mgsl); Init_gsl_histogram2d(mgsl); Init_gsl_histogram3d(mgsl); Init_gsl_ntuple(mgsl); Init_gsl_monte(mgsl); Init_gsl_siman(mgsl); Init_gsl_odeiv(mgsl); Init_gsl_interp(mgsl); Init_gsl_spline(mgsl); Init_gsl_diff(mgsl); #ifdef GSL_1_4_9_LATER Init_gsl_deriv(mgsl); #endif Init_gsl_cheb(mgsl); Init_gsl_sum(mgsl); Init_gsl_dht(mgsl); Init_gsl_root(mgsl); Init_gsl_multiroot(mgsl); Init_gsl_min(mgsl); Init_gsl_multimin(mgsl); Init_gsl_fit(mgsl); Init_gsl_multifit(mgsl); Init_gsl_const(mgsl); Init_gsl_ieee(mgsl); #ifdef HAVE_NARRAY_H Init_gsl_narray(mgsl); #endif Init_wavelet(mgsl); rb_gsl_define_const(mgsl); #ifdef HAVE_TENSOR_TENSOR_H Init_tensor_init(mgsl); Init_tensor_int_init(mgsl); #endif Init_gsl_graph(mgsl); Init_gsl_dirac(mgsl); #ifdef HAVE_TAMU_ANOVA_TAMU_ANOVA_H Init_tamu_anova(mgsl); #endif #ifdef HAVE_OOL_OOL_VERSION_H Init_ool(mgsl); #endif #ifdef HAVE_JACOBI_H Init_jacobi(mgsl); #endif #ifdef HAVE_GSL_GSL_CQP_H Init_cqp(mgsl); #endif Init_fresnel(mgsl); #ifdef GSL_1_9_LATER Init_bspline(mgsl); #endif #ifdef HAVE_ALF_ALF_H Init_alf(mgsl); #endif Init_geometry(mgsl); #ifdef GSL_1_14_LATER Init_multiset(mgsl); #endif rb_gsl_define_methods(mgsl); } /**********/ static void rb_gsl_define_intern(VALUE module) { rb_gsl_id_beg = rb_intern("begin"); rb_gsl_id_end = rb_intern("end"); rb_gsl_id_excl = rb_intern("exclude_end?"); rb_gsl_id_to_a = rb_intern("to_a"); rb_gsl_id_name = rb_intern("name"); rb_gsl_id_size = rb_intern("size"); } static void rb_gsl_define_const(VALUE module) { rb_define_const(module, "MODE_DEFAULT", INT2FIX(GSL_MODE_DEFAULT)); rb_define_const(module, "PREC_DOUBLE", INT2FIX(GSL_PREC_DOUBLE)); rb_define_const(module, "PREC_SINGLE", INT2FIX(GSL_PREC_SINGLE)); rb_define_const(module, "PREC_APPROX", INT2FIX(GSL_PREC_APPROX)); #ifdef GSL_VERSION rb_define_const(module, "VERSION", rb_str_new2(GSL_VERSION)); rb_define_const(module, "GSL_VERSION", rb_str_new2(GSL_VERSION)); #endif #ifdef RUBY_GSL_VERSION rb_define_const(module, "RUBY_GSL_VERSION", rb_str_new2(RUBY_GSL_VERSION)); rb_define_const(module, "RB_GSL_VERSION", rb_str_new2(RUBY_GSL_VERSION)); #endif rb_define_const(module, "DBL_EPSILON", rb_float_new(GSL_DBL_EPSILON)); rb_define_const(module, "FLT_EPSILON", rb_float_new(GSL_FLT_EPSILON)); rb_define_const(module, "MACH_EPS", rb_float_new(GSL_MACH_EPS)); rb_define_const(module, "SQRT_DBL_EPSILON", rb_float_new(GSL_SQRT_DBL_EPSILON)); rb_define_const(module, "ROOT3_DBL_EPSILON", rb_float_new(GSL_ROOT3_DBL_EPSILON)); rb_define_const(module, "ROOT4_DBL_EPSILON", rb_float_new(GSL_ROOT4_DBL_EPSILON)); rb_define_const(module, "ROOT5_DBL_EPSILON", rb_float_new(GSL_ROOT5_DBL_EPSILON)); rb_define_const(module, "ROOT6_DBL_EPSILON", rb_float_new(GSL_ROOT6_DBL_EPSILON)); rb_define_const(module, "LOG_DBL_EPSILON", rb_float_new(GSL_LOG_DBL_EPSILON)); rb_define_const(module, "DBL_MAX", rb_float_new(GSL_DBL_MAX)); rb_define_const(module, "SQRT_DBL_MAX", rb_float_new(GSL_SQRT_DBL_MAX)); rb_define_const(module, "ROOT3_DBL_MAX", rb_float_new(GSL_ROOT3_DBL_MAX)); rb_define_const(module, "ROOT4_DBL_MAX", rb_float_new(GSL_ROOT4_DBL_MAX)); rb_define_const(module, "ROOT5_DBL_MAX", rb_float_new(GSL_ROOT5_DBL_MAX)); rb_define_const(module, "ROOT6_DBL_MAX", rb_float_new(GSL_ROOT6_DBL_MAX)); rb_define_const(module, "LOG_DBL_MAX", rb_float_new(GSL_LOG_DBL_MAX)); rb_define_const(module, "DBL_MIN", rb_float_new(GSL_DBL_MIN)); rb_define_const(module, "SQRT_DBL_MIN", rb_float_new(GSL_SQRT_DBL_MIN)); rb_define_const(module, "ROOT3_DBL_MIN", rb_float_new(GSL_ROOT3_DBL_MIN)); rb_define_const(module, "ROOT4_DBL_MIN", rb_float_new(GSL_ROOT4_DBL_MIN)); rb_define_const(module, "ROOT5_DBL_MIN", rb_float_new(GSL_ROOT5_DBL_MIN)); rb_define_const(module, "ROOT6_DBL_MIN", rb_float_new(GSL_ROOT6_DBL_MIN)); rb_define_const(module, "LOG_DBL_MIN", rb_float_new(GSL_LOG_DBL_MIN)); #ifdef GSL_1_14_LATER rb_define_const(module, "MAJOR_VERSION", INT2FIX(GSL_MAJOR_VERSION)); rb_define_const(module, "MINOR_VERSION", INT2FIX(GSL_MINOR_VERSION)); #endif } static VALUE rb_gsl_have_tensor(VALUE module) { #ifdef HAVE_TENSOR_TENSOR_H return Qtrue; #else return Qfalse; #endif } static VALUE rb_gsl_have_narray(VALUE module) { #ifdef HAVE_NARRAY_H return Qtrue; #else return Qfalse; #endif } static void rb_gsl_define_methods(VALUE module) { rb_define_singleton_method(module, "have_tensor?", rb_gsl_have_tensor, 0); rb_define_singleton_method(module, "have_narray?", rb_gsl_have_narray, 0); } gsl-1.15.3/ext/poly_source.c0000644000175000017500000016562612220252463015271 0ustar boutilboutil/* poly_source.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #ifdef BASE_DOUBLE #define NUMCONV(x) NUM2DBL(x) #define NUMCONV2(x) NUM2DBL(x) #define MAT_ROW_COL MATRIX_ROW_COL #define MAT_P MATRIX_P #define MAT_ROW_P MATRIX_ROW_P #define MAT_COL_P MATRIX_COL_P #define C_TO_VALUE rb_float_new #define C_TO_VALUE2 rb_float_new #define CHECK_MAT CHECK_MATRIX #define MAT_VIEW_P MATRIX_VIEW_P #define PRINTF_FORMAT "%4.3e " #define VEC_ROW_COL VECTOR_ROW_COL #define VEC_P VECTOR_P #define VEC_ROW_P VECTOR_ROW_P #define VEC_COL_P VECTOR_COL_P #define CHECK_VEC CHECK_VECTOR #define VEC_VIEW_P VECTOR_VIEW_P #elif defined(BASE_INT) #define NUMCONV(x) NUM2DBL(x) #define NUMCONV2(x) NUM2INT(x) #define PRINTF_FORMAT "%d " #define MAT_ROW_COL MATRIX_INT_ROW_COL #define MAT_P MATRIX_INT_P #define C_TO_VALUE INT2FIX #define C_TO_VALUE2 INT2NUM #define MAT_ROW_P MATRIX_INT_ROW_P #define MAT_COL_P MATRIX_INT_COL_P #define CHECK_MAT CHECK_MATRIX_INT #define MAT_VIEW_P MATRIX_INT_VIEW_P #define VEC_ROW_COL VECTOR_INT_ROW_COL #define VEC_P VECTOR_INT_P #define VEC_ROW_P VECTOR_INT_ROW_P #define VEC_COL_P VECTOR_INT_COL_P #define CHECK_VEC CHECK_VECTOR_INT #define VEC_VIEW_P VECTOR_INT_VIEW_P #endif #ifdef BASE_DOUBLE VALUE cgsl_poly, cgsl_poly_int; VALUE cgsl_poly_workspace; VALUE cgsl_poly_complex_workspace; #ifdef GSL_1_1_LATER VALUE cgsl_poly_dd; VALUE cgsl_poly_taylor; #endif #endif #ifdef BASE_INT double gsl_poly_int_eval(const BASE c[], const int len, const double x) { int i; double ans = (double) c[len-1]; for(i=len-1; i>0; i--) ans = (double) c[i-1] + x * ans; return ans; } #endif #ifdef BASE_DOUBLE #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif #ifdef GSL_1_11_LATER static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b); #endif static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x) { gsl_vector *v = NULL, *vx, *vnew; gsl_matrix *mx, *mnew; double rslt; int flag = 0; size_t i, N, n; VALUE val; double *ptr0; double *ptr1, *ptr2; #ifdef HAVE_NARRAY_H int shape[1]; #endif #ifdef GSL_1_11_LATER gsl_complex *z, zz; gsl_vector_complex *vz, *vznew; if (rb_obj_is_kind_of(a, cgsl_vector_complex)) return rb_gsl_complex_poly_complex_eval(a, x); #endif switch (TYPE(a)) { case T_ARRAY: #ifdef GSL_1_11_LATER if (rb_obj_is_kind_of(rb_ary_entry(a, 0), cgsl_complex)) return rb_gsl_complex_poly_complex_eval(a, x); #endif v = make_cvector_from_rarray(a); N = v->size; ptr0 = v->data; flag = 1; break; default: if (rb_obj_is_kind_of(a, cgsl_vector)) { Data_Get_Struct(a, gsl_vector, v); N = v->size; ptr0 = v->data; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(a)) { N = NA_TOTAL(a); ptr0 = NA_PTR_TYPE(a, double*); #endif } else { rb_raise(rb_eTypeError, "Wrong argument type %s (Array, GSL::Vector or NArray expected)", rb_class2name(CLASS_OF(a))); } } switch (TYPE(x)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: val = rb_float_new(gsl_poly_eval(ptr0, N, NUM2DBL(x))); break; case T_ARRAY: n = RARRAY_LEN(x); val = rb_ary_new2(n); for (i = 0; i < n; i++) { rslt = gsl_poly_eval(ptr0, N, NUM2DBL(rb_ary_entry(x, i))); rb_ary_store(val, i, rb_float_new(rslt)); } break; default: if (rb_obj_is_kind_of(x, cgsl_vector)) { Data_Get_Struct(x, gsl_vector, vx); vnew = gsl_vector_alloc(vx->size); val = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); n = vx->size; ptr1 = vx->data; ptr2 = vnew->data; } else if (rb_obj_is_kind_of(x, cgsl_matrix)) { Data_Get_Struct(x, gsl_matrix, mx); mnew = gsl_matrix_alloc(mx->size1, mx->size2); val = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); n = mx->size1*mx->size2; ptr1 = mx->data; ptr2 = mnew->data; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(x)) { shape[0] = NA_TOTAL(x); n = shape[0]; val = na_make_object(NA_DFLOAT, 1, shape, CLASS_OF(x)); ptr1 = NA_PTR_TYPE(x, double*); ptr2 = NA_PTR_TYPE(val, double*); #endif #ifdef GSL_1_11_LATER } else if (rb_obj_is_kind_of(x, cgsl_complex)) { Data_Get_Struct(x, gsl_complex, z); zz = gsl_poly_complex_eval(ptr0, N, *z); z = make_complex(GSL_REAL(zz), GSL_IMAG(zz)); if (flag == 1) gsl_vector_free(v); return Data_Wrap_Struct(cgsl_complex, 0, free, z); } else if (rb_obj_is_kind_of(x, cgsl_vector_complex)) { Data_Get_Struct(x, gsl_vector_complex, vz); vznew = gsl_vector_complex_alloc(vz->size); for (i = 0; i < vz->size; i++) { zz = gsl_poly_complex_eval(ptr0, N, gsl_vector_complex_get(vz, i)); gsl_vector_complex_set(vznew, i, zz); } if (flag == 1) gsl_vector_free(v); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vznew); #endif } else { rb_raise(rb_eTypeError, "Wrong argument type %s (A number, Array, GSL::Vector or NArray expected)", rb_class2name(CLASS_OF(a))); } for (i = 0; i < n; i++) { ptr2[i] = gsl_poly_eval(ptr0, N, ptr1[i]); } } if (flag == 1) gsl_vector_free(v); return val; } #ifdef GSL_1_11_LATER static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b) { gsl_vector_complex *coef, *zb, *vnew; gsl_complex *zc; gsl_complex z, *zx, *res; VALUE ret; size_t i, N; int flag = 0; if (rb_obj_is_kind_of(a, cgsl_vector_complex)) { Data_Get_Struct(a, gsl_vector_complex, coef); N = coef->size; zc = (gsl_complex*) coef->data; } else if (TYPE(a) == T_ARRAY) { N = RARRAY_LEN(a); zc = (gsl_complex*) malloc(sizeof(gsl_complex)); flag = 1; for (i = 0; i < N; i++) { Data_Get_Struct(rb_ary_entry(a, i), gsl_complex, zx); zc[i] = *zx; } } else { rb_raise(rb_eTypeError, "rb_gsl_complex_poly_complex_solve: wrong argument type %s (GSL::Vector::Complex or Array expected)\n", rb_class2name(CLASS_OF(a))); } switch (TYPE(b)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: res = (gsl_complex*) malloc(sizeof(gsl_complex)); ret = Data_Wrap_Struct(cgsl_complex, 0, free, res); GSL_SET_REAL(&z, NUM2DBL(b)); GSL_SET_IMAG(&z, 0.0); *res = gsl_complex_poly_complex_eval(zc, coef->size, z); break; case T_ARRAY: ret = rb_ary_new2(RARRAY_LEN(b)); for (i = 0; i < RARRAY_LEN(b); i++) { Data_Get_Struct(rb_ary_entry(b, i), gsl_complex, zx); res = (gsl_complex*) malloc(sizeof(gsl_complex)); *res = gsl_complex_poly_complex_eval(zc, N, *zx); rb_ary_store(ret, i, Data_Wrap_Struct(cgsl_complex, 0, free, res)); } break; default: if (rb_obj_is_kind_of(b, cgsl_complex)) { res = (gsl_complex*) malloc(sizeof(gsl_complex)); ret = Data_Wrap_Struct(cgsl_complex, 0, free, res); Data_Get_Struct(b, gsl_complex, zx); *res = gsl_complex_poly_complex_eval(zc, N, *zx); } else if (rb_obj_is_kind_of(b, cgsl_vector_complex)) { Data_Get_Struct(b, gsl_vector_complex, zb); vnew = gsl_vector_complex_alloc(zb->size); ret = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); for (i = 0; i < zb->size; i++) { z = gsl_vector_complex_get(zb, i); gsl_vector_complex_set(vnew, i, gsl_complex_poly_complex_eval(zc, N, z)); } } else { rb_raise(rb_eTypeError, "Wrong argument type %s.\n", rb_class2name(CLASS_OF(b))); } } if (flag == 1) free(zc); return ret; } #endif #endif static VALUE FUNCTION(rb_gsl_poly,eval)(VALUE obj, VALUE xx) { GSL_TYPE(gsl_poly) *p = NULL; GSL_TYPE(gsl_vector) *v = NULL; GSL_TYPE(gsl_matrix) *m = NULL; gsl_vector *vnew = NULL; gsl_matrix *mnew = NULL; VALUE x, ary; size_t i, j; #ifdef BASE_DOUBLE #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; size_t n; #endif #ifdef GSL_1_11_LATER gsl_complex *z, zz; gsl_vector_complex *vz, *vznew; #endif #endif Data_Get_Struct(obj, GSL_TYPE(gsl_poly), p); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(FUNCTION(gsl_poly,eval)(p->data, p->size, NUM2DBL(xx))); break; case T_ARRAY: ary = rb_ary_new2(RARRAY_LEN(xx)); for (i = 0; i < RARRAY_LEN(xx); i++) { x = rb_ary_entry(xx, i); Need_Float(x); rb_ary_store(ary, i, rb_float_new(FUNCTION(gsl_poly,eval)(p->data, p->size, NUM2DBL(x)))); } return ary; break; default: #ifdef BASE_DOUBLE #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); for (i = 0; i < n; i++) ptr2[i] = FUNCTION(gsl_poly,eval)(p->data,p->size,ptr1[i]); return ary; } #endif #endif if (VEC_P(xx)) { Data_Get_Struct(xx, GSL_TYPE(gsl_vector), v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, FUNCTION(gsl_poly,eval)(p->data, p->size, FUNCTION(gsl_vector,get)(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MAT_P(xx)) { Data_Get_Struct(xx, GSL_TYPE(gsl_matrix), m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, FUNCTION(gsl_poly,eval)(p->data, p->size, FUNCTION(gsl_matrix,get)(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); #ifdef BASE_DOUBLE #ifdef GSL_1_11_LATER } else if (rb_obj_is_kind_of(xx, cgsl_complex)) { Data_Get_Struct(xx, gsl_complex, z); zz = gsl_poly_complex_eval(p->data, p->size, *z); z = make_complex(GSL_REAL(zz), GSL_IMAG(zz)); return Data_Wrap_Struct(cgsl_complex, 0, free, z); } else if (rb_obj_is_kind_of(xx, cgsl_vector_complex)) { Data_Get_Struct(xx, gsl_vector_complex, vz); vznew = gsl_vector_complex_alloc(vz->size); for (i = 0; i < vz->size; i++) { zz = gsl_poly_complex_eval(p->data, p->size, gsl_vector_complex_get(vz, i)); gsl_vector_complex_set(vznew, i, zz); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vznew); #endif #endif } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } /* singleton method */ static VALUE FUNCTION(rb_gsl_poly,eval2)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_poly) *p = NULL; GSL_TYPE(gsl_vector) *v = NULL; GSL_TYPE(gsl_matrix) *m = NULL; gsl_vector *vnew = NULL; gsl_matrix *mnew = NULL; VALUE xx, x, ary; size_t i, j, size; #ifdef BASE_DOUBLE #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif #endif switch (argc) { case 2: Data_Get_Struct(argv[0], GSL_TYPE(gsl_poly), p); size = p->size; xx = argv[1]; break; case 3: Data_Get_Struct(argv[0], GSL_TYPE(gsl_poly), p); size = FIX2INT(argv[1]); xx = argv[2]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(FUNCTION(gsl_poly,eval)(p->data, size, NUM2DBL(xx))); break; case T_ARRAY: ary = rb_ary_new2(RARRAY_LEN(xx)); for (i = 0; i < RARRAY_LEN(xx); i++) { x = rb_ary_entry(xx, i); Need_Float(x); rb_ary_store(ary, i, rb_float_new(FUNCTION(gsl_poly,eval)(p->data, size, NUM2DBL(x)))); } return ary; break; default: #ifdef BASE_DOUBLE #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); ptr1 = (double*) na->ptr; size = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary,double*); for (i = 0; i < size; i++) ptr2[i] = FUNCTION(gsl_poly,eval)(p->data,p->size,ptr1[i]); return ary; } #endif #endif if (VEC_P(xx)) { Data_Get_Struct(xx, GSL_TYPE(gsl_vector), v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, FUNCTION(gsl_poly,eval)(p->data, size, FUNCTION(gsl_vector,get)(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MAT_P(xx)) { Data_Get_Struct(xx, GSL_TYPE(gsl_matrix), m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, FUNCTION(gsl_poly,eval)(p->data, size, FUNCTION(gsl_matrix,get)(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } /* ax*x + bx + c = 0 */ static VALUE FUNCTION(rb_gsl_poly,solve_quadratic)(int argc, VALUE *argv, VALUE obj) { double x0, x1; GSL_TYPE(gsl_poly) *v = NULL; gsl_vector *r; int n; switch (argc) { case 3: n = gsl_poly_solve_quadratic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]), &x0, &x1); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: n = gsl_poly_solve_quadratic(NUMCONV2(rb_ary_entry(argv[0], 0)), NUMCONV2(rb_ary_entry(argv[0], 1)), NUMCONV2(rb_ary_entry(argv[0], 2)), &x0, &x1); break; default: CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_poly), v); n = gsl_poly_solve_quadratic(FUNCTION(gsl_vector,get)(v, 0), FUNCTION(gsl_vector,get)(v, 1), FUNCTION(gsl_vector,get)(v, 2), &x0, &x1); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (3 numbers or 1 array or 1 vector)"); break; } // If n == 0, we want to return an empty gsl_vector, but gsl_vectors can'y be // empty, so just return an empty Array. if(n == 0) { return rb_ary_new(); } r = gsl_vector_alloc(n); switch(n) { case 2: gsl_vector_set(r, 1, x1); /* fall through */ case 1: gsl_vector_set(r, 0, x0); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r); } static VALUE FUNCTION(rb_gsl_poly,complex_solve_quadratic)(int argc, VALUE *argv, VALUE obj) { gsl_complex z0, z1; GSL_TYPE(gsl_vector) *v = NULL; gsl_vector_complex *r = NULL; int n; switch (argc) { case 3: n = gsl_poly_complex_solve_quadratic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]), &z0, &z1); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: n = gsl_poly_complex_solve_quadratic(NUMCONV2(rb_ary_entry(argv[0], 0)), NUMCONV2(rb_ary_entry(argv[0], 1)), NUMCONV2(rb_ary_entry(argv[0], 2)), &z0, &z1); break; default: CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); n = gsl_poly_complex_solve_quadratic(FUNCTION(gsl_vector,get)(v, 0), FUNCTION(gsl_vector,get)(v, 1), FUNCTION(gsl_vector,get)(v, 2), &z0, &z1); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (3 numbers or 1 array or 1 vector)"); break; } // If n == 0, we want to return an empty gsl_vector, but gsl_vectors can'y be // empty, so just return an empty Array. if(n == 0) { return rb_ary_new(); } r = gsl_vector_complex_alloc(n); switch(n) { case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */ case 1: gsl_vector_complex_set(r, 0, z0); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } static VALUE FUNCTION(rb_gsl_poly,solve_cubic)(int argc, VALUE *argv, VALUE obj) { double x0, x1, x2; GSL_TYPE(gsl_vector) *v = NULL; gsl_vector *r = NULL; int n; switch (argc) { case 3: n = gsl_poly_solve_cubic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]), &x0, &x1, &x2); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: n = gsl_poly_solve_cubic(NUMCONV2(rb_ary_entry(argv[0], 0)), NUMCONV2(rb_ary_entry(argv[0], 1)), NUMCONV2(rb_ary_entry(argv[0], 2)), &x0, &x1, &x2); break; default: CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); n = gsl_poly_solve_cubic(FUNCTION(gsl_vector,get)(v, 0), FUNCTION(gsl_vector,get)(v, 1), FUNCTION(gsl_vector,get)(v, 2), &x0, &x1, &x2); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (3 numbers or 1 array or 1 vector)"); break; } r = gsl_vector_alloc(n); switch(n) { case 3: gsl_vector_set(r, 2, x2); /* fall through */ case 2: gsl_vector_set(r, 1, x1); /* fall through */ case 1: gsl_vector_set(r, 0, x0); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r); } static VALUE FUNCTION(rb_gsl_poly,complex_solve_cubic)(int argc, VALUE *argv, VALUE obj) { gsl_complex z0, z1, z2; GSL_TYPE(gsl_vector) *v = NULL; gsl_vector_complex *r = NULL; int n; switch (argc) { case 3: n = gsl_poly_complex_solve_cubic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]), &z0, &z1, &z2); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: n = gsl_poly_complex_solve_cubic(NUMCONV2(rb_ary_entry(argv[0], 0)), NUMCONV2(rb_ary_entry(argv[0], 1)), NUMCONV2(rb_ary_entry(argv[0], 2)), &z0, &z1, &z2); break; default: CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); n = gsl_poly_complex_solve_cubic(FUNCTION(gsl_vector,get)(v, 0), FUNCTION(gsl_vector,get)(v, 1), FUNCTION(gsl_vector,get)(v, 2), &z0, &z1, &z2); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (3 numbers or 1 array or 1 vector)"); break; } r = gsl_vector_complex_alloc(n); switch(n) { case 3: gsl_vector_complex_set(r, 2, z2); /* fall through */ case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */ case 1: gsl_vector_complex_set(r, 0, z0); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } #ifdef HAVE_POLY_SOLVE_QUARTIC static VALUE FUNCTION(rb_gsl_poly,solve_quartic)(int argc, VALUE *argv, VALUE obj) { double x0, x1, x2, x3; GSL_TYPE(gsl_vector) *v = NULL; gsl_vector *r = NULL; int n; switch (argc) { case 4: n = gsl_poly_solve_quartic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]), NUMCONV2(argv[3]), &x0, &x1, &x2, &x3); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: n = gsl_poly_solve_quartic(NUMCONV2(rb_ary_entry(argv[0], 0)), NUMCONV2(rb_ary_entry(argv[0], 1)), NUMCONV2(rb_ary_entry(argv[0], 2)), NUMCONV2(rb_ary_entry(argv[0], 3)), &x0, &x1, &x2, &x3); break; default: CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); n = gsl_poly_solve_quartic(FUNCTION(gsl_vector,get)(v, 0), FUNCTION(gsl_vector,get)(v, 1), FUNCTION(gsl_vector,get)(v, 2), FUNCTION(gsl_vector,get)(v, 3), &x0, &x1, &x2, &x3); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (3 numbers or 1 array or 1 vector)"); break; } r = gsl_vector_alloc(n); switch(n) { case 4: gsl_vector_set(r, 3, x3); /* fall through */ case 3: gsl_vector_set(r, 2, x2); /* fall through */ case 2: gsl_vector_set(r, 1, x1); /* fall through */ case 1: gsl_vector_set(r, 0, x0); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r); } static VALUE FUNCTION(rb_gsl_poly,complex_solve_quartic)(int argc, VALUE *argv, VALUE obj) { gsl_complex z0, z1, z2, z3; GSL_TYPE(gsl_vector) *v = NULL; gsl_vector_complex *r = NULL; int n; switch (argc) { case 4: n = gsl_poly_complex_solve_quartic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]), NUMCONV2(argv[3]), &z0, &z1, &z2, &z3); break; case 1: switch (TYPE(argv[0])) { case T_ARRAY: n = gsl_poly_complex_solve_quartic(NUMCONV2(rb_ary_entry(argv[0], 0)), NUMCONV2(rb_ary_entry(argv[0], 1)), NUMCONV2(rb_ary_entry(argv[0], 2)), NUMCONV2(rb_ary_entry(argv[0], 3)), &z0, &z1, &z2, &z3); break; default: CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); n = gsl_poly_complex_solve_quartic(FUNCTION(gsl_vector,get)(v, 0), FUNCTION(gsl_vector,get)(v, 1), FUNCTION(gsl_vector,get)(v, 2), FUNCTION(gsl_vector,get)(v, 3), &z0, &z1, &z2, &z3); break; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (3 numbers or 1 array or 1 vector)"); break; } r = gsl_vector_complex_alloc(n); switch(n) { case 4: gsl_vector_complex_set(r, 0, z0); /* fall through */ case 3: gsl_vector_complex_set(r, 1, z1); /* fall through */ case 2: gsl_vector_complex_set(r, 2, z2); /* fall through */ case 1: gsl_vector_complex_set(r, 3, z3); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } #endif /* singleton method */ VALUE FUNCTION(rb_gsl_poly,complex_solve)(int argc, VALUE *argv, VALUE obj) { int size = -1, size2; gsl_poly_complex_workspace *w = NULL; GSL_TYPE(gsl_vector) *v = NULL; gsl_vector *a = NULL, *z = NULL; gsl_complex c; gsl_vector_complex *r = NULL; int i, flag = 0; // local variable "status" declared and set, but never used //int status; switch (argc) { case 1: break; case 2: if (TYPE(argv[1]) == T_FIXNUM) size = FIX2INT(argv[1]); break; case 3: if (TYPE(argv[1]) == T_FIXNUM) size = FIX2INT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-3)", argc); break; } switch (TYPE(argv[0])) { case T_ARRAY: if (size < 0) size = RARRAY_LEN(argv[0]); a = gsl_vector_alloc(size); for (i = 0; i < size; i++) gsl_vector_set(a, i, NUMCONV2(rb_ary_entry(argv[0], i))); break; case T_FIXNUM: case T_BIGNUM: case T_FLOAT: if (rb_obj_is_kind_of(argv[argc-1], cgsl_poly_workspace)) size = argc - 1; else size = argc; a = gsl_vector_alloc(size); for (i = 0; i < size; i++) gsl_vector_set(a, i, NUMCONV2(argv[i])); break; default: if (rb_obj_is_kind_of(argv[0], GSL_TYPE(cgsl_vector))) { Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); if (size < 0) size = v->size; } else { rb_raise(rb_eTypeError, "wrong argument type (Array, Vector, or Numeric expected"); } a = gsl_vector_alloc(v->size); for (i = 0; i < size; i++) gsl_vector_set(a, i, FUNCTION(gsl_vector,get)(v, i)); break; } size2 = 2*(size - 1); z = gsl_vector_alloc(size2); if (rb_obj_is_kind_of(argv[argc-1], cgsl_poly_workspace) || rb_obj_is_kind_of(argv[argc-1], cgsl_poly_complex_workspace)) { Data_Get_Struct(argv[argc-1], gsl_poly_complex_workspace, w); flag = 0; } else { w = gsl_poly_complex_workspace_alloc(size); flag = 1; } /*status =*/ gsl_poly_complex_solve(a->data, size, w, z->data); if (flag == 1) gsl_poly_complex_workspace_free(w); gsl_vector_free(a); r = gsl_vector_complex_alloc(size - 1); for (i = 0; i < size - 1; i++) { c.dat[0] = gsl_vector_get(z, i*2); c.dat[1] = gsl_vector_get(z, i*2+1); gsl_vector_complex_set(r, i, c); } gsl_vector_free(z); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } /* a2 x*x + a1 x + a0 = 0 */ static VALUE FUNCTION(rb_gsl_poly,solve_quadratic2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector *r = NULL; gsl_vector_complex *r2 = NULL; double a2, a1, a0; double d; /* determinant */ double x0, x1; int n; gsl_complex z0, z1; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->size < 3) { rb_raise(rb_eArgError, "the order of the object is less than 3."); } a2 = FUNCTION(gsl_vector,get)(v, 2); /* coefficients */ a1 = FUNCTION(gsl_vector,get)(v, 1); a0 = FUNCTION(gsl_vector,get)(v, 0); d = a1*a1 - 4.0*a2*a0; /* determinant */ if (d >= 0.0) { n = gsl_poly_solve_quadratic(a2, a1, a0, &x0, &x1); r = gsl_vector_alloc(n); switch(n) { case 2: gsl_vector_set(r, 1, x1); /* fall through */ case 1: gsl_vector_set(r, 0, x0); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r); } else { n = gsl_poly_complex_solve_quadratic(a2, a1, a0, &z0, &z1); r2 = gsl_vector_complex_alloc(n); switch(n) { case 2: gsl_vector_complex_set(r2, 1, z1); /* fall through */ case 1: gsl_vector_complex_set(r2, 0, z0); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r2); } } static VALUE FUNCTION(rb_gsl_poly,complex_solve_quadratic2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector_complex *r = NULL; double a2, a1, a0; int n; gsl_complex z0, z1; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->size < 3) { rb_raise(rb_eArgError, "the order of the object is less than 3."); } a2 = FUNCTION(gsl_vector,get)(v, 2); /* coefficients */ a1 = FUNCTION(gsl_vector,get)(v, 1); a0 = FUNCTION(gsl_vector,get)(v, 0); n = gsl_poly_complex_solve_quadratic(a2, a1, a0, &z0, &z1); r = gsl_vector_complex_alloc(n); switch(n) { case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */ case 1: gsl_vector_complex_set(r, 0, z0); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } /* x**3 + a2 x**2 + a1 x + a0 = 0 */ static VALUE FUNCTION(rb_gsl_poly,solve_cubic2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector *r = NULL; double a3, a2, a1, a0; double x0, x1, x2; int n; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->size < 4) { rb_raise(rb_eArgError, "the order of the object is less than 4."); } a3 = FUNCTION(gsl_vector,get)(v, 3); a2 = FUNCTION(gsl_vector,get)(v, 2)/a3; /* coefficients */ a1 = FUNCTION(gsl_vector,get)(v, 1)/a3; a0 = FUNCTION(gsl_vector,get)(v, 0)/a3; n = gsl_poly_solve_cubic(a2, a1, a0, &x0, &x1, &x2); r = gsl_vector_alloc(n); switch(n) { case 3: gsl_vector_set(r, 2, x2); /* fall through */ case 2: gsl_vector_set(r, 1, x1); /* fall through */ case 1: gsl_vector_set(r, 0, x0); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r); } static VALUE FUNCTION(rb_gsl_poly,complex_solve_cubic2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector_complex *r = NULL; double a3, a2, a1, a0; int n; gsl_complex z0, z1, z2; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->size < 4) { rb_raise(rb_eArgError, "the order of the object is less than 4."); } a3 = FUNCTION(gsl_vector,get)(v, 3); a2 = FUNCTION(gsl_vector,get)(v, 2)/a3; /* coefficients */ a1 = FUNCTION(gsl_vector,get)(v, 1)/a3; a0 = FUNCTION(gsl_vector,get)(v, 0)/a3; n = gsl_poly_complex_solve_cubic(a2, a1, a0, &z0, &z1, &z2); r = gsl_vector_complex_alloc(n); switch(n) { case 3: gsl_vector_complex_set(r, 2, z2); /* fall through */ case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */ case 1: gsl_vector_complex_set(r, 0, z0); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } #ifdef HAVE_POLY_SOLVE_QUARTIC /* a4 x**4 + a3 x**3 + a2 x**2 + a1 x + a0 = 0 */ static VALUE FUNCTION(rb_gsl_poly,solve_quartic2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector *r = NULL; double a4, a3, a2, a1, a0; double x0, x1, x2, x3; int n; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->size < 5) { rb_raise(rb_eArgError, "the order of the object is less than 4."); } a4 = FUNCTION(gsl_vector,get)(v, 4); a3 = FUNCTION(gsl_vector,get)(v, 3)/a4; a2 = FUNCTION(gsl_vector,get)(v, 2)/a4; /* coefficients */ a1 = FUNCTION(gsl_vector,get)(v, 1)/a4; a0 = FUNCTION(gsl_vector,get)(v, 0)/a4; n = gsl_poly_solve_quartic(a3, a2, a1, a0, &x0, &x1, &x2, &x3); r = gsl_vector_alloc(3); r = gsl_vector_alloc(4); gsl_vector_set(r, 0, x0); gsl_vector_set(r, 1, x1); gsl_vector_set(r, 2, x2); gsl_vector_set(r, 3, x3); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r); } static VALUE FUNCTION(rb_gsl_poly,complex_solve_quartic2)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector_complex *r = NULL; double a4, a3, a2, a1, a0; int n; gsl_complex z0, z1, z2, z3; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); if (v->size < 5) { rb_raise(rb_eArgError, "the order of the object is less than 4."); } a4 = FUNCTION(gsl_vector,get)(v, 4); a3 = FUNCTION(gsl_vector,get)(v, 3)/a4; a2 = FUNCTION(gsl_vector,get)(v, 2)/a4; /* coefficients */ a1 = FUNCTION(gsl_vector,get)(v, 1)/a4; a0 = FUNCTION(gsl_vector,get)(v, 0)/a4; n = gsl_poly_complex_solve_quartic(a3, a2, a1, a0, &z0, &z1, &z2, &z3); r = gsl_vector_complex_alloc(4); gsl_vector_complex_set(r, 0, z0); gsl_vector_complex_set(r, 1, z1); gsl_vector_complex_set(r, 2, z2); gsl_vector_complex_set(r, 3, z3); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } #endif /* method */ VALUE FUNCTION(rb_gsl_poly,complex_solve2)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; gsl_vector *a = NULL, *z = NULL; size_t size, size2, i; gsl_poly_complex_workspace *w = NULL; gsl_complex c; gsl_vector_complex *r = NULL; int flag = 0; // local variable "status" declared and set, but never used //int status; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); size = v->size; size2 = 2*(size - 1); z = gsl_vector_alloc(size2); a = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(a, i, FUNCTION(gsl_vector,get)(v, i)); } if (argc == 1 && rb_obj_is_kind_of(argv[0], cgsl_poly_workspace)) { Data_Get_Struct(argv[0], gsl_poly_complex_workspace, w); flag = 0; } else { w = gsl_poly_complex_workspace_alloc(size); flag = 1; } /*status =*/ gsl_poly_complex_solve(a->data, size, w, z->data); r = gsl_vector_complex_alloc(size - 1); for (i = 0; i < size - 1; i++) { c.dat[0] = gsl_vector_get(z, i*2); c.dat[1] = gsl_vector_get(z, i*2+1); gsl_vector_complex_set(r, i, c); } gsl_vector_free(a); gsl_vector_free(z); if (flag == 1) gsl_poly_complex_workspace_free(w); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); } #ifdef BASE_INT static VALUE rb_gsl_poly_int_to_f(VALUE obj) { gsl_vector *v; gsl_vector_int *vi; size_t i; Data_Get_Struct(obj, gsl_vector_int, vi); v = gsl_vector_alloc(vi->size); for (i = 0; i < v->size; i++) gsl_vector_set(v, i, (double) gsl_vector_int_get(vi, i)); return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, v); } #endif #ifdef BASE_DOUBLE static VALUE rb_gsl_poly_to_i(VALUE obj) { gsl_vector *v; gsl_vector_int *vi; size_t i; Data_Get_Struct(obj, gsl_vector, v); vi = gsl_vector_int_alloc(v->size); for (i = 0; i < v->size; i++) gsl_vector_int_set(vi, i, (int) gsl_vector_get(v, i)); return Data_Wrap_Struct(cgsl_poly_int, 0, gsl_vector_int_free, vi); } static VALUE FUNCTION(rb_gsl_poly,workspace_new)(VALUE klass, VALUE n) { gsl_poly_complex_workspace *w = NULL; w = gsl_poly_complex_workspace_alloc(FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_poly_complex_workspace_free, w); } #ifdef GSL_1_1_LATER /* singleton method of the class Poly */ static VALUE rb_gsl_poly_dd_init(VALUE obj, VALUE vxa, VALUE vya) { gsl_vector *xa = NULL, *ya = NULL; gsl_poly *dd = NULL; Data_Get_Struct(vxa, gsl_vector, xa); Data_Get_Struct(vya, gsl_vector, ya); dd = gsl_vector_alloc(xa->size); gsl_poly_dd_init(dd->data, xa->data, ya->data, xa->size); return Data_Wrap_Struct(cgsl_poly_dd, 0, gsl_vector_free, dd); } static VALUE rb_gsl_poly_dd_eval(VALUE obj, VALUE xxa, VALUE xx) { gsl_vector *v = NULL; gsl_matrix *m = NULL; gsl_vector *dd = NULL, *xa, *vnew = NULL; gsl_matrix *mnew = NULL; VALUE x, ary; size_t size, i, j; Data_Get_Struct(obj, gsl_vector, dd); CHECK_VECTOR(xxa); Data_Get_Struct(xxa, gsl_vector, xa); switch (TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new(gsl_poly_dd_eval(dd->data, xa->data, dd->size, NUM2DBL(xx))); break; case T_ARRAY: size = RARRAY_LEN(xx); ary = rb_ary_new2(size); for (i = 0; i < size; i++) { x = rb_ary_entry(xx, i); Need_Float(x); rb_ary_store(ary, i, rb_float_new(gsl_poly_dd_eval(dd->data, xa->data, dd->size, NUM2DBL(x)))); } return ary; break; default: if (VEC_P(xx)) { Data_Get_Struct(xx, GSL_TYPE(gsl_vector), v); size = v->size; vnew = gsl_vector_alloc(v->size); for (i = 0; i < size; i++) { gsl_vector_set(vnew, i, gsl_poly_dd_eval(dd->data, xa->data, dd->size, FUNCTION(gsl_vector,get)(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MAT_P(xx)) { Data_Get_Struct(xx, GSL_TYPE(gsl_matrix), m); size = m->size1; mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, gsl_poly_dd_eval(dd->data, xa->data, dd->size, gsl_matrix_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } return Qnil; /* never reach here */ } static VALUE rb_gsl_poly_dd_taylor(int argc, VALUE *argv, VALUE obj) { gsl_vector *dd = NULL; gsl_vector *xa, *c = NULL, *w = NULL; double xp; size_t size; int flag = 0; Data_Get_Struct(obj, gsl_vector, dd); switch (argc) { case 2: size = dd->size; xp = NUM2DBL(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, xa); w = gsl_vector_alloc(size); flag = 1; break; case 3: xp = NUM2DBL(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, xa); if (TYPE(argv[2]) == T_FIXNUM) { size = FIX2INT(argv[2]); w = gsl_vector_alloc(size); flag = 1; } else { CHECK_VEC(argv[2]); Data_Get_Struct(argv[2], GSL_TYPE(gsl_vector), w); size = dd->size; } break; case 4: Need_Float(argv[0]); CHECK_VECTOR(argv[1]); CHECK_FIXNUM(argv[2]); CHECK_VECTOR(argv[3]); xp = NUM2DBL(argv[0]); Data_Get_Struct(argv[1], gsl_vector, xa); size = FIX2INT(argv[2]); Data_Get_Struct(argv[3], GSL_TYPE(gsl_vector), w); break; default: rb_raise(rb_eArgError, "wrong number of arguments"); } c = gsl_vector_alloc(size); gsl_poly_dd_taylor(c->data, xp, dd->data, xa->data, size, w->data); if (flag == 1) gsl_vector_free(w); return Data_Wrap_Struct(cgsl_poly_taylor, 0, gsl_vector_free, c); } #endif #endif static VALUE FUNCTION(rb_gsl_poly,order)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); return INT2FIX(v->size - 1); } int FUNCTION(gsl_poly,conv)(const BASE *a, size_t na, const BASE *b, size_t nb, BASE *c, size_t *nc) { BASE x; size_t i, j; *nc = na + nb - 1; for (i = 0; i < *nc; i++) c[i] = 0; for (i = 0; i < *nc; i++) { if (i >= na) break; x = a[i]; for (j = 0; j < *nc; j++) { if (j >= nb) break; else c[i+j] += x*b[j]; } } return 0; } GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,conv_vector)(const GSL_TYPE(gsl_vector) *v1, const GSL_TYPE(gsl_vector) *v2) { GSL_TYPE(gsl_vector) *vnew = NULL; size_t n, tmp; if (v1->size == 1) { vnew = FUNCTION(make_vector,clone)(v2); FUNCTION(gsl_vector,scale)(vnew, FUNCTION(gsl_vector,get)(v1, 0)); return vnew; } else if (v2->size == 1) { vnew = FUNCTION(make_vector,clone)(v1); FUNCTION(gsl_vector,scale)(vnew, FUNCTION(gsl_vector,get)(v2, 0)); return vnew; } else { n = v1->size + v2->size - 1; vnew = FUNCTION(gsl_vector,calloc)(n); FUNCTION(gsl_poly,conv)(v1->data, v1->size, v2->data, v2->size, vnew->data, &tmp); return vnew; } } GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,reduce)(const GSL_TYPE(gsl_vector) *v) { size_t i, nn = v->size; GSL_TYPE(gsl_vector) *vnew = NULL; for (i = v->size-1; 0 <= (int) i; i--) { if (!gsl_fcmp(FUNCTION(gsl_vector,get)(v, i), 0.0, 1e-10)) { nn = i; break; } } if (nn == 0) nn = v->size; vnew = FUNCTION(gsl_vector,alloc)(nn); for (i = 0; i < nn; i++) { FUNCTION(gsl_vector,set)(vnew, i, FUNCTION(gsl_vector,get)(v, i)); } return vnew; } GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,deriv)(const GSL_TYPE(gsl_vector) *v) { GSL_TYPE(gsl_vector) *vnew = NULL; size_t i; vnew = FUNCTION(gsl_vector,alloc)(v->size - 1); for (i = 0; i < v->size - 1; i++) { FUNCTION(gsl_vector,set)(vnew, i, FUNCTION(gsl_vector,get)(v, i+1)*(i+1)); } return vnew; } GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,integ)(const GSL_TYPE(gsl_vector) *v) { GSL_TYPE(gsl_vector) *vnew = NULL; size_t i; vnew = FUNCTION(gsl_vector,alloc)(v->size + 1); FUNCTION(gsl_vector,set)(vnew, 0, 0.0); for (i = 1; i < v->size + 1; i++) { FUNCTION(gsl_vector,set)(vnew, i, FUNCTION(gsl_vector,get)(v, i-1)/i); } return vnew; } GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,deconv_vector)(const GSL_TYPE(gsl_vector) *c, const GSL_TYPE(gsl_vector) *a, GSL_TYPE(gsl_vector) **r) { GSL_TYPE(gsl_vector) *vnew = NULL, *a2 = NULL, *c2 = NULL, *vtmp = NULL; GSL_TYPE(gsl_vector) *rtmp = NULL; BASE x, y, z, aa; size_t n, i, j, k, jj; c2 = FUNCTION(gsl_poly,reduce)(c); a2 = FUNCTION(gsl_poly,reduce)(a); n = c2->size - a2->size + 1; vnew = FUNCTION(gsl_vector,calloc)(n); rtmp = FUNCTION(gsl_vector,alloc)(c2->size - 1); aa = FUNCTION(gsl_vector,get)(a2, a2->size - 1); FUNCTION(gsl_vector,set)(vnew, n-1, FUNCTION(gsl_vector,get)(c2, c2->size-1)/aa); for (i = n - 2, k = 1; k < n; i--, k++) { x = FUNCTION(gsl_vector,get)(c2, c2->size-1-k); for (j = n-1; j >= 0; j--) { z = FUNCTION(gsl_vector,get)(vnew, j); jj = c2->size-1-k-j; if (jj > k || jj < 0) continue; y = FUNCTION(gsl_vector,get)(a2, jj); x -= y*z; } FUNCTION(gsl_vector,set)(vnew, i, x/aa); } vtmp = FUNCTION(gsl_poly,conv_vector)(vnew, a2); for (i = 0; i < rtmp->size; i++) { x = FUNCTION(gsl_vector,get)(c2, i); y = FUNCTION(gsl_vector,get)(vtmp, i); FUNCTION(gsl_vector,set)(rtmp, i, x - y); } *r = FUNCTION(gsl_poly,reduce)(rtmp); FUNCTION(gsl_vector,free)(rtmp); FUNCTION(gsl_vector,free)(vtmp); FUNCTION(gsl_vector,free)(c2); FUNCTION(gsl_vector,free)(a2); return vnew; } GSL_TYPE(gsl_poly)* FUNCTION(get_poly,get)(VALUE obj, int *flag) { GSL_TYPE(gsl_poly) *p = NULL; size_t i; switch (TYPE(obj)) { case T_ARRAY: p = FUNCTION(gsl_vector,alloc)(RARRAY_LEN(obj)); for (i = 0; i < p->size; i++) FUNCTION(gsl_vector,set)(p, i, (BASE) NUM2DBL(rb_ary_entry(obj, i))); *flag = 1; break; case T_FLOAT: case T_FIXNUM: p = FUNCTION(gsl_vector,alloc)(1); FUNCTION(gsl_vector,set)(p, 0, (BASE) NUM2DBL(obj)); *flag = 1; break; default: CHECK_VEC(obj); Data_Get_Struct(obj, GSL_TYPE(gsl_vector), p); *flag = 0; break; } return p; } static VALUE FUNCTION(rb_gsl_poly,conv)(VALUE obj, VALUE bb) { GSL_TYPE(gsl_vector) *v = NULL, *v2 = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (TYPE(bb)) { case T_FIXNUM: case T_FLOAT: vnew = FUNCTION(gsl_vector,alloc)(v->size); FUNCTION(gsl_vector,memcpy)(vnew, v); FUNCTION(gsl_vector,scale)(vnew, (BASE) NUM2DBL(bb)); break; default: CHECK_VEC(bb); Data_Get_Struct(bb, GSL_TYPE(gsl_vector), v2); vnew = FUNCTION(gsl_poly,conv_vector)(v, v2); break; } return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); } VALUE FUNCTION(rb_gsl_poly,deconv)(VALUE obj, VALUE bb) { GSL_TYPE(gsl_poly) *v = NULL, *v2 = NULL, *vnew = NULL, *r = NULL; int flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (TYPE(bb)) { case T_ARRAY: v2 = FUNCTION(get_poly,get)(bb, &flag); break; case T_FLOAT: case T_FIXNUM: v2 = FUNCTION(gsl_vector,alloc)(1); FUNCTION(gsl_vector,set)(v2, 0, (BASE) NUM2DBL(bb)); break; default: CHECK_VEC(bb); Data_Get_Struct(bb, GSL_TYPE(gsl_vector), v2); break; } vnew = FUNCTION(gsl_poly,deconv_vector)(v, v2, &r); if (flag == 1) FUNCTION(gsl_vector,free)(v2); if (FUNCTION(gsl_vector,isnull)(r)) return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); else return rb_ary_new3(2, Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew), Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), r)); } static VALUE FUNCTION(rb_gsl_poly,reduce)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_poly,reduce)(v); if (vnew == NULL) { return Qnil; } else if (vnew->size == 0) { return Qnil; } else if (FUNCTION(gsl_vector,isnull)(vnew)) { return INT2FIX(0); } else if (vnew->size == 1) { return rb_float_new(FUNCTION(gsl_vector,get)(vnew, 0)); } else { return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); } return Qnil; /* never reach here */ } static VALUE FUNCTION(rb_gsl_poly,deriv)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_poly,deriv)(v); return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_poly,integ)(VALUE obj) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(gsl_poly,integ)(v); return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_poly,conv2)(VALUE klass, VALUE v1, VALUE v2) { GSL_TYPE(gsl_poly) *p1 = NULL, *p2 = NULL, *p3 = NULL; int flag1 = 0, flag2 = 0; size_t i; VALUE ary; p1 = FUNCTION(get_poly,get)(v1, &flag1); p2 = FUNCTION(get_poly,get)(v2, &flag2); p3 = FUNCTION(gsl_poly,conv_vector)(p1, p2); if (flag1 == 1) FUNCTION(gsl_vector,free)(p1); if (flag2 == 1) FUNCTION(gsl_vector,free)(p2); if (flag1 == 1 && flag2 == 1) { ary = rb_ary_new2(p3->size); for (i = 0; i < p3->size; i++) rb_ary_store(ary, i, C_TO_VALUE2(FUNCTION(gsl_vector,get)(p3, i))); FUNCTION(gsl_vector,free)(p3); return ary; } else { return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), p3); } } static VALUE FUNCTION(rb_gsl_poly,deconv2)(VALUE klass, VALUE v1, VALUE v2) { GSL_TYPE(gsl_poly) *p1 = NULL, *p2 = NULL; GSL_TYPE(gsl_poly) *r = NULL, *vnew = NULL; int flag1 = 0, flag2 = 0; p1 = FUNCTION(get_poly,get)(v1, &flag1); p2 = FUNCTION(get_poly,get)(v2, &flag2); vnew = FUNCTION(gsl_poly,deconv_vector)(p1, p2, &r); if (flag1 == 1) FUNCTION(gsl_vector,free)(p1); if (flag2 == 1) FUNCTION(gsl_vector,free)(p2); if (FUNCTION(gsl_vector,isnull)(r)) return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); else return rb_ary_new3(2, Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew), Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), r)); } GSL_TYPE(gsl_poly)* FUNCTION(gsl_poly,add)(const GSL_TYPE(gsl_poly) *a, const GSL_TYPE(gsl_poly) *b) { GSL_TYPE(gsl_poly) *c = NULL; const GSL_TYPE(gsl_poly) *longer; size_t i, n; if (a->size > b->size) { c = FUNCTION(gsl_vector,alloc)(a->size); longer = a; } else { c = FUNCTION(gsl_vector,alloc)(b->size); longer = b; } n = GSL_MIN(a->size, b->size); for (i = 0; i < n; i++) { FUNCTION(gsl_vector,set)(c, i, FUNCTION(gsl_vector,get)(a, i) + FUNCTION(gsl_vector,get)(b, i)); } for (i = n; i < c->size; i++) FUNCTION(gsl_vector,set)(c, i, FUNCTION(gsl_vector,get)(longer, i)); return c; } static VALUE FUNCTION(rb_gsl_poly,add)(VALUE obj, VALUE bb) { GSL_TYPE(gsl_vector) *v = NULL, *vnew = NULL, *vb = NULL; BASE b; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); switch (TYPE(bb)) { case T_FLOAT: case T_FIXNUM: b = (BASE) NUM2DBL(bb); vnew = FUNCTION(gsl_vector,alloc)(v->size); FUNCTION(gsl_vector,memcpy)(vnew, v); FUNCTION(gsl_vector,set)(vnew, 0, FUNCTION(gsl_vector,get)(v, 0) + b); break; default: CHECK_VEC(bb); Data_Get_Struct(bb, GSL_TYPE(gsl_vector), vb); vnew = FUNCTION(gsl_poly,add)(v, vb); } return Data_Wrap_Struct(CLASS_OF(obj), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE rb_gsl_poly_uminus(VALUE obj); static VALUE rb_gsl_poly_int_uminus(VALUE obj); static VALUE FUNCTION(rb_gsl_poly,sub)(VALUE obj, VALUE bb) { switch (TYPE(bb)) { case T_FLOAT: case T_FIXNUM: return FUNCTION(rb_gsl_poly,add)(obj, C_TO_VALUE2(-(BASE)NUM2DBL(bb))); break; default: CHECK_VEC(bb); return FUNCTION(rb_gsl_poly,add)(obj, FUNCTION(rb_gsl_poly,uminus)(bb)); break; } } static VALUE FUNCTION(rb_gsl_poly,uminus)(VALUE obj) { GSL_TYPE(gsl_poly) *p = NULL, *pnew = NULL; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), p); pnew = FUNCTION(gsl_vector,alloc)(p->size); for (i = 0; i < pnew->size; i++) FUNCTION(gsl_vector,set)(pnew, i, -FUNCTION(gsl_vector,get)(p, i)); return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), pnew); } static VALUE FUNCTION(rb_gsl_poly,uplus)(VALUE obj) { return obj; } static VALUE FUNCTION(rb_gsl_poly,coerce)(VALUE obj, VALUE other) { GSL_TYPE(gsl_vector) *vb; switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: vb = FUNCTION(gsl_vector,calloc)(1); FUNCTION(gsl_vector,set)(vb, 0, (BASE) NUM2DBL(other)); return rb_ary_new3(2, Data_Wrap_Struct(CLASS_OF(obj), 0, FUNCTION(gsl_vector,free), vb), obj); break; default: CHECK_VEC(other); return rb_ary_new3(3, other, obj); break; } } static VALUE FUNCTION(rb_gsl_poly,to_gv)(VALUE obj) { GSL_TYPE(gsl_vector) *v, *vnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_vector), v); vnew = FUNCTION(make_vector,clone)(v); return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew); } static VALUE FUNCTION(rb_gsl_poly,companion_matrix)(VALUE obj) { GSL_TYPE(gsl_poly) *p = NULL; BASE z; gsl_matrix *m; size_t i, j, size; Data_Get_Struct(obj, GSL_TYPE(gsl_poly), p); size = p->size - 1; m = gsl_matrix_calloc(size, size); z = FUNCTION(gsl_vector,get)(p, size); for (j = 0; j < size; j++) gsl_matrix_set(m, 0, size-j-1, -FUNCTION(gsl_vector,get)(p, j)/z); for (i = 1; i < size; i++) { gsl_matrix_set(m, i, i-1, 1.0); } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m); } static VALUE FUNCTION(rb_gsl_poly,info)(VALUE obj) { GSL_TYPE(gsl_poly) *v; char buf[256]; Data_Get_Struct(obj, GSL_TYPE(gsl_poly), v); sprintf(buf, "Class: %s\n", rb_class2name(CLASS_OF(obj))); #ifdef RUBY_1_9_LATER sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj)))); #else sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super)); #endif sprintf(buf, "%sOrder: %d\n", buf, (int) v->size-1); return rb_str_new2(buf); } #ifdef BASE_DOUBLE #include "rb_gsl_fit.h" /* singleton */ static VALUE rb_gsl_poly_fit(int argc, VALUE *argv, VALUE obj) { gsl_multifit_linear_workspace *space = NULL; gsl_matrix *X = NULL, *cov = NULL; gsl_vector *x, *y = NULL, *c = NULL; gsl_vector_view xx, yy; size_t order, i, j; double chisq, val; int status, flag = 0; VALUE vc, vcov; if (argc != 3 && argc != 4) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc); x = &xx.vector; y = &yy.vector; Data_Get_Vector(argv[0], x); Data_Get_Vector(argv[1], y); order = NUM2INT(argv[2]); if (argc == 4) { Data_Get_Struct(argv[3], gsl_multifit_linear_workspace, space); } else { space = gsl_multifit_linear_alloc(x->size, order + 1); flag = 1; } cov = gsl_matrix_alloc(order + 1, order + 1); c = gsl_vector_alloc(order + 1); X = gsl_matrix_alloc(x->size, order + 1); for (i = 0; i < x->size; i++) { val = 1.0; gsl_matrix_set(X, i, 0, val); for (j = 1; j <= order; j++) { val *= gsl_vector_get(x, i); gsl_matrix_set(X, i, j, val); } } status = gsl_multifit_linear(X, y, c, cov, &chisq, space); if (flag == 1) gsl_multifit_linear_free(space); vc = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, c); vcov = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, cov); gsl_matrix_free(X); return rb_ary_new3(4, vc, vcov, rb_float_new(chisq), INT2FIX(status)); } static VALUE rb_gsl_poly_wfit(int argc, VALUE *argv, VALUE obj) { gsl_multifit_linear_workspace *space = NULL; gsl_matrix *X = NULL, *cov = NULL; gsl_vector *x, *y = NULL, *w, *c = NULL; size_t order, i, j; double chisq, val; int status, flag = 0; VALUE vc, vcov; if (argc != 4 && argc != 5) rb_raise(rb_eArgError, "wrong number of arguments (%d for 4 or 5)", argc); Data_Get_Vector(argv[0], x); Data_Get_Vector(argv[1], w); Data_Get_Vector(argv[2], y); order = NUM2INT(argv[3]); if (argc == 5) { Data_Get_Struct(argv[4], gsl_multifit_linear_workspace, space); } else { space = gsl_multifit_linear_alloc(x->size, order + 1); flag = 1; } cov = gsl_matrix_alloc(order + 1, order + 1); c = gsl_vector_alloc(order + 1); X = gsl_matrix_alloc(x->size, order + 1); for (i = 0; i < x->size; i++) { val = 1.0; gsl_matrix_set(X, i, 0, val); for (j = 1; j <= order; j++) { val *= gsl_vector_get(x, i); gsl_matrix_set(X, i, j, val); } } status = gsl_multifit_wlinear(X, w, y, c, cov, &chisq, space); if (flag == 1) gsl_multifit_linear_free(space); vc = Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, c); vcov = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, cov); gsl_matrix_free(X); return rb_ary_new3(4, vc, vcov, rb_float_new(chisq), INT2FIX(status)); } #endif #ifdef BASE_DOUBLE #ifdef GSL_1_13_LATER static VALUE rb_gsl_poly_eval_derivs_singleton(int argc, VALUE *argv, VALUE klass) { VALUE ary; gsl_vector *v = NULL, *v2 = NULL; size_t i, lenc, lenres; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; int shape[1]; #endif if (argc < 2) rb_raise(rb_eArgError, "Wrong number of arguments (%d for >= 2)", argc); if (rb_obj_is_kind_of(argv[0], rb_cArray)) { v = gsl_vector_alloc(RARRAY_LEN(argv[0])); lenc = v->size; for (i = 0; i < lenc; i++) { gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(argv[0], i))); } if (argc == 2) lenres = lenc + 1; else lenres = FIX2INT(argv[2]); v2 = gsl_vector_alloc(lenres); gsl_poly_eval_derivs(v->data, lenc, NUM2DBL(argv[1]), v2->data, lenres); ary = rb_ary_new2(lenres); for (i = 0; i < lenres; i++) { rb_ary_store(ary, i, rb_float_new(gsl_vector_get(v2, i))); } gsl_vector_free(v2); gsl_vector_free(v); return ary; } if (rb_obj_is_kind_of(argv[0], cgsl_vector)) { Data_Get_Struct(argv[0], gsl_vector, v); lenc = v->size; if (argc == 2) lenres = lenc + 1; else lenres = FIX2INT(argv[2]); v2 = gsl_vector_alloc(lenres); gsl_poly_eval_derivs(v->data, lenc, NUM2DBL(argv[1]), v2->data, lenres); return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, v2); } #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) { GetNArray(argv[0], na); ptr1 = (double*) na->ptr; lenc = na->total; if (argc == 2) lenres = lenc + 1; else lenres = FIX2INT(argv[2]); shape[0] = lenres; ary = na_make_object(NA_DFLOAT, na->rank, shape, CLASS_OF(argv[0])); ptr2 = NA_PTR_TYPE(ary,double*); gsl_poly_eval_derivs(ptr1, lenc, NUM2DBL(argv[1]), ptr2, lenres); return ary; } #endif return Qnil; // Never comes here } static VALUE rb_gsl_poly_eval_derivs(int argc, VALUE *argv, VALUE obj) { gsl_vector *v, *v2; size_t lenc, lenres; Data_Get_Struct(obj, gsl_vector, v); lenc = v->size; switch (argc) { case 1: lenres = lenc + 1; break; case 2: lenres = FIX2INT(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for > 1)", argc); } v2 = gsl_vector_alloc(lenres); gsl_poly_eval_derivs(v->data, lenc, NUM2DBL(argv[0]), v2->data, lenres); return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, v2); } #endif #endif void FUNCTION(Init_gsl_poly,init)(VALUE module) { #ifdef BASE_DOUBLE VALUE mgsl_poly_complex; cgsl_poly = rb_define_class_under(module, "Poly", cgsl_vector); cgsl_poly_int = rb_define_class_under(cgsl_poly, "Int", cgsl_vector_int); cgsl_poly_workspace = rb_define_class_under(cgsl_poly, "Workspace", cGSL_Object); mgsl_poly_complex = rb_define_module_under(cgsl_poly, "Complex"); cgsl_poly_complex_workspace = rb_define_class_under(mgsl_poly_complex, "Workspace", cGSL_Object); rb_define_singleton_method(cgsl_poly_workspace, "alloc", rb_gsl_poly_workspace_new, 1); rb_define_singleton_method(cgsl_poly_complex_workspace, "alloc", rb_gsl_poly_workspace_new, 1); rb_define_singleton_method(mgsl_poly_complex, "solve_quadratic", FUNCTION(rb_gsl_poly,complex_solve_quadratic), -1); rb_define_singleton_method(mgsl_poly_complex, "solve_cubic", FUNCTION(rb_gsl_poly,complex_solve_cubic), -1); #ifdef HAVE_POLY_SOLVE_QUARTIC rb_define_singleton_method(mgsl_poly_complex, "solve_quartic", FUNCTION(rb_gsl_poly,complex_solve_quartic), -1); #endif rb_define_singleton_method(mgsl_poly_complex, "solve", FUNCTION(rb_gsl_poly,complex_solve), -1); rb_define_singleton_method(mgsl_poly_complex, "roots", FUNCTION(rb_gsl_poly,complex_solve), -1); #endif rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_quadratic", FUNCTION(rb_gsl_poly,solve_quadratic), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_cubic", FUNCTION(rb_gsl_poly,solve_cubic), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_quadratic", FUNCTION(rb_gsl_poly,complex_solve_quadratic), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_cubic", FUNCTION(rb_gsl_poly,complex_solve_cubic), -1); #ifdef HAVE_POLY_SOLVE_QUARTIC rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_quartic", FUNCTION(rb_gsl_poly,solve_quartic), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_quartic", FUNCTION(rb_gsl_poly,complex_solve_quartic), -1); #endif rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve", FUNCTION(rb_gsl_poly,complex_solve), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve", FUNCTION(rb_gsl_poly,complex_solve), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "roots", FUNCTION(rb_gsl_poly,complex_solve), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "eval", FUNCTION(rb_gsl_poly,eval2), -1); rb_define_method(GSL_TYPE(cgsl_poly), "eval", FUNCTION(rb_gsl_poly,eval), 1); rb_define_alias(GSL_TYPE(cgsl_poly), "at", "eval"); rb_define_method(GSL_TYPE(cgsl_poly), "solve_quadratic", FUNCTION(rb_gsl_poly,solve_quadratic2), 0); rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_quadratic", FUNCTION(rb_gsl_poly,complex_solve_quadratic2), 0); rb_define_method(GSL_TYPE(cgsl_poly), "solve_cubic", FUNCTION(rb_gsl_poly,solve_cubic2), 0); rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_cubic", FUNCTION(rb_gsl_poly,complex_solve_cubic2), 0); #ifdef HAVE_POLY_SOLVE_QUARTIC rb_define_method(GSL_TYPE(cgsl_poly), "solve_quartic", FUNCTION(rb_gsl_poly,solve_quartic2), 0); rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_quartic", FUNCTION(rb_gsl_poly,complex_solve_quartic2), 0); #endif rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve", FUNCTION(rb_gsl_poly,complex_solve2), -1); rb_define_alias(GSL_TYPE(cgsl_poly), "solve", "complex_solve"); rb_define_alias(GSL_TYPE(cgsl_poly), "roots", "complex_solve"); #ifdef BASE_INT rb_define_method(cgsl_poly_int, "to_f", rb_gsl_poly_int_to_f, 0); #endif #ifdef BASE_DOUBLE // rb_define_singleton_method(cgsl_poly, "eval", rb_gsl_poly_eval_singleton, 2); rb_define_method(cgsl_poly, "to_i", rb_gsl_poly_to_i, 0); #ifdef GSL_1_11_LATER rb_define_singleton_method(cgsl_poly, "complex_eval", rb_gsl_poly_eval_singleton, 2); rb_define_method(cgsl_vector_complex, "eval", rb_gsl_complex_poly_complex_eval, 1); #endif #ifdef GSL_1_1_LATER cgsl_poly_dd = rb_define_class_under(cgsl_poly, "DividedDifference", cgsl_poly); cgsl_poly_taylor = rb_define_class_under(cgsl_poly, "Taylor", cgsl_poly); rb_define_singleton_method(cgsl_poly, "dd_init", rb_gsl_poly_dd_init, 2); rb_define_method(cgsl_poly_dd, "eval",rb_gsl_poly_dd_eval, 2); rb_define_method(cgsl_poly_dd, "taylor", rb_gsl_poly_dd_taylor, -1); #endif #endif rb_define_method(GSL_TYPE(cgsl_poly), "order", FUNCTION(rb_gsl_poly,order), 0); /*****/ rb_define_method(GSL_TYPE(cgsl_poly), "conv", FUNCTION(rb_gsl_poly,conv), 1); rb_define_alias(GSL_TYPE(cgsl_poly), "*", "conv"); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "conv", FUNCTION(rb_gsl_poly,conv2), 2); rb_define_method(GSL_TYPE(cgsl_poly), "deconv", FUNCTION(rb_gsl_poly,deconv), 1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "deconv", FUNCTION(rb_gsl_poly,deconv2), 2); rb_define_method(GSL_TYPE(cgsl_poly), "reduce", FUNCTION(rb_gsl_poly,reduce), 1); rb_define_method(GSL_TYPE(cgsl_poly), "deriv", FUNCTION(rb_gsl_poly,deriv), 1); rb_define_method(GSL_TYPE(cgsl_poly), "integ", FUNCTION(rb_gsl_poly,integ), 1); /*****/ rb_define_method(GSL_TYPE(cgsl_poly), "add", FUNCTION(rb_gsl_poly,add), 1); rb_define_alias(GSL_TYPE(cgsl_poly), "+", "add"); rb_define_method(GSL_TYPE(cgsl_poly), "sub", FUNCTION(rb_gsl_poly,sub), 1); rb_define_alias(GSL_TYPE(cgsl_poly), "-", "sub"); rb_define_method(GSL_TYPE(cgsl_poly), "-@", FUNCTION(rb_gsl_poly,uminus), 0); rb_define_method(GSL_TYPE(cgsl_poly), "+@", FUNCTION(rb_gsl_poly,uplus), 0); rb_define_method(GSL_TYPE(cgsl_poly), "coerce", FUNCTION(rb_gsl_poly,coerce), 1); rb_define_method(GSL_TYPE(cgsl_poly), "to_gv", FUNCTION(rb_gsl_poly,to_gv), 0); rb_define_alias(GSL_TYPE(cgsl_poly), "to_v", "to_gv"); rb_define_method(GSL_TYPE(cgsl_poly), "companion_matrix", FUNCTION(rb_gsl_poly,companion_matrix), 0); rb_define_alias(GSL_TYPE(cgsl_poly), "compan", "companion_matrix"); /*****/ rb_define_method(GSL_TYPE(cgsl_poly), "info", FUNCTION(rb_gsl_poly,info), 0); #ifdef BASE_DOUBLE rb_define_singleton_method(GSL_TYPE(cgsl_poly), "fit", FUNCTION(rb_gsl_poly,fit), -1); rb_define_singleton_method(GSL_TYPE(cgsl_poly), "wfit", FUNCTION(rb_gsl_poly,wfit), -1); #ifdef GSL_1_13_LATER rb_define_singleton_method(cgsl_poly, "eval_derivs", rb_gsl_poly_eval_derivs_singleton, -1); rb_define_method(cgsl_vector, "eval_derivs", rb_gsl_poly_eval_derivs, -1); #endif #endif } #undef NUMCONV #undef NUMCONV2 #undef PRINTF_FORMAT #undef VEC_ROW_COL #undef VEC_P #undef C_TO_VALUE #undef C_TO_VALUE2 #undef VEC_COL_P #undef VEC_ROW_P #undef CHECK_VEC #undef VEC_VIEW_P #undef MAT_ROW_COL #undef MAT_P #undef C_TO_VALUE #undef MAT_COL_P #undef MAT_ROW_P #undef CHECK_MAT #undef MAT_VIEW_P gsl-1.15.3/ext/matrix_source.c0000644000175000017500000025761412220252463015611 0ustar boutilboutil/* matrix_source.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #ifdef BASE_DOUBLE #define NUMCONV(x) NUM2DBL(x) #define NUMCONV2(x) NUM2DBL(x) #define PRINTF_FORMAT "%4.3e " #define MAT_ROW_COL MATRIX_ROW_COL #define MAT_P MATRIX_P #define MAT_ROW_P MATRIX_ROW_P #define MAT_COL_P MATRIX_COL_P #define C_TO_VALUE rb_float_new #define C_TO_VALUE2 rb_float_new #define CHECK_MAT CHECK_MATRIX #define MAT_VIEW_P MATRIX_VIEW_P #define VEC_ROW_COL VECTOR_ROW_COL #define VEC_P VECTOR_P #define VEC_ROW_P VECTOR_ROW_P #define VEC_COL_P VECTOR_COL_P #define CHECK_VEC CHECK_VECTOR #define VEC_VIEW_P VECTOR_VIEW_P #elif defined(BASE_INT) #define NUMCONV(x) FIX2INT(x) #define NUMCONV2(x) NUM2INT(x) #define PRINTF_FORMAT "%d " #define MAT_ROW_COL MATRIX_INT_ROW_COL #define MAT_P MATRIX_INT_P #define C_TO_VALUE INT2FIX #define C_TO_VALUE2 INT2NUM #define MAT_ROW_P MATRIX_INT_ROW_P #define MAT_COL_P MATRIX_INT_COL_P #define CHECK_MAT CHECK_MATRIX_INT #define MAT_VIEW_P MATRIX_INT_VIEW_P #define VEC_ROW_COL VECTOR_INT_ROW_COL #define VEC_P VECTOR_INT_P #define VEC_ROW_P VECTOR_INT_ROW_P #define VEC_COL_P VECTOR_INT_COL_P #define CHECK_VEC CHECK_VECTOR_INT #define VEC_VIEW_P VECTOR_INT_VIEW_P #endif // From ext/vector_source.c void FUNCTION(get_range,beg_en_n)(VALUE range, BASE *beg, BASE *en, size_t *n, int *step); // From ext/vector_source.c void get_range_beg_en_n_for_size(VALUE range, int *beg, int *en, size_t *n, int *step, size_t size); void parse_submatrix_args(int argc, VALUE *argv, size_t size1, size_t size2, size_t *i, size_t *j, size_t *n1, size_t *n2); #ifdef BASE_DOUBLE void parse_submatrix_args(int argc, VALUE *argv, size_t size1, size_t size2, size_t *i, size_t *j, size_t *n1, size_t *n2) { int ii, ij, in1, in2, end, step; switch (argc) { // no args -> same as submatrix(0, 0, size1, size2) case 0: *i = 0; *j = 0; *n1 = size1; *n2 = size2; break; // Fixnum -> Same as submatrix(i/size2, i%size2, 1, 1) case 1: CHECK_FIXNUM(argv[0]); ii = FIX2INT(argv[0]); *n1 = size1 * size2; if(ii < 0) ii += *n1; // TODO Bounds check? *i = ii / size2; *j = ii % size2; *n1 = 1; *n2 = 1; break; // nil, nil -> all rows, all cols (Matrix::View) // nil, Range -> all rows, Range cols (Matrix::View) // nil, Fixnum -> all rows, single col (Vector::Col::View) // Range, nil -> Range rows, all cols (Matrix::View) // Range, Range -> Range rows, Range cols (Matrix::View) // Range, Fixnum -> Range rows, single col (Vector::Col::View) // Fixnum, nil -> single row, all cols (Vector::View) // Fixnum, Range -> single row, Range cols (Vector::View) // Fixnum, Fixnum -> single row, single col (Matrix::View) case 2: // nil, ... if(NIL_P(argv[0])) { // Parse second arg if(NIL_P(argv[1])) { // nil, nil -> all rows, all cols (Matrix::View) *i = 0; *j = 0; *n1 = size1; *n2 = size2; } else if(rb_obj_is_kind_of(argv[1], rb_cRange)) { // nil, Range -> all rows, Range cols (Matrix::View) *i = 0; *n1 = size1; get_range_beg_en_n_for_size(argv[1], &ij, &end, n2, &step, size2); if(step < 0 || *n2 <=0) { rb_raise(rb_eRangeError, "begin > end"); } *j = (size_t)ij; } else { // nil, Fixnum -> all rows, single col (Vector::Col::View) ij = NUM2INT(argv[1]); if(ij < 0) ij += size2; *i = 0; *j = (size_t)ij; *n1 = size1; *n2 = 0; // *n2 == 0 tells #submatrix to return Vector::Col::View } // Range, ... } else if(rb_obj_is_kind_of(argv[0], rb_cRange)) { get_range_beg_en_n_for_size(argv[0], &ii, &end, n1, &step, size1); if(step < 0 || *n1 <= 0) { rb_raise(rb_eRangeError, "arg0: begin > end"); } *i = (size_t)ii; // Parse second arg if(NIL_P(argv[1])) { // Range, nil -> Range rows, all cols (Matrix::View) *j = 0; *n2 = size2; } else if(rb_obj_is_kind_of(argv[1], rb_cRange)) { // Range, Range -> Range rows, Range cols (Matrix::View) get_range_beg_en_n_for_size(argv[1], &ij, &end, n2, &step, size2); if(step < 0 || *n2 <= 0) { rb_raise(rb_eRangeError, "arg1: begin > end"); } *j = (size_t)ij; } else { // Range, Fixnum -> Range rows, single col (Vector::Col::View) ij = NUM2INT(argv[1]); if(ij < 0) ij += size2; *j = (size_t) ij; *n2 = 0; // *n2 == 0 tells #submatrix to return Vector::Col::View } // Fixnum, ... } else { ii = NUM2INT(argv[0]); if(ii < 0) ii += size1; if(NIL_P(argv[1])) { // Fixnum, nil -> single row, all cols (Vector::View) *i = (size_t)ii; *j = 0; *n1 = 0; *n2 = size2; // *n1 == 0 tells #submatrix to return Vector::View } else if(rb_obj_is_kind_of(argv[1], rb_cRange)) { // Fixnum, Range -> single row, Range cols (Vector::View) get_range_beg_en_n_for_size(argv[1], &ij, &end, n2, &step, size2); if(step < 0 || *n2 <= 0) { rb_raise(rb_eRangeError, "arg1: begin > end"); } *i = (size_t)ii; *j = (size_t)ij; *n1 = 0; // *n1 == 0 tells #submatrix to return Vector::View } else { // Fixnum, Fixnum -> single row, single col (Matrix::View) ij = NUM2INT(argv[1]); if(ij < 0) ij += size2; *i = (size_t)ii; *j = (size_t)ij; *n1 = 1; *n2 = 1; } } break; // nil, Fixnum, Fixnum -> All rows, some cols // Range, Fixnum, Fixnum -> Range rows, some cols // Fixnum, Fixnum, nil -> Some rows, all cols // Fixnum, Fixnum, Range -> Some rows, Range cols case 3: // nil, Fixnum, Fixnum if(NIL_P(argv[0])) { // nil, Fixnum, Fixnum -> All rows, some cols CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); *i = 0; ij = FIX2INT(argv[1]); *n1 = size1; in2 = FIX2INT(argv[2]); if(ij < 0) ij += size2; *j = (size_t) ij; *n2 = (size_t) in2; // Range, Fixnum, Fixnum } else if(rb_obj_is_kind_of(argv[0], rb_cRange)) { // Range, Fixnum, Fixnum -> Range rows, some cols CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); get_range_beg_en_n_for_size(argv[0], &ii, &end, n1, &step, size1); if(step < 0 || *n1 <= 0) { rb_raise(rb_eRangeError, "arg0: begin > end"); } ij = FIX2INT(argv[1]); in2 = FIX2INT(argv[2]); if(ij < 0) ij += size2; *i = (size_t)ii; *j = (size_t) ij; *n2 = (size_t) in2; // Fixnum, Fixnum, ... } else { CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); ii = FIX2INT(argv[0]); if(ii < 0) ii += size1; in1 = FIX2INT(argv[1]); *i = (size_t)ii; *n1 = (size_t)in1; // Parse arg2 if(NIL_P(argv[2])) { // Fixnum, Fixnum, nil -> Some rows, all cols *j = 0; *n2 = size2; } else if(rb_obj_is_kind_of(argv[2], rb_cRange)) { // Fixnum, Fixnum, Range -> Some rows, Range cols get_range_beg_en_n_for_size(argv[2], &ij, &end, n2, &step, size2); if(step < 0 || *n2 <= 0) { rb_raise(rb_eRangeError, "arg2: begin > end"); } *j = (size_t)ij; } else { rb_raise(rb_eArgError, "expected third argument to be nil or Range, not %s", rb_class2name(CLASS_OF(argv[2]))); } } break; case 4: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_FIXNUM(argv[2]); CHECK_FIXNUM(argv[3]); ii = FIX2INT(argv[0]); ij = FIX2INT(argv[1]); in1 = FIX2INT(argv[2]); in2 = FIX2INT(argv[3]); if(ii < 0) ii += size1; if(ij < 0) ij += size2; // TODO Bounds check? *i = (size_t)ii; *j = (size_t)ij; *n1 = (size_t)in1; *n2 = (size_t)in2; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 4)", argc); break; } } #endif VALUE FUNCTION(rb_gsl_matrix,do_something)(VALUE obj, void (*f)(GSL_TYPE(gsl_matrix) *)) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); (*f)(m); return obj; } static VALUE FUNCTION(create_matrix,from_range_shape)(VALUE range, VALUE nn1, VALUE nn2); static VALUE FUNCTION(create_matrix,from_ranges)(int argc, VALUE *argv); GSL_TYPE(gsl_matrix)* FUNCTION(gsl_matrix,alloc_from_colvectors)(int argc, VALUE *argv); static VALUE FUNCTION(rb_gsl_matrix,alloc)(int argc, VALUE *argv, VALUE klass) { GSL_TYPE(gsl_matrix) *m = NULL; size_t n1, n2; #ifdef HAVE_NARRAY_H size_t n; VALUE ary; struct NARRAY *na; #endif if (argc < 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 1)", argc); #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv[0])) { GetNArray(argv[0], na); n = na->shape[0]*na->shape[1]; m = FUNCTION(gsl_matrix,alloc)(na->shape[1], na->shape[0]); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); #ifdef BASE_DOUBLE ary = na_change_type(argv[0], NA_DFLOAT); #else ary = na_change_type(argv[0], NA_LINT); #endif memcpy(m->data, NA_PTR_TYPE(ary,BASE*), n*sizeof(BASE)); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); } #endif switch (TYPE(argv[0])) { case T_FIXNUM: if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); CHECK_FIXNUM(argv[1]); n1 = FIX2INT(argv[0]); n2 = FIX2INT(argv[1]); m = FUNCTION(gsl_matrix,calloc)(n1, n2); break; case T_ARRAY: if (argc == 1) { m = FUNCTION(gsl_matrix,alloc_from_arrays)(argc, argv); break; } if (CLASS_OF(argv[1]) == rb_cRange) argv[1] = rb_gsl_range2ary(argv[1]); switch (TYPE(argv[1])) { case T_ARRAY: m = FUNCTION(gsl_matrix,alloc_from_arrays)(argc, argv); break; case T_FIXNUM: if (argc != 3) rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); CHECK_FIXNUM(argv[2]); m = FUNCTION(gsl_matrix,alloc_from_array_sizes)(argv[0], argv[1], argv[2]); break; default: rb_raise(rb_eTypeError, "wrong argument type %s\nUsage: new(n1, n2), " "new([], [], [], ...), new([], n1, n2)", rb_class2name(CLASS_OF(argv[1]))); break; } break; default: if (CLASS_OF(argv[0]) == rb_cRange) { if (argc==3 && TYPE(argv[1]) == T_FIXNUM && TYPE(argv[2]) == T_FIXNUM) return FUNCTION(create_matrix,from_range_shape)(argv[0], argv[1], argv[2]); else return FUNCTION(create_matrix,from_ranges)(argc, argv); } else if (VEC_P(argv[0])) { if (argc == 3 && FIXNUM_P(argv[1]) && FIXNUM_P(argv[2])) { m = FUNCTION(gsl_matrix,alloc_from_vector_sizes)(argv[0], argv[1], argv[2]); } else { if (VEC_COL_P(argv[0])) { m = FUNCTION(gsl_matrix,alloc_from_colvectors)(argc, argv); } else { m = FUNCTION(gsl_matrix,alloc_from_vectors)(argc, argv); } } } else { rb_raise(rb_eTypeError, "wrong argument type %s\n" "Usage: new(n1, n2), new([], [], [], ...), new([], n1, n2)", rb_class2name(CLASS_OF(argv[0]))); } break; } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } void FUNCTION(set_ptr_data,by_range)(BASE *ptr, size_t n, VALUE range); static GSL_TYPE(gsl_matrix)* FUNCTION(cr_matrix,from_ranges)(int argc, VALUE *argv) { GSL_TYPE(gsl_matrix) *m; BASE beg, en; size_t i, n; int step; FUNCTION(get_range,beg_en_n)(argv[0], &beg, &en, &n, &step); m = FUNCTION(gsl_matrix,calloc)(argc, n); FUNCTION(set_ptr_data,by_range)(m->data, n, argv[0]); for (i = 1; i < argc; i++) { if (CLASS_OF(argv[i]) != rb_cRange) rb_raise(rb_eTypeError, "wrong argument type %s (Range expected)", rb_class2name(CLASS_OF(argv[i]))); FUNCTION(set_ptr_data,by_range)(m->data+i*n, n, argv[i]); } return m; } static VALUE FUNCTION(create_matrix,from_ranges)(int argc, VALUE *argv) { GSL_TYPE(gsl_matrix) *m; m = FUNCTION(cr_matrix,from_ranges)(argc, argv); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } static GSL_TYPE(gsl_matrix)* FUNCTION(cr_matrix,from_range_shape)(VALUE range, VALUE nn1, VALUE nn2) { size_t n1, n2; GSL_TYPE(gsl_matrix) *m; n1 = FIX2INT(nn1); n2 = FIX2INT(nn2); m = FUNCTION(gsl_matrix,alloc)(n1, n2); FUNCTION(set_ptr_data,by_range)(m->data, n1*n2, range); return m; } static VALUE FUNCTION(create_matrix,from_range_shape)(VALUE range, VALUE nn1, VALUE nn2) { GSL_TYPE(gsl_matrix) *m; m = FUNCTION(cr_matrix,from_range_shape)(range, nn1, nn2); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } /* create a matrix from arrays */ GSL_TYPE(gsl_matrix)* FUNCTION(gsl_matrix,alloc_from_arrays)(int argc, VALUE *argv) { size_t n, i, j; GSL_TYPE(gsl_matrix) *m = NULL; if (CLASS_OF(argv[0]) == rb_cRange) argv[0] = rb_gsl_range2ary(argv[0]); else Check_Type(argv[0], T_ARRAY); n = RARRAY_LEN(argv[0]); m = FUNCTION(gsl_matrix,alloc)(argc, n); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); for (i = 0; i < argc; i++) { if (CLASS_OF(argv[i]) == rb_cRange) argv[i] = rb_gsl_range2ary(argv[i]); else Check_Type(argv[i], T_ARRAY); for (j = 0; j < n; j++) { if (j >= RARRAY_LEN(argv[i])) FUNCTION(gsl_matrix,set)(m, i, j, 0); else FUNCTION(gsl_matrix,set)(m, i, j, NUMCONV2(rb_ary_entry(argv[i], j))); } } return m; } GSL_TYPE(gsl_matrix)* FUNCTION(gsl_matrix,alloc_from_vectors)(int argc, VALUE *argv) { size_t i; GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); m = FUNCTION(gsl_matrix,alloc)(argc, v->size); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); for (i = 0; i < argc; i++) { CHECK_VEC(argv[i]); Data_Get_Struct(argv[i], GSL_TYPE(gsl_vector), v); FUNCTION(gsl_matrix,set_row)(m, i, v); } return m; } GSL_TYPE(gsl_matrix)* FUNCTION(gsl_matrix,alloc_from_colvectors)(int argc, VALUE *argv) { size_t i; GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; if (argc < 1) rb_raise(rb_eArgError, "too few arguments"); CHECK_VEC(argv[0]); Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v); // m = FUNCTION(gsl_matrix,alloc)(argc, v->size); m = FUNCTION(gsl_matrix,alloc)(v->size, argc); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); for (i = 0; i < argc; i++) { CHECK_VEC(argv[i]); Data_Get_Struct(argv[i], GSL_TYPE(gsl_vector), v); FUNCTION(gsl_matrix,set_col)(m, i, v); } return m; } /* create a matrix from two sizes and an array */ GSL_TYPE(gsl_matrix)* FUNCTION(gsl_matrix,alloc_from_array_sizes)(VALUE ary, VALUE nn1, VALUE nn2) { size_t n1, n2, len; GSL_TYPE(gsl_matrix) *m = NULL; size_t i, j, k; CHECK_FIXNUM(nn1); CHECK_FIXNUM(nn2); Check_Type(ary, T_ARRAY); n1 = FIX2INT(nn1); n2 = FIX2INT(nn2); m = FUNCTION(gsl_matrix,alloc)(n1, n2); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); k = 0; len = RARRAY_LEN(ary); for (i = 0; i < n1; i++) { for (j = 0; j < n2; j++, k++) { if (k >= len) FUNCTION(gsl_matrix,set)(m, i, j, (BASE) 0); else FUNCTION(gsl_matrix,set)(m, i, j, (BASE) NUMCONV2(rb_ary_entry(ary, k))); } } return m; } GSL_TYPE(gsl_matrix)* FUNCTION(gsl_matrix,alloc_from_vector_sizes)(VALUE ary, VALUE nn1, VALUE nn2) { size_t n1, n2; GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; size_t i, j, k; CHECK_VEC(ary); CHECK_FIXNUM(nn1); CHECK_FIXNUM(nn2); Data_Get_Struct(ary, GSL_TYPE(gsl_vector), v); n1 = FIX2INT(nn1); n2 = FIX2INT(nn2); m = FUNCTION(gsl_matrix,alloc)(n1, n2); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); k = 0; for (i = 0; i < n1; i++) { for (j = 0; j < n2; j++, k++) { if (k >= v->size) FUNCTION(gsl_matrix,set)(m, i, j, (BASE) 0); else FUNCTION(gsl_matrix,set)(m, i, j, FUNCTION(gsl_vector,get)(v, k)); } } return m; } static VALUE FUNCTION(rb_gsl_matrix,calloc)(VALUE klass, VALUE nn1, VALUE nn2) { GSL_TYPE(gsl_matrix) *m = NULL; CHECK_FIXNUM(nn1); CHECK_FIXNUM(nn2); m = FUNCTION(gsl_matrix,calloc)(FIX2INT(nn1), FIX2INT(nn2)); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_calloc failed"); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_matrix,diagonal_singleton)(int argc, VALUE *argv, VALUE klass) { GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; VALUE ary, tmp; size_t len, i; switch (argc) { case 1: switch (TYPE(argv[0])) { case T_FIXNUM: case T_FLOAT: len = FIX2INT(argv[0]); m = FUNCTION(gsl_matrix,alloc)(len, len); for (i = 0; i < len; i++) FUNCTION(gsl_matrix,set)(m, i, i, 1); return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); break; default: /* do next */ break; } if (rb_obj_is_kind_of(argv[0], rb_cRange)) ary = rb_gsl_range2ary(argv[0]); else ary = argv[0]; switch (TYPE(ary)) { case T_ARRAY: len = RARRAY_LEN(ary); m = FUNCTION(gsl_matrix,calloc)(len, len); for (i = 0; i < len; i++) { tmp = rb_ary_entry(ary, i); FUNCTION(gsl_matrix,set)(m, i, i, NUMCONV2(tmp)); } break; default: CHECK_VEC(ary); Data_Get_Struct(ary, GSL_TYPE(gsl_vector), v); len = v->size; m = FUNCTION(gsl_matrix,calloc)(len, len); for (i = 0; i < len; i++) { FUNCTION(gsl_matrix,set)(m, i, i, FUNCTION(gsl_vector,get)(v, i)); } break; } break; default: m = FUNCTION(gsl_matrix,calloc)(argc, argc); for (i = 0; i < argc; i++) { FUNCTION(gsl_matrix,set)(m, i, i, NUMCONV2(argv[i])); } break; } return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_matrix,eye)(int argc, VALUE *argv, VALUE klass) { GSL_TYPE(gsl_matrix) *m = NULL; size_t n1, n2, n, i; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); n1 = n2 = n; break; case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); n1 = FIX2INT(argv[0]); n2 = FIX2INT(argv[1]); n = GSL_MIN_INT(n1, n2); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } m = FUNCTION(gsl_matrix,calloc)(n1, n2); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_calloc failed"); for (i = 0; i < n; i++) { FUNCTION(gsl_matrix,set)(m, i, i, 1); } return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_matrix,ones)(int argc, VALUE *argv, VALUE klass) { GSL_TYPE(gsl_matrix) *m = NULL; size_t n1, n2, n, i, j; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); n1 = n2 = n; break; case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); n1 = FIX2INT(argv[0]); n2 = FIX2INT(argv[1]); n = GSL_MIN_INT(n1, n2); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } m = FUNCTION(gsl_matrix,calloc)(n1, n2); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_calloc failed"); for (i = 0; i < n1; i++) { for (j = 0; j < n2; j++) { FUNCTION(gsl_matrix,set)(m, i, j, (BASE) 1); } } return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_matrix,zeros)(int argc, VALUE *argv, VALUE klass) { GSL_TYPE(gsl_matrix) *m = NULL; size_t n1, n2, n, i, j; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); n1 = n2 = n; break; case 2: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); n1 = FIX2INT(argv[0]); n2 = FIX2INT(argv[1]); n = GSL_MIN_INT(n1, n2); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } m = FUNCTION(gsl_matrix,calloc)(n1, n2); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_calloc failed"); for (i = 0; i < n1; i++) { for (j = 0; j < n2; j++) { FUNCTION(gsl_matrix,set)(m, i, j, (BASE) 0); } } return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_matrix,identity)(VALUE klass, VALUE nn) { GSL_TYPE(gsl_matrix) *m = NULL; size_t n, i; CHECK_FIXNUM(nn); n = FIX2INT(nn); m = FUNCTION(gsl_matrix,calloc)(n, n); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_calloc failed"); for (i = 0; i < n; i++) { FUNCTION(gsl_matrix,set)(m, i, i, 1); } return Data_Wrap_Struct(klass, 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_matrix,size1)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return INT2FIX(m->size1); } static VALUE FUNCTION(rb_gsl_matrix,size2)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return INT2FIX(m->size2); } static VALUE FUNCTION(rb_gsl_matrix,shape)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return rb_ary_new3(2, INT2FIX(m->size1), INT2FIX(m->size2)); } static VALUE FUNCTION(rb_gsl_matrix,submatrix)(int argc, VALUE *argv, VALUE obj); static VALUE FUNCTION(rb_gsl_matrix,get)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; VALUE retval; int ii, ij; if(argc == 2 && TYPE(argv[0]) == T_FIXNUM && TYPE(argv[1]) == T_FIXNUM) { // m[i,j] Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); ii = FIX2INT(argv[0]); ij = FIX2INT(argv[1]); if(ii < 0) ii += m->size1; if(ij < 0) ij += m->size2; retval = C_TO_VALUE2(FUNCTION(gsl_matrix,get)(m, (size_t)ii, (size_t)ij)); } else if(argc == 1 && TYPE(argv[0]) == T_FIXNUM) { // m[i] Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); ii = FIX2INT(argv[0]); if(ii < 0) ii += m->size1 * m->size2; retval = C_TO_VALUE2(FUNCTION(gsl_matrix,get)(m, (size_t)(ii / m->size2), (size_t)(ii % m->size2))); } else if(argc == 1 && TYPE(argv[0]) == T_ARRAY) { // m[[i,j]], to support m[m.max_index] if(RARRAY_LEN(argv[0]) == 2) { Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); ii = FIX2INT(RARRAY_PTR(argv[0])[0]); ij = FIX2INT(RARRAY_PTR(argv[0])[1]); if(ii < 0) ii += m->size1; if(ij < 0) ij += m->size2; retval = C_TO_VALUE2(FUNCTION(gsl_matrix,get)(m, (size_t)ii, (size_t)ij)); } else { rb_raise(rb_eArgError, "Array index must have length 2, not %d", (int) RARRAY_LEN(argv[0])); } } else { retval = FUNCTION(rb_gsl_matrix,submatrix)(argc, argv, obj); } return retval; } void FUNCTION(rb_gsl_vector,set_subvector)(int argc, VALUE *argv, GSL_TYPE(gsl_vector) *v, VALUE other); static VALUE FUNCTION(rb_gsl_matrix,set)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mother; QUALIFIED_VIEW(gsl_matrix,view) mv; QUALIFIED_VIEW(gsl_vector,view) vv; VALUE other, row, row_set_argv[2]; int ii, ij, step; size_t i, j, k, n1, n2, nother; BASE beg, end; if(argc < 1 || argc > 5) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-5)", argc); } Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); other = argv[argc-1]; if(argc == 1 && TYPE(argv[0]) == T_ARRAY) { // m.set([row0,row1,...]) n1 = RARRAY_LEN(argv[0]); if(n1 > m->size1) n1 = m->size1; row_set_argv[0] = INT2FIX(0); // Each given row must have as manay elements as m has columns. // The bounds check happens inside rb_gsl_vector*set_subvector(). row_set_argv[1] = INT2FIX(m->size2); for(k = 0; k < n1 && k < m->size1; k++) { vv = FUNCTION(gsl_matrix,row)(m, k); FUNCTION(rb_gsl_vector,set_subvector)(2, row_set_argv, &vv.vector, rb_ary_entry(argv[0], k)); } } else if(argc == 1) { // m[] = x FUNCTION(gsl_matrix,set_all)(m, NUMCONV2(other)); } else if(argc==2 && TYPE(argv[0]) == T_ARRAY && TYPE(argv[1]) != T_ARRAY) { // m.set([i, j], x) or m[[i,j]] = x ii = FIX2INT(rb_ary_entry(argv[0], 0)); ij = FIX2INT(rb_ary_entry(argv[0], 1)); if(ii < 0) ii += m->size1; if(ij < 0) ij += m->size2; FUNCTION(gsl_matrix,set)(m, (size_t)ii, (size_t)ij, NUMCONV2(argv[1])); } else if(argc == 3 && TYPE(argv[0]) == T_FIXNUM && TYPE(argv[1]) == T_FIXNUM) { // m[i,j] = x ii = FIX2INT(argv[0]); ij = FIX2INT(argv[1]); if(ii < 0) ii += m->size1; if(ij < 0) ij += m->size2; FUNCTION(gsl_matrix,set)(m, (size_t)ii, (size_t)ij, NUMCONV2(other)); } else if(TYPE(argv[0]) == T_ARRAY) { // m.set(row0,row1,...) n1 = argc; if(n1 > m->size1) n1 = m->size1; row_set_argv[0] = INT2FIX(0); row_set_argv[1] = INT2FIX(m->size2); for(k = 0; k < n1 && k < m->size1; k++) { vv = FUNCTION(gsl_matrix,row)(m, k); FUNCTION(rb_gsl_vector,set_subvector)(2, row_set_argv, &vv.vector, argv[k]); } } else { // x -> assignment to m.submatrix(i...) parse_submatrix_args(argc-1, argv, m->size1, m->size2, &i, &j, &n1, &n2); if(n1 == 0) n1 = 1; if(n2 == 0) n2 = 1; mv = FUNCTION(gsl_matrix,submatrix)(m, i, j, n1, n2); if(rb_obj_is_kind_of(other, GSL_TYPE(cgsl_matrix))) { // m[...] = m_other Data_Get_Struct(other, GSL_TYPE(gsl_matrix), mother); if(n1 * n2 != mother->size1 * mother->size2) { rb_raise(rb_eRangeError, "sizes do not match (%d x %d != %d x %d)", (int) n1, (int) n2, (int) mother->size1, (int) mother->size2); } // TODO Change to gsl_matrix_memmove if/when GSL has such a function // because gsl_matrix_memcpy does not handle overlapping regions (e.g. // Views) well. FUNCTION(gsl_matrix,memcpy)(&mv.matrix, mother); } else if(rb_obj_is_kind_of(other, rb_cArray)) { row_set_argv[0] = INT2FIX(0); row_set_argv[1] = INT2FIX(n2); if(n1 == 1) { // m[...] = [col0, ...] # single row vv = FUNCTION(gsl_matrix,row)(&mv.matrix, 0); FUNCTION(rb_gsl_vector,set_subvector)(2, row_set_argv, &vv.vector, other); } else { // m[...] = [[row0], [row1], ...] # multiple rows if(n1 != RARRAY_LEN(other)) { rb_raise(rb_eRangeError, "row counts do not match (%d != %d)", (int) n1, (int) RARRAY_LEN(other)); } for(k = 0; k < n1; k++) { vv = FUNCTION(gsl_matrix,row)(&mv.matrix, k); row = rb_ary_entry(other, k); FUNCTION(rb_gsl_vector,set_subvector)(2, row_set_argv, &vv.vector, row); } } } else if(rb_obj_is_kind_of(other, rb_cRange)) { // m[...] = beg..end FUNCTION(get_range,beg_en_n)(other, &beg, &end, ¬her, &step); if(n1 * n2 != nother) { rb_raise(rb_eRangeError, "sizes do not match (%d x %d != %d)", (int) n1, (int) n2, (int) nother); } for(k = 0; k < nother; k++) { FUNCTION(gsl_matrix,set)(&mv.matrix, k / n2, k % n2, beg); beg += step; } } else { // m[...] = x FUNCTION(gsl_matrix,set_all)(&mv.matrix, NUMCONV2(other)); } } return obj; } static VALUE FUNCTION(rb_gsl_matrix,set_all)(VALUE obj, VALUE x) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,set_all)(m, NUMCONV2(x)); return obj; } static VALUE FUNCTION(rb_gsl_matrix,set_zero)(VALUE obj) { return FUNCTION(rb_gsl_matrix,do_something)(obj, FUNCTION(gsl_matrix,set_zero)); } static VALUE FUNCTION(rb_gsl_matrix,set_identity)(VALUE obj) { return FUNCTION(rb_gsl_matrix,do_something)(obj, FUNCTION(gsl_matrix,set_identity)); } static VALUE FUNCTION(rb_gsl_matrix,print)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); printf("[ "); for (i = 0; i < m->size1; i++) { if (i != 0) printf(" "); for (j = 0; j < m->size2; j++) { printf(PRINTF_FORMAT, FUNCTION(gsl_matrix,get)(m, i, j)); } if (i == m->size1 - 1) printf("]\n"); else printf("\n"); } return Qnil; } #ifdef BASE_DOUBLE #define SHOW_ELM 6 #else #define SHOW_ELM 12 #endif static VALUE FUNCTION(rb_gsl_matrix,to_s)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; char buf[32], format[32], format2[32]; size_t i, j; VALUE str; BASE x; int dig = 8; #ifdef BASE_INT BASE min; BASE max; #endif Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); #ifdef BASE_INT min = FUNCTION(gsl_matrix,min)(m); max = gsl_matrix_int_max(m); dig = (int) GSL_MAX(fabs(max),fabs(min)); if (dig > 0) dig = ceil(log10(dig+1e-10)); else dig = 1; if (min < 0) dig += 1; sprintf(format, "%%%dd ", (int) dig); strcpy(format2, format); #else strcpy(format, PRINTF_FORMAT); strcpy(format2, " "PRINTF_FORMAT); #endif str = rb_str_new2("[ "); for (i = 0; i < m->size1; i++) { if (i != 0) { strcpy(buf, " "); rb_str_cat(str, buf, strlen(buf)); } for (j = 0; j < m->size2; j++) { x = FUNCTION(gsl_matrix,get)(m, i, j); if (x < 0) sprintf(buf, format, x); else sprintf(buf, format2, x); rb_str_cat(str, buf, strlen(buf)); if (j >= (55/dig)) { strcpy(buf, "... "); rb_str_cat(str, buf, strlen(buf)); break; } } if (i >= 20) { strcpy(buf, "\n ... ]"); rb_str_cat(str, buf, strlen(buf)); break; } if (i == m->size1 - 1) { strcpy(buf, "]"); rb_str_cat(str, buf, strlen(buf)); } else { strcpy(buf, "\n"); rb_str_cat(str, buf, strlen(buf)); } } return str; } #undef SHOW_ELM static VALUE FUNCTION(rb_gsl_matrix,inspect)(VALUE obj) { VALUE str; char buf[64]; sprintf(buf, "%s\n", rb_class2name(CLASS_OF(obj))); str = rb_str_new2(buf); return rb_str_concat(str, FUNCTION(rb_gsl_matrix,to_s)(obj)); } #ifdef BASE_DOUBLE #define PRINTF_FORMAT2 "%g" #elif defined(BASE_INT) #define PRINTF_FORMAT2 "%d" #endif static VALUE FUNCTION(rb_gsl_matrix,fprintf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *h = NULL; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 2) { Check_Type(argv[1], T_STRING); status = FUNCTION(gsl_matrix,fprintf)(fp, h, STR2CSTR(argv[1])); } else { status = FUNCTION(gsl_matrix,fprintf)(fp, h, PRINTF_FORMAT2); } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_matrix,printf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *h = NULL; int status; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), h); if (argc == 1) { Check_Type(argv[0], T_STRING); status = FUNCTION(gsl_matrix,fprintf)(stdout, h, STR2CSTR(argv[0])); } else { status = FUNCTION(gsl_matrix,fprintf)(stdout, h, PRINTF_FORMAT2); } return INT2FIX(status); } #undef PRINTF_FORMAT2 static VALUE FUNCTION(rb_gsl_matrix,fscanf)(VALUE obj, VALUE io) { GSL_TYPE(gsl_matrix) *h = NULL; FILE *fp = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), h); fp = rb_gsl_open_readfile(io, &flag); status = FUNCTION(gsl_matrix,fscanf)(fp, h); if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_matrix,set_diagonal)(VALUE obj, VALUE diag) { GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v; size_t i, len; BASE x; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); switch (TYPE(diag)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: x = (BASE) NUMCONV2(diag); for (i = 0; i < m->size1; i++) FUNCTION(gsl_matrix,set)(m, i, i, x); break; case T_ARRAY: len = GSL_MIN_INT(m->size1, RARRAY_LEN(diag)); for (i = 0; i < len; i++) { FUNCTION(gsl_matrix,set)(m, i, i, NUMCONV2(rb_ary_entry(diag, i))); } break; default: if (VEC_P(diag)) { Data_Get_Struct(diag, GSL_TYPE(gsl_vector), v); len = GSL_MIN_INT(m->size1, v->size); for (i = 0; i < len; i++) { FUNCTION(gsl_matrix,set)(m, i, i, FUNCTION(gsl_vector,get)(v, i)); } } else { rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector or Array expected)", rb_class2name(CLASS_OF(diag))); } break; } return obj; } static VALUE FUNCTION(rb_gsl_matrix,get_row)(VALUE obj, VALUE i) { GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); v = FUNCTION(gsl_vector,alloc)(m->size1); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); FUNCTION(gsl_matrix,get_row)(v, m, FIX2INT(i)); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), v); } static VALUE FUNCTION(rb_gsl_matrix,get_col)(VALUE obj, VALUE i) { GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); v = FUNCTION(gsl_vector,alloc)(m->size2); if (v == NULL) rb_raise(rb_eNoMemError, "gsl_vector_alloc failed"); FUNCTION(gsl_matrix,get_col)(v, m, FIX2INT(i)); // TODO This is NOT returning a view! Is there a macro more appropriate than // QUALIFIED_VIEW? return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,col), 0, FUNCTION(gsl_vector,free), v); } static VALUE FUNCTION(rb_gsl_matrix,set_row)(VALUE obj, VALUE i, VALUE vv) { GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; int flag = 0; size_t j; CHECK_FIXNUM(i); if (CLASS_OF(vv) == rb_cRange) vv = rb_gsl_range2ary(vv); if (TYPE(vv) == T_ARRAY) { v = FUNCTION(gsl_vector,alloc)(RARRAY_LEN(vv)); for (j = 0; j < RARRAY_LEN(vv); j++) { FUNCTION(gsl_vector,set)(v, j, NUMCONV2(rb_ary_entry(vv, j))); } flag = 1; } else { CHECK_VEC(vv); Data_Get_Struct(vv, GSL_TYPE(gsl_vector), v); } Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,set_row)(m, FIX2INT(i), v); if (flag == 1) FUNCTION(gsl_vector,free)(v); return obj; } static VALUE FUNCTION(rb_gsl_matrix,set_col)(VALUE obj, VALUE j, VALUE vv) { GSL_TYPE(gsl_matrix) *m = NULL; GSL_TYPE(gsl_vector) *v = NULL; int flag = 0; size_t i; CHECK_FIXNUM(j); if (CLASS_OF(vv) == rb_cRange) vv = rb_gsl_range2ary(vv); if (TYPE(vv) == T_ARRAY) { v = FUNCTION(gsl_vector,alloc)(RARRAY_LEN(vv)); for (i = 0; i < RARRAY_LEN(vv); i++) { FUNCTION(gsl_vector,set)(v, i, NUMCONV2(rb_ary_entry(vv, i))); } flag = 1; } else { CHECK_VECTOR(vv); Data_Get_Struct(vv, GSL_TYPE(gsl_vector), v); } Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,set_col)(m, FIX2INT(j), v); if (flag == 1) FUNCTION(gsl_vector,free)(v); return obj; } static VALUE FUNCTION(rb_gsl_matrix,clone)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(gsl_matrix,memcpy)(mnew, m); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,memcpy)(VALUE obj, VALUE mm1, VALUE mm2) { GSL_TYPE(gsl_matrix) *m1 = NULL, *m2 = NULL; CHECK_MAT(mm1); CHECK_MAT(mm2); Data_Get_Struct(mm1, GSL_TYPE(gsl_matrix), m1); Data_Get_Struct(mm2, GSL_TYPE(gsl_matrix), m2); FUNCTION(gsl_matrix,memcpy)(m1, m2); return mm1; } static VALUE FUNCTION(rb_gsl_matrix,isnull)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return INT2FIX(FUNCTION(gsl_matrix,isnull)(m)); } static VALUE FUNCTION(rb_gsl_matrix,isnull2)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); if (FUNCTION(gsl_matrix,isnull)(m)) return Qtrue; else return Qfalse; } /* singleton */ static VALUE FUNCTION(rb_gsl_matrix,swap)(VALUE obj, VALUE mm1, VALUE mm2) { GSL_TYPE(gsl_matrix) *m1 = NULL, *m2 = NULL; CHECK_MAT(mm1); CHECK_MAT(mm2); Data_Get_Struct(mm1, GSL_TYPE(gsl_matrix), m1); Data_Get_Struct(mm2, GSL_TYPE(gsl_matrix), m2); FUNCTION(gsl_matrix,swap)(m1, m2); return mm1; } static VALUE FUNCTION(rb_gsl_matrix,swap_rows_bang)(VALUE obj, VALUE i, VALUE j) { GSL_TYPE(gsl_matrix) *m = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,swap_rows)(m, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE FUNCTION(rb_gsl_matrix,swap_rows)(VALUE obj, VALUE i, VALUE j) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(make_matrix,clone)(m); FUNCTION(gsl_matrix,swap_rows)(mnew, FIX2INT(i), FIX2INT(j)); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,swap_columns_bang)(VALUE obj, VALUE i, VALUE j) { GSL_TYPE(gsl_matrix) *m = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,swap_columns)(m, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE FUNCTION(rb_gsl_matrix,swap_columns)(VALUE obj, VALUE i, VALUE j) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(make_matrix,clone)(m); FUNCTION(gsl_matrix,swap_columns)(mnew, FIX2INT(i), FIX2INT(j)); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,swap_rowcol_bang)(VALUE obj, VALUE i, VALUE j) { GSL_TYPE(gsl_matrix) *m = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,swap_rowcol)(m, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE FUNCTION(rb_gsl_matrix,swap_rowcol)(VALUE obj, VALUE i, VALUE j) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(make_matrix,clone)(m); FUNCTION(gsl_matrix,swap_rowcol)(mnew, FIX2INT(i), FIX2INT(j)); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,transpose_memcpy)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size2, m->size1); FUNCTION(gsl_matrix,transpose_memcpy)(mnew, m); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,transpose_bang)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,transpose)(m); return obj; } static VALUE FUNCTION(rb_gsl_matrix,max)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return C_TO_VALUE2(FUNCTION(gsl_matrix,max)(m)); } static VALUE FUNCTION(rb_gsl_matrix,min)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return C_TO_VALUE2(FUNCTION(gsl_matrix,min)(m)); } static VALUE FUNCTION(rb_gsl_matrix,minmax)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; BASE min, max; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,minmax)(m, &min, &max); return rb_ary_new3(2, C_TO_VALUE2(min), C_TO_VALUE2(max)); } static VALUE FUNCTION(rb_gsl_matrix,max_index)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; size_t imax, jmax; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,max_index)(m, &imax, &jmax); return rb_ary_new3(2, INT2FIX(imax), INT2FIX(jmax)); } static VALUE FUNCTION(rb_gsl_matrix,min_index)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; size_t imin, jmin; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,min_index)(m, &imin, &jmin); return rb_ary_new3(2, INT2FIX(imin), INT2FIX(jmin)); } static VALUE FUNCTION(rb_gsl_matrix,minmax_index)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; size_t imin, jmin, imax, jmax; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,minmax_index)(m, &imin, &jmin, &imax, &jmax); return rb_ary_new3(2, rb_ary_new3(2, INT2FIX(imin), INT2FIX(jmin)), rb_ary_new3(2, INT2FIX(imax), INT2FIX(jmax))); } static VALUE FUNCTION(rb_gsl_matrix,fwrite)(VALUE obj, VALUE io) { GSL_TYPE(gsl_matrix) *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), h); f = rb_gsl_open_writefile(io, &flag); status = FUNCTION(gsl_matrix,fwrite)(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_matrix,fread)(VALUE obj, VALUE io) { GSL_TYPE(gsl_matrix) *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), h); f = rb_gsl_open_readfile(io, &flag); status = FUNCTION(gsl_matrix,fread)(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE FUNCTION(rb_gsl_matrix,trace)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; size_t i; BASE trace = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); for (i = 0; i < m->size1; i++) { trace += FUNCTION(gsl_matrix,get)(m, i, i); } return C_TO_VALUE2(trace); } static VALUE FUNCTION(rb_gsl_matrix,uplus)(VALUE obj) { return obj; } static VALUE FUNCTION(rb_gsl_matrix,uminus)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew = NULL; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { FUNCTION(gsl_matrix,set)(mnew, i, j, -FUNCTION(gsl_matrix,get)(m, i, j)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } VALUE FUNCTION(rb_gsl_matrix,power)(VALUE obj, VALUE bb) { GSL_TYPE(gsl_matrix) *m = NULL, *mtmp = NULL, *mnew = NULL; size_t i, b; CHECK_FIXNUM(bb); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); b = FIX2INT(bb); mtmp = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(gsl_matrix,memcpy)(mnew, m); for (i = 1; i < b; i++) { FUNCTION(gsl_matrix,memcpy)(mtmp, mnew); #ifdef BASE_DOUBLE gsl_linalg_matmult(mtmp, m, mnew); #else gsl_linalg_matmult_int(mtmp, m, mnew); #endif } FUNCTION(gsl_matrix,free)(mtmp); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,submatrix)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_matrix,view) *mv = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; size_t i, j, n1, n2; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); parse_submatrix_args(argc, argv, m->size1, m->size2, &i, &j, &n1, &n2); if(n1 == 0) { vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,subrow)(m, i, j, n2); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, vv); } else if(n2 == 0) { vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,subcolumn)(m, j, i, n1); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,col_view), 0, free, vv); } else { mv = ALLOC(QUALIFIED_VIEW(gsl_matrix,view)); *mv = FUNCTION(gsl_matrix,submatrix)(m, i, j, n1, n2); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_matrix,view), 0, free, mv); } } static VALUE FUNCTION(rb_gsl_matrix,return_vector_view)(VALUE obj, VALUE index, QUALIFIED_VIEW(gsl_vector,view) (*f)(GSL_TYPE(gsl_matrix)*, size_t)) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; CHECK_FIXNUM(index); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = (*f)(m, FIX2INT(index)); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, vv); } static VALUE FUNCTION(rb_gsl_matrix,row)(VALUE obj, VALUE i) { return FUNCTION(rb_gsl_matrix,return_vector_view)(obj, i, FUNCTION(gsl_matrix,row)); } static VALUE FUNCTION(rb_gsl_matrix,column)(VALUE obj, VALUE j) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; CHECK_FIXNUM(j); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,column)(m, FIX2INT(j)); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,col_view), 0, free, vv); } #ifdef GSL_1_10_LATER static VALUE FUNCTION(rb_gsl_matrix,subrow)(VALUE obj, VALUE i, VALUE offset, VALUE n) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,subrow)(m, FIX2INT(i), FIX2INT(offset), FIX2INT(n)); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, vv); } static VALUE FUNCTION(rb_gsl_matrix,subcolumn)(VALUE obj, VALUE j, VALUE offset, VALUE n) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,subcolumn)(m, FIX2INT(j), FIX2INT(offset), FIX2INT(n)); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,col_view), 0, free, vv); } #endif static VALUE FUNCTION(rb_gsl_matrix,diagonal)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv = NULL; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,diagonal)(m); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, vv); } static VALUE FUNCTION(rb_gsl_matrix,subdiagonal)(VALUE obj, VALUE k) { return rb_gsl_matrix_return_vector_view(obj, k, gsl_matrix_subdiagonal); } static VALUE FUNCTION(rb_gsl_matrix,superdiagonal)(VALUE obj, VALUE k) { return rb_gsl_matrix_return_vector_view(obj, k, gsl_matrix_superdiagonal); } static VALUE FUNCTION(rb_gsl_matrix,vector_view)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); vv->vector.size = m->size1*m->size2; vv->vector.owner = 0; vv->vector.stride = 1; vv->vector.data = m->data; return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, vv); } static VALUE FUNCTION(rb_gsl_matrix,each_row)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); for (i = 0; i < m->size1; i++) { vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,row)(m, i); #ifdef BASE_DOUBLE rb_yield(Data_Wrap_Struct(cgsl_vector_view, 0, free, vv)); #else rb_yield(Data_Wrap_Struct(cgsl_vector_int_view, 0, free, vv)); #endif } return obj; } static VALUE FUNCTION(rb_gsl_matrix,each_col)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; QUALIFIED_VIEW(gsl_vector,view) *vv; size_t i; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); for (i = 0; i < m->size2; i++) { vv = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); *vv = FUNCTION(gsl_matrix,column)(m, i); #ifdef BASE_DOUBLE rb_yield(Data_Wrap_Struct(cgsl_vector_col_view, 0, free, vv)); #else rb_yield(Data_Wrap_Struct(cgsl_vector_int_col_view, 0, free, vv)); #endif } return obj; } static VALUE FUNCTION(rb_gsl_matrix,scale_bang)(VALUE obj, VALUE x) { GSL_TYPE(gsl_matrix) *m; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,scale)(m, NUMCONV(x)); return obj; } static VALUE FUNCTION(rb_gsl_matrix,scale)(VALUE obj, VALUE b) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(make_matrix,clone)(m); FUNCTION(gsl_matrix,scale)(mnew, NUMCONV(b)); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,add_constant_bang)(VALUE obj, VALUE x) { GSL_TYPE(gsl_matrix) *m; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(gsl_matrix,add_constant)(m, NUMCONV(x)); return obj; } static VALUE FUNCTION(rb_gsl_matrix,add_constant)(VALUE obj, VALUE b) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(make_matrix,clone)(m); FUNCTION(gsl_matrix,add_constant)(mnew, NUMCONV(b)); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static int FUNCTION(mygsl_matrix,equal)(GSL_TYPE(gsl_matrix) *a, GSL_TYPE(gsl_matrix) *b, double eps) { size_t i, j; BASE x, y; if (a->size1 != b->size1 || a->size2 != b->size2) return 0; for (i = 0; i < a->size1; i++) { for (j = 0; j < a->size2; j++) { x = FUNCTION(gsl_matrix,get)(a, i, j); y = FUNCTION(gsl_matrix,get)(b, i, j); if (fabs(x-y) > eps) return 0; } } return 1; } #ifdef HAVE_TENSOR_TENSOR_H EXTERN VALUE cgsl_tensor, cgsl_tensor_int; VALUE rb_gsl_tensor_equal(int argc, VALUE *argv, VALUE obj); VALUE rb_gsl_tensor_int_equal(int argc, VALUE *argv, VALUE obj); #ifdef BASE_DOUBLE #define TEN_P(x) TENSOR_P(x) #else #define TEN_P(x) TENSOR_INT_P(x) #endif #endif static VALUE FUNCTION(rb_gsl_matrix,equal)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *a, *b; double eps = 1e-10; VALUE bb; switch (argc) { case 2: bb = argv[0]; eps = NUM2DBL(argv[1]); break; case 1: bb = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } #ifdef HAVE_TENSOR_TENSOR_H if (TEN_P(bb)) { return FUNCTION(rb_gsl_tensor,equal)(argc, argv, obj); } #endif CHECK_MAT(bb); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), a); Data_Get_Struct(bb, GSL_TYPE(gsl_matrix), b); if (FUNCTION(mygsl_matrix,equal)(a, b, eps) == 1) return Qtrue; else return Qfalse; } #ifdef HAVE_TENSOR_TENSOR_H #ifdef TEN_P #undef TEN_P #endif #endif static VALUE FUNCTION(rb_gsl_matrix,equal_singleton)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *a, *b; VALUE aa, bb; double eps = 1e-10; BASE x, y; size_t i, j; switch (argc) { case 3: aa = argv[0]; bb = argv[1]; eps = NUM2DBL(argv[2]); break; case 2: aa = argv[0]; bb = argv[1]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } CHECK_MAT(aa); CHECK_MAT(bb); Data_Get_Struct(aa, GSL_TYPE(gsl_matrix), a); Data_Get_Struct(bb, GSL_TYPE(gsl_matrix), b); if (a->size1 != b->size1 || a->size2 != b->size2) return Qfalse; for (i = 0; i < a->size1; i++) { for (j = 0; j < a->size2; j++) { x = FUNCTION(gsl_matrix,get)(a, i, j); y = FUNCTION(gsl_matrix,get)(b, i, j); if (fabs(x-y) > eps) return Qfalse; } } return Qtrue; } #ifdef HAVE_TENSOR_TENSOR_H #include "rb_gsl_tensor.h" static VALUE FUNCTION(rb_gsl_matrix,to_tensor)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; GSL_TYPE(rbgsl_tensor) *t; unsigned int rank; size_t dim; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); if (m->size1 != m->size2) rb_raise(rb_eRuntimeError, "matrix must have equal dimensions"); rank = 2; dim = m->size1; t = FUNCTION(rbgsl_tensor,alloc)(rank, dim); memcpy(t->tensor->data, m->data, sizeof(BASE)*t->tensor->size); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), t); } #endif static VALUE FUNCTION(rb_gsl_matrix,collect)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { FUNCTION(gsl_matrix,set)(mnew, i, j, NUMCONV(rb_yield(C_TO_VALUE(FUNCTION(gsl_matrix,get)(m, i, j))))); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,collect_bang)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { FUNCTION(gsl_matrix,set)(m, i, j, NUMCONV(rb_yield(C_TO_VALUE(FUNCTION(gsl_matrix,get)(m, i, j))))); } } return obj; } static VALUE FUNCTION(rb_gsl_matrix,upper)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(make_matrix,clone)(m); for (i = 0; i < m->size1; i++) { for (j = 0; j < i; j++) { FUNCTION(gsl_matrix,set)(mnew, i, j, 0); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,lower)(VALUE obj) { GSL_TYPE(gsl_matrix) *m = NULL, *mnew; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(make_matrix,clone)(m); for (i = 0; i < m->size1; i++) { for (j = i+1; j < m->size2; j++) { FUNCTION(gsl_matrix,set)(mnew, i, j, 0); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } /* singleton method, creates Pascal matrix of dimension n */ static VALUE FUNCTION(rb_gsl_matrix,pascal1)(VALUE obj, VALUE n) { GSL_TYPE(gsl_matrix) *m; BASE x; size_t i, j, dim; CHECK_FIXNUM(n); dim = (size_t) FIX2INT(n); m = FUNCTION(gsl_matrix,alloc)(dim, dim); for (j = 0; j < dim; j++) FUNCTION(gsl_matrix,set)(m, 0, j, (BASE) 1); for (i = 1; i < dim; i++) { FUNCTION(gsl_matrix,set)(m, i, 0, (BASE) 1); for (j = 1; j < dim; j++) { x=FUNCTION(gsl_matrix,get)(m,i-1,j)+FUNCTION(gsl_matrix,get)(m,i,j-1); FUNCTION(gsl_matrix,set)(m, i, j, x); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } #ifdef BASE_DOUBLE static VALUE FUNCTION(rb_gsl_matrix,hilbert)(VALUE obj, VALUE n) { GSL_TYPE(gsl_matrix) *m; double x; size_t i, j, dim; CHECK_FIXNUM(n); dim = (size_t) FIX2INT(n); m = FUNCTION(gsl_matrix,alloc)(dim, dim); for (i = 0; i < dim; i++) { for (j = 0; j < dim; j++) { x = 1.0/(i + j + 1); FUNCTION(gsl_matrix,set)(m, i, j, (BASE) x); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } double mygsl_binomial_coef(unsigned int n, unsigned int k); static VALUE FUNCTION(rb_gsl_matrix,invhilbert)(VALUE obj, VALUE n) { GSL_TYPE(gsl_matrix) *m; double x, y; size_t i, j, dim; CHECK_FIXNUM(n); dim = (size_t) FIX2INT(n); m = FUNCTION(gsl_matrix,alloc)(dim, dim); for (i = 0; i < dim; i++) { for (j = 0; j < dim; j++) { if ((i+j)%2 == 0) x = 1; else x = -1; x *= (i + j + 1); x *= mygsl_binomial_coef(dim + i, dim - j - 1); x *= mygsl_binomial_coef(dim + j, dim - i - 1); y = mygsl_binomial_coef(i + j, i); x *= y*y; FUNCTION(gsl_matrix,set)(m, i, j, (BASE) x); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } #endif static void FUNCTION(mygsl_matrix,vandermonde)(GSL_TYPE(gsl_matrix) *m, GSL_TYPE(gsl_vector) *v) { size_t i, j; for (i = 0; i < v->size; i++) { for (j = 0; j < v->size; j++) { FUNCTION(gsl_matrix,set)(m, i, j, (BASE) gsl_pow_int(FUNCTION(gsl_vector,get)(v, i), v->size-j-1)); } } } /* singleton */ static VALUE FUNCTION(rb_gsl_matrix,vandermonde)(VALUE obj, VALUE vv) { GSL_TYPE(gsl_vector) *v; GSL_TYPE(gsl_matrix) *m; int flag = 0; if (TYPE(vv) == T_ARRAY) { v = FUNCTION(make_cvector,from_rarray)(vv); flag = 1; } else if (VEC_P(vv)) { Data_Get_Struct(vv, GSL_TYPE(gsl_vector), v); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector expected)", rb_class2name(CLASS_OF(vv))); } m = FUNCTION(gsl_matrix,alloc)(v->size, v->size); FUNCTION(mygsl_matrix,vandermonde)(m, v); if (flag == 1) FUNCTION(gsl_vector,free)(v); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } static void FUNCTION(mygsl_matrix,toeplitz)(GSL_TYPE(gsl_matrix) *m, GSL_TYPE(gsl_vector) *v) { size_t i, j; for (i = 0; i < v->size; i++) { for (j = 0; j < v->size; j++) { if (j >= i) FUNCTION(gsl_matrix,set)(m, i, j, FUNCTION(gsl_vector,get)(v, j-i)); else FUNCTION(gsl_matrix,set)(m, i, j, FUNCTION(gsl_vector,get)(v, i-j)); } } } static VALUE FUNCTION(rb_gsl_matrix,toeplitz)(VALUE obj, VALUE vv) { GSL_TYPE(gsl_vector) *v; GSL_TYPE(gsl_matrix) *m; int flag = 0; if (TYPE(vv) == T_ARRAY) { v = FUNCTION(make_cvector,from_rarray)(vv); flag = 1; } else if (VEC_P(vv)) { Data_Get_Struct(vv, GSL_TYPE(gsl_vector), v); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector expected)", rb_class2name(CLASS_OF(vv))); } m = FUNCTION(gsl_matrix,alloc)(v->size, v->size); FUNCTION(mygsl_matrix,toeplitz)(m, v); if (flag == 1) FUNCTION(gsl_vector,free)(v); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } void FUNCTION(mygsl_vector,to_m_circulant)(GSL_TYPE(gsl_matrix) *m, GSL_TYPE(gsl_vector) *v); static VALUE FUNCTION(rb_gsl_matrix,circulant)(VALUE obj, VALUE vv) { GSL_TYPE(gsl_vector) *v; GSL_TYPE(gsl_matrix) *m; int flag = 0; if (TYPE(vv) == T_ARRAY) { v = FUNCTION(make_cvector,from_rarray)(vv); flag = 1; } else if (VEC_P(vv)) { Data_Get_Struct(vv, GSL_TYPE(gsl_vector), v); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector expected)", rb_class2name(CLASS_OF(vv))); } m = FUNCTION(gsl_matrix,alloc)(v->size, v->size); FUNCTION(mygsl_vector,to_m_circulant)(m, v); if (flag == 1) FUNCTION(gsl_vector,free)(v); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } static void FUNCTION(mygsl_matrix,indgen)(GSL_TYPE(gsl_matrix) *m, BASE start, BASE step) { size_t i, j; BASE n; n = start; for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { FUNCTION(gsl_matrix,set)(m, i, j, n); n += step; } } } static VALUE FUNCTION(rb_gsl_matrix,indgen_singleton)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m; size_t n1, n2; BASE start = 0, step = 1; switch (argc) { case 4: step = NUMCONV2(argv[3]); /* no break */ case 3: start = NUMCONV2(argv[2]); /* no break */ case 2: n1 = NUM2INT(argv[0]); n2 = NUM2INT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2-4)", argc); break; } m = FUNCTION(gsl_matrix,alloc)(n1, n2); FUNCTION(mygsl_matrix,indgen)(m, start, step); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_gsl_matrix,indgen)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; BASE start = 0, step = 1; switch (argc) { case 2: step = NUMCONV2(argv[1]); /* no break */ case 1: start = NUMCONV2(argv[0]); break; case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(mygsl_matrix,indgen)(mnew, start, step); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,indgen_bang)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m; BASE start = 0, step = 1; switch (argc) { case 2: step = NUMCONV2(argv[1]); /* no break */ case 1: start = NUMCONV2(argv[0]); break; case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0-2)", argc); break; } Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); FUNCTION(mygsl_matrix,indgen)(m, start, step); return obj; } static VALUE FUNCTION(rb_gsl_matrix,to_a)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; VALUE ma, ra; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); ma = rb_ary_new2(m->size1); for(i=0; i < m->size1; i++) { ra = rb_ary_new2(m->size2); rb_ary_store(ma, i, ra); for(j=0; j < m->size2; j++) { rb_ary_store(ra, j, C_TO_VALUE(FUNCTION(gsl_matrix,get)(m, i, j))); } } return ma; } static VALUE FUNCTION(rb_gsl_matrix,to_v)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; GSL_TYPE(gsl_vector) *v; size_t i, j, k; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); v = FUNCTION(gsl_vector,alloc)(m->size1*m->size2); // memcpy(v->data, m->data, sizeof(BASE)*v->size); for (i = 0, k = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++, k++) { FUNCTION(gsl_vector,set)(v, k, FUNCTION(gsl_matrix,get)(m, i, j)); } } if(m->size1 > 1 && m->size2 == 1) { return Data_Wrap_Struct(CONCAT2(GSL_TYPE(cgsl_vector),col), 0, FUNCTION(gsl_vector,free), v); } else { return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), v); } } static VALUE FUNCTION(rb_gsl_matrix,to_vview)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; QUALIFIED_VIEW(gsl_vector,view) *v; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); v = ALLOC(QUALIFIED_VIEW(gsl_vector,view)); v->vector.size = m->size1*m->size2; v->vector.stride = 1; v->vector.owner = 0; v->vector.data = m->data; return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, FUNCTION(gsl_vector,free), v); } static VALUE FUNCTION(rb_gsl_matrix,norm)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; size_t i, n; BASE x = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); n = m->size1*m->size2; for (i = 0; i < n; i++) x += m->data[i]*m->data[i]; return rb_float_new(sqrt(x)); } static int FUNCTION(mygsl_matrix,reverse_columns)(GSL_TYPE(gsl_matrix) *dst, GSL_TYPE(gsl_matrix) *src) { size_t j; QUALIFIED_VIEW(gsl_vector,view) col; if (dst->size1 != src->size1 || dst->size2 != src->size2) rb_raise(rb_eRuntimeError, "matrix sizes are different."); for (j = 0; j < src->size2; j++) { col = FUNCTION(gsl_matrix,column)(src, j); FUNCTION(gsl_matrix,set_col)(dst, dst->size2-1-j, &col.vector); } return 0; } static int FUNCTION(mygsl_matrix,reverse_rows)(GSL_TYPE(gsl_matrix) *dst, GSL_TYPE(gsl_matrix) *src) { size_t i; QUALIFIED_VIEW(gsl_vector,view) row; if (dst->size1 != src->size1 || dst->size2 != src->size2) rb_raise(rb_eRuntimeError, "matrix sizes are different."); for (i = 0; i < src->size1; i++) { row = FUNCTION(gsl_matrix,row)(src, i); FUNCTION(gsl_matrix,set_row)(dst, dst->size1-1-i, &row.vector); } return 0; } static VALUE FUNCTION(rb_gsl_matrix,reverse_columns)(VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(mygsl_matrix,reverse_columns)(mnew, m); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,reverse_columns_bang)(VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(mygsl_matrix,reverse_columns)(mnew, m); FUNCTION(gsl_matrix,memcpy)(m, mnew); FUNCTION(gsl_matrix,free)(mnew); return obj; } static VALUE FUNCTION(rb_gsl_matrix,reverse_rows)(VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(mygsl_matrix,reverse_rows)(mnew, m); return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,reverse_rows_bang)(VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(mygsl_matrix,reverse_rows)(mnew, m); FUNCTION(gsl_matrix,memcpy)(m, mnew); FUNCTION(gsl_matrix,free)(mnew); return obj; } static VALUE FUNCTION(rb_gsl_matrix,block)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return Data_Wrap_Struct(GSL_TYPE(cgsl_block), 0, NULL, m->block); } static VALUE FUNCTION(rb_gsl_matrix,info)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; char buf[256]; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); sprintf(buf, "Class: %s\n", rb_class2name(CLASS_OF(obj))); #ifdef RUBY_1_9_LATER sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj)))); #else sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super)); #endif sprintf(buf, "%sDimension: %dx%d\n", buf, (int) m->size1, (int) m->size2); sprintf(buf, "%sSize: %d\n", buf, (int) (m->size1*m->size2)); return rb_str_new2(buf); } static VALUE FUNCTION(rb_gsl_matrix,any)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; QUALIFIED_VIEW(gsl_vector,view) vv; GSL_TYPE(gsl_vector) *v; gsl_vector_int *vnew; size_t j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vnew = gsl_vector_int_alloc(m->size2); for (j = 0; j < m->size2; j++) { vv = FUNCTION(gsl_matrix,column)(m, j); v = &vv.vector; if (FUNCTION(gsl_vector,isnull(v))) gsl_vector_int_set(vnew, j, 0); else gsl_vector_int_set(vnew, j, 1); } return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, vnew); } static VALUE FUNCTION(rb_gsl_matrix,all)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; QUALIFIED_VIEW(gsl_vector,view) vv; GSL_TYPE(gsl_vector) *v; gsl_vector_int *vnew; size_t i, j; int flag = 0; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); vnew = gsl_vector_int_alloc(m->size2); for (j = 0; j < m->size2; j++) { vv = FUNCTION(gsl_matrix,column)(m, j); v = &vv.vector; /* if (FUNCTION(gsl_vector,isnull(v))) gsl_vector_int_set(vnew, j, 0); else gsl_vector_int_set(vnew, j, 1);*/ for (i = 0; i < v->size; i++) { if (FUNCTION(gsl_vector,get)(v, i) == (BASE) 0) { gsl_vector_int_set(vnew, j, 0); flag = 0; break; } else { flag = 1; } } if (flag == 1) gsl_vector_int_set(vnew, j, 1); } return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, vnew); } static VALUE FUNCTION(rb_gsl_matrix,rot90)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew, *mtmp; int p; switch (argc) { case 0: p = 1; break; case 1: p = FIX2INT(argv[0])%4; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); switch (p) { case 0: mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); // FUNCTION(gsl_matrix,memcpy(mnew, m)); FUNCTION(gsl_matrix,memcpy)(mnew, m); break; case 1: case -3: mtmp = FUNCTION(gsl_matrix,alloc)(m->size2, m->size1); FUNCTION(gsl_matrix,transpose_memcpy(mtmp, m)); mnew = FUNCTION(gsl_matrix,alloc)(m->size2, m->size1); FUNCTION(mygsl_matrix,reverse_rows)(mnew, mtmp); FUNCTION(gsl_matrix,free)(mtmp); break; case 2: case -2: mtmp = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(mygsl_matrix,reverse_rows)(mtmp,m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); FUNCTION(mygsl_matrix,reverse_columns)(mnew, mtmp); FUNCTION(gsl_matrix,free)(mtmp); break; case 3: case -1: mtmp = FUNCTION(gsl_matrix,alloc)(m->size2, m->size1); FUNCTION(gsl_matrix,transpose_memcpy(mtmp, m)); mnew = FUNCTION(gsl_matrix,alloc)(m->size2, m->size1); FUNCTION(mygsl_matrix,reverse_columns)(mnew, mtmp); FUNCTION(gsl_matrix,free)(mtmp); break; default: return Qnil; break; } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } void FUNCTION(mygsl_vector,diff)(GSL_TYPE(gsl_vector) *vdst, GSL_TYPE(gsl_vector) *vsrc, size_t n); static VALUE FUNCTION(rb_gsl_matrix,diff)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; QUALIFIED_VIEW(gsl_vector,view) v1, v2; size_t n, j; switch (argc) { case 0: n = 1; break; case 1: n = FIX2INT(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 or 1)", argc); break; } if (n <= 0) return obj; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1-n, m->size2); if (m->size1 <= n) return obj; for (j = 0; j < m->size2; j++) { v1 = FUNCTION(gsl_matrix,column)(m, j); v2 = FUNCTION(gsl_matrix,column)(mnew, j); FUNCTION(mygsl_vector,diff)(&v2.vector, &v1.vector, n); } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,test)(VALUE obj, int (*f)(const double)) { GSL_TYPE(gsl_matrix) *m; gsl_matrix_int *mi; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mi = gsl_matrix_int_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_int_set(mi, i, j, (*f)(FUNCTION(gsl_matrix,get)(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix_int, 0, gsl_matrix_int_free, mi); } static VALUE FUNCTION(rb_gsl_matrix,isnan)(VALUE obj) { return FUNCTION(rb_gsl_matrix,test)(obj, gsl_isnan); } static VALUE FUNCTION(rb_gsl_matrix,isinf)(VALUE obj) { return FUNCTION(rb_gsl_matrix,test)(obj, gsl_isinf); } static VALUE FUNCTION(rb_gsl_matrix,finite)(VALUE obj) { return FUNCTION(rb_gsl_matrix,test)(obj, gsl_finite); } static VALUE FUNCTION(rb_gsl_matrix,sgn)(VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; BASE x; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { x = FUNCTION(gsl_matrix,get)(m, i, j); FUNCTION(gsl_matrix,set)(mnew, i, j, (BASE)(x>0 ? 1 : (x<0 ? -1 : 0))); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,abs)(VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { FUNCTION(gsl_matrix,set)(mnew, i, j, (BASE) fabs(FUNCTION(gsl_matrix,get)(m, i, j))); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,horzcat)(VALUE obj, VALUE mm2) { GSL_TYPE(gsl_matrix) *m, *m2, *mnew; QUALIFIED_VIEW(gsl_vector,view) v; size_t j, k; CHECK_MAT(mm2); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); Data_Get_Struct(mm2, GSL_TYPE(gsl_matrix), m2); if (m->size1 != m2->size1) rb_raise(rb_eRuntimeError, "Different number of rows (%d and %d).", (int) m->size1, (int) m2->size1); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2 + m2->size2); for (j = 0, k = 0; j < m->size2; j++, k++) { v = FUNCTION(gsl_matrix,column)(m, j); FUNCTION(gsl_matrix,set_col)(mnew, k, &v.vector); } for (j = 0; j < m2->size2; j++, k++) { v = FUNCTION(gsl_matrix,column)(m2, j); FUNCTION(gsl_matrix,set_col)(mnew, k, &v.vector); } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,horzcat_singleton)(VALUE klass, VALUE mm, VALUE mm2) { CHECK_MAT(mm); return FUNCTION(rb_gsl_matrix,horzcat)(mm, mm2); } static VALUE FUNCTION(rb_gsl_matrix,vertcat)(VALUE obj, VALUE mm2) { GSL_TYPE(gsl_matrix) *m, *m2, *mnew; QUALIFIED_VIEW(gsl_vector,view) v; size_t i, k; CHECK_MAT(mm2); Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); Data_Get_Struct(mm2, GSL_TYPE(gsl_matrix), m2); if (m->size2 != m2->size2) rb_raise(rb_eRuntimeError, "Different number of columns (%d and %d).", (int) m->size2, (int) m2->size2); mnew = FUNCTION(gsl_matrix,alloc)(m->size1 + m2->size1, m->size2); for (i = 0, k = 0; i < m->size1; i++, k++) { v = FUNCTION(gsl_matrix,row)(m, i); FUNCTION(gsl_matrix,set_row)(mnew, k, &v.vector); } for (i = 0; i < m2->size1; i++, k++) { v = FUNCTION(gsl_matrix,row)(m2, i); FUNCTION(gsl_matrix,set_row)(mnew, k, &v.vector); } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,vertcat_singleton)(VALUE klass, VALUE mm, VALUE mm2) { CHECK_MAT(mm); return FUNCTION(rb_gsl_matrix,vertcat)(mm, mm2); } #ifdef GSL_1_9_LATER static VALUE FUNCTION(rb_gsl_matrix,property)(VALUE obj, int (*f)(const GSL_TYPE(gsl_matrix)*)) { GSL_TYPE(gsl_matrix) *m; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); return INT2FIX((*f)(m)); } static VALUE FUNCTION(rb_gsl_matrix,property2)(VALUE obj, int (*f)(const GSL_TYPE(gsl_matrix) *)) { GSL_TYPE(gsl_matrix) *m; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); if ((*f)(m)) return Qtrue; else return Qfalse; } static VALUE FUNCTION(rb_gsl_matrix,ispos)(VALUE obj) { return FUNCTION(rb_gsl_matrix,property)(obj, FUNCTION(gsl_matrix,ispos)); } static VALUE FUNCTION(rb_gsl_matrix,ispos2)(VALUE obj) { return FUNCTION(rb_gsl_matrix,property2)(obj, FUNCTION(gsl_matrix,ispos)); } static VALUE FUNCTION(rb_gsl_matrix,isneg)(VALUE obj) { return FUNCTION(rb_gsl_matrix,property)(obj, FUNCTION(gsl_matrix,isneg)); } static VALUE FUNCTION(rb_gsl_matrix,isneg2)(VALUE obj) { return FUNCTION(rb_gsl_matrix,property2)(obj, FUNCTION(gsl_matrix,isneg)); } #endif #ifdef GSL_1_10_LATER static VALUE FUNCTION(rb_gsl_matrix,isnonneg)(VALUE obj) { return FUNCTION(rb_gsl_matrix,property)(obj, FUNCTION(gsl_matrix,isnonneg)); } static VALUE FUNCTION(rb_gsl_matrix,isnonneg2)(VALUE obj) { return FUNCTION(rb_gsl_matrix,property2)(obj, FUNCTION(gsl_matrix,isnonneg)); } #endif static VALUE FUNCTION(rb_gsl_matrix,symmetrize)(VALUE obj) { GSL_TYPE(gsl_matrix) *m, *mnew; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); if (m->size1 != m->size2) rb_raise(rb_eRuntimeError, "symmetrize: not a square matrix.\n"); mnew = FUNCTION(gsl_matrix,alloc)(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = i; j < m->size2; j++) { FUNCTION(gsl_matrix,set)(mnew, i, j, FUNCTION(gsl_matrix,get)(m, i, j)); } for (j = 0; j < i; j++) { FUNCTION(gsl_matrix,set)(mnew, i, j, FUNCTION(gsl_matrix,get)(m, j, i)); } } return Data_Wrap_Struct(GSL_TYPE(cgsl_matrix), 0, FUNCTION(gsl_matrix,free), mnew); } static VALUE FUNCTION(rb_gsl_matrix,symmetrize_bang)(VALUE obj) { GSL_TYPE(gsl_matrix) *m; size_t i, j; Data_Get_Struct(obj, GSL_TYPE(gsl_matrix), m); if (m->size1 != m->size2) rb_raise(rb_eRuntimeError, "symmetrize: not a square matrix.\n"); for (i = 0; i < m->size1; i++) { for (j = 0; j < i; j++) { FUNCTION(gsl_matrix,set)(m, i, j, FUNCTION(gsl_matrix,get)(m, j, i)); } } return obj; } void FUNCTION(Init_gsl_matrix,init)(VALUE module) { /* rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "new", FUNCTION(rb_gsl_matrix,alloc), -1);*/ rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "[]", FUNCTION(rb_gsl_matrix,alloc), -1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "alloc", FUNCTION(rb_gsl_matrix,alloc), -1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "calloc", FUNCTION(rb_gsl_matrix,calloc), 2); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "eye", FUNCTION(rb_gsl_matrix,eye), -1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "ones", FUNCTION(rb_gsl_matrix,ones), -1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "zeros", FUNCTION(rb_gsl_matrix,zeros), -1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "diagonal", FUNCTION(rb_gsl_matrix,diagonal_singleton), -1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "diag", FUNCTION(rb_gsl_matrix,diagonal_singleton), -1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "identity", FUNCTION(rb_gsl_matrix,identity), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "scalar", FUNCTION(rb_gsl_matrix,identity), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "unit", FUNCTION(rb_gsl_matrix,identity), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "I", FUNCTION(rb_gsl_matrix,identity), 1); /*****/ rb_define_method(GSL_TYPE(cgsl_matrix), "size1", FUNCTION(rb_gsl_matrix,size1), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "size2", FUNCTION(rb_gsl_matrix,size2), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "shape", FUNCTION(rb_gsl_matrix,shape), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "size", "shape"); rb_define_method(GSL_TYPE(cgsl_matrix), "get", FUNCTION(rb_gsl_matrix,get), -1); rb_define_alias(GSL_TYPE(cgsl_matrix), "[]", "get"); rb_define_method(GSL_TYPE(cgsl_matrix), "set", FUNCTION(rb_gsl_matrix,set), -1); rb_define_alias(GSL_TYPE(cgsl_matrix), "[]=", "set"); rb_define_method(GSL_TYPE(cgsl_matrix), "set_all", FUNCTION(rb_gsl_matrix,set_all), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "set_zero", FUNCTION(rb_gsl_matrix,set_zero), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "set_identity", FUNCTION(rb_gsl_matrix,set_identity), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "print", FUNCTION(rb_gsl_matrix,print), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "inspect", FUNCTION(rb_gsl_matrix,inspect), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "to_s", FUNCTION(rb_gsl_matrix,to_s), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "set_diagonal", FUNCTION(rb_gsl_matrix,set_diagonal), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "get_row", FUNCTION(rb_gsl_matrix,get_row), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "get_column", FUNCTION(rb_gsl_matrix,get_col), 1); rb_define_alias(GSL_TYPE(cgsl_matrix), "get_col", "get_column"); rb_define_method(GSL_TYPE(cgsl_matrix), "set_column", FUNCTION(rb_gsl_matrix,set_col), 2); rb_define_alias(GSL_TYPE(cgsl_matrix), "set_col", "set_column"); rb_define_method(GSL_TYPE(cgsl_matrix), "set_row", FUNCTION(rb_gsl_matrix,set_row), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "clone", FUNCTION(rb_gsl_matrix,clone), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "duplicate", "clone"); rb_define_alias(GSL_TYPE(cgsl_matrix), "dup", "clone"); rb_define_method(GSL_TYPE(cgsl_matrix), "isnull", FUNCTION(rb_gsl_matrix,isnull), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "isnull?", FUNCTION(rb_gsl_matrix,isnull2), 0); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "memcpy", FUNCTION(rb_gsl_matrix,memcpy), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "swap_rows", FUNCTION(rb_gsl_matrix,swap_rows), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "swap_rows!", FUNCTION(rb_gsl_matrix,swap_rows_bang), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "swap_columns", FUNCTION(rb_gsl_matrix,swap_columns), 2); rb_define_alias(GSL_TYPE(cgsl_matrix), "swap_cols", "swap_columns"); rb_define_method(GSL_TYPE(cgsl_matrix), "swap_columns!", FUNCTION(rb_gsl_matrix,swap_columns_bang), 2); rb_define_alias(GSL_TYPE(cgsl_matrix), "swap_cols!", "swap_columns!"); rb_define_method(GSL_TYPE(cgsl_matrix), "swap_rowcol", FUNCTION(rb_gsl_matrix,swap_rowcol), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "swap_rowcol!", FUNCTION(rb_gsl_matrix,swap_rowcol_bang), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "transpose_memcpy", FUNCTION(rb_gsl_matrix,transpose_memcpy), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "transpose", "transpose_memcpy"); rb_define_alias(GSL_TYPE(cgsl_matrix), "trans", "transpose_memcpy"); rb_define_method(GSL_TYPE(cgsl_matrix), "transpose!", FUNCTION(rb_gsl_matrix,transpose_bang), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "trans!", "transpose!"); rb_define_method(GSL_TYPE(cgsl_matrix), "reverse_columns", FUNCTION(rb_gsl_matrix,reverse_columns), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "fliplr", "reverse_columns"); rb_define_method(GSL_TYPE(cgsl_matrix), "reverse_columns!", FUNCTION(rb_gsl_matrix,reverse_columns_bang), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "reverse_rows", FUNCTION(rb_gsl_matrix,reverse_rows), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "flipud", "reverse_rows"); rb_define_method(GSL_TYPE(cgsl_matrix), "reverse_rows!", FUNCTION(rb_gsl_matrix,reverse_rows_bang), 0); /*****/ rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "swap", FUNCTION(rb_gsl_matrix,swap), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "max", FUNCTION(rb_gsl_matrix,max), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "min", FUNCTION(rb_gsl_matrix,min), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "minmax", FUNCTION(rb_gsl_matrix,minmax), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "max_index", FUNCTION(rb_gsl_matrix,max_index), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "min_index", FUNCTION(rb_gsl_matrix,min_index), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "minmax_index", FUNCTION(rb_gsl_matrix,minmax_index), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "fwrite", FUNCTION(rb_gsl_matrix,fwrite), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "fread", FUNCTION(rb_gsl_matrix,fread), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "fprintf", FUNCTION(rb_gsl_matrix,fprintf), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "printf", FUNCTION(rb_gsl_matrix,printf), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "fscanf", FUNCTION(rb_gsl_matrix,fscanf), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "trace", FUNCTION(rb_gsl_matrix,trace), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "-@", FUNCTION(rb_gsl_matrix,uminus), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "+@", FUNCTION(rb_gsl_matrix,uplus), 0); /*****/ rb_define_method(GSL_TYPE(cgsl_matrix), "submatrix", FUNCTION(rb_gsl_matrix,submatrix), -1); rb_define_alias(GSL_TYPE(cgsl_matrix), "view", "submatrix"); rb_define_method(GSL_TYPE(cgsl_matrix), "row", FUNCTION(rb_gsl_matrix,row), 1); /* rb_define_alias(GSL_TYPE(cgsl_matrix), "[]", "row");*/ rb_define_method(GSL_TYPE(cgsl_matrix), "column", FUNCTION(rb_gsl_matrix,column), 1); rb_define_alias(GSL_TYPE(cgsl_matrix), "col", "column"); #ifdef GSL_1_10_LATER rb_define_method(GSL_TYPE(cgsl_matrix), "subrow", FUNCTION(rb_gsl_matrix,subrow), 3); rb_define_method(GSL_TYPE(cgsl_matrix), "subcolumn", FUNCTION(rb_gsl_matrix,subcolumn), 3); rb_define_alias(GSL_TYPE(cgsl_matrix), "subcol", "subcolumn"); #endif rb_define_method(GSL_TYPE(cgsl_matrix), "diagonal", FUNCTION(rb_gsl_matrix,diagonal), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "diag", "diagonal"); rb_define_method(GSL_TYPE(cgsl_matrix), "subdiagonal", FUNCTION(rb_gsl_matrix,subdiagonal), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "superdiagonal", FUNCTION(rb_gsl_matrix,superdiagonal), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "vector_view", FUNCTION(rb_gsl_matrix,vector_view), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "each_row", FUNCTION(rb_gsl_matrix,each_row), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "each_col", FUNCTION(rb_gsl_matrix,each_col), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "each_column", "each_col"); rb_define_method(GSL_TYPE(cgsl_matrix), "scale", FUNCTION(rb_gsl_matrix,scale), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "scale!", FUNCTION(rb_gsl_matrix,scale_bang), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "add_constant", FUNCTION(rb_gsl_matrix,add_constant), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "add_constant!", FUNCTION(rb_gsl_matrix,add_constant_bang), 1); rb_define_method(GSL_TYPE(cgsl_matrix), "equal?", FUNCTION(rb_gsl_matrix,equal), -1); rb_define_alias(GSL_TYPE(cgsl_matrix), "==", "equal?"); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "equal?", FUNCTION(rb_gsl_matrix,equal_singleton), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "power", FUNCTION(rb_gsl_matrix,power), 1); rb_define_alias(GSL_TYPE(cgsl_matrix), "**", "power"); rb_define_alias(GSL_TYPE(cgsl_matrix), "^", "power"); rb_define_method(GSL_TYPE(cgsl_matrix), "collect", FUNCTION(rb_gsl_matrix,collect), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "collect!", FUNCTION(rb_gsl_matrix,collect_bang), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "map", "collect"); rb_define_alias(GSL_TYPE(cgsl_matrix), "map!", "collect!"); #ifdef HAVE_TENSOR_TENSOR_H rb_define_method(GSL_TYPE(cgsl_matrix), "to_tensor", FUNCTION(rb_gsl_matrix,to_tensor), 0); #endif /*****/ rb_define_method(GSL_TYPE(cgsl_matrix), "to_a", FUNCTION(rb_gsl_matrix,to_a), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "to_v", FUNCTION(rb_gsl_matrix,to_v), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "to_vview", FUNCTION(rb_gsl_matrix,to_vview), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "data", "to_vview"); rb_define_method(GSL_TYPE(cgsl_matrix), "norm", FUNCTION(rb_gsl_matrix,norm), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "upper", FUNCTION(rb_gsl_matrix,upper), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "lower", FUNCTION(rb_gsl_matrix,lower), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "block", FUNCTION(rb_gsl_matrix,block), 0); /***** Special matrices *****/ rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "pascal", FUNCTION(rb_gsl_matrix,pascal1), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "vandermonde", FUNCTION(rb_gsl_matrix,vandermonde), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "vander", FUNCTION(rb_gsl_matrix,vandermonde), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "toeplitz", FUNCTION(rb_gsl_matrix,toeplitz), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "circulant", FUNCTION(rb_gsl_matrix,circulant), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "indgen", FUNCTION(rb_gsl_matrix,indgen_singleton), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "indgen", FUNCTION(rb_gsl_matrix,indgen), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "indgen!", FUNCTION(rb_gsl_matrix,indgen_bang), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "info", FUNCTION(rb_gsl_matrix,info), 0); #ifdef BASE_DOUBLE rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "hilbert", FUNCTION(rb_gsl_matrix,hilbert), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "hilb", FUNCTION(rb_gsl_matrix,hilbert), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "invhilbert", FUNCTION(rb_gsl_matrix,invhilbert), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "invhilb", FUNCTION(rb_gsl_matrix,invhilbert), 1); #endif rb_define_method(GSL_TYPE(cgsl_matrix), "any", FUNCTION(rb_gsl_matrix,any), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "all", FUNCTION(rb_gsl_matrix,all), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "rot90", FUNCTION(rb_gsl_matrix,rot90), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "diff", FUNCTION(rb_gsl_matrix,diff), -1); rb_define_method(GSL_TYPE(cgsl_matrix), "isnan", FUNCTION(rb_gsl_matrix,isnan), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "isinf", FUNCTION(rb_gsl_matrix,isinf), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "finite", FUNCTION(rb_gsl_matrix,finite), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "sgn", FUNCTION(rb_gsl_matrix,sgn), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "signum", "sgn"); rb_define_method(GSL_TYPE(cgsl_matrix), "abs", FUNCTION(rb_gsl_matrix,abs), 0); rb_define_alias(GSL_TYPE(cgsl_matrix), "fabs", "abs"); rb_define_method(GSL_TYPE(cgsl_matrix), "horzcat", FUNCTION(rb_gsl_matrix,horzcat), 1); rb_define_alias(GSL_TYPE(cgsl_matrix), "cat", "horzcat"); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "horzcat", FUNCTION(rb_gsl_matrix,horzcat_singleton), 2); rb_define_method(GSL_TYPE(cgsl_matrix), "vertcat", FUNCTION(rb_gsl_matrix,vertcat), 1); rb_define_singleton_method(GSL_TYPE(cgsl_matrix), "vertcat", FUNCTION(rb_gsl_matrix,vertcat_singleton), 2); #ifdef GSL_1_9_LATER rb_define_method(GSL_TYPE(cgsl_matrix), "ispos", FUNCTION(rb_gsl_matrix,ispos), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "ispos?", FUNCTION(rb_gsl_matrix,ispos2), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "isneg", FUNCTION(rb_gsl_matrix,isneg), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "isneg?", FUNCTION(rb_gsl_matrix,isneg2), 0); #endif #ifdef GSL_1_10_LATER rb_define_method(GSL_TYPE(cgsl_matrix), "isnonneg", FUNCTION(rb_gsl_matrix,isnonneg), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "isnonneg?", FUNCTION(rb_gsl_matrix,isnonneg2), 0); #endif rb_define_method(GSL_TYPE(cgsl_matrix), "symmetrize", FUNCTION(rb_gsl_matrix,symmetrize), 0); rb_define_method(GSL_TYPE(cgsl_matrix), "symmetrize!", FUNCTION(rb_gsl_matrix,symmetrize_bang), 0); } #undef NUMCONV #undef NUMCONV2 #undef PRINTF_FORMAT #undef VEC_ROW_COL #undef VEC_P #undef C_TO_VALUE #undef C_TO_VALUE2 #undef VEC_COL_P #undef VEC_ROW_P #undef CHECK_VEC #undef VEC_VIEW_P #undef MAT_ROW_COL #undef MAT_P #undef MAT_COL_P #undef MAT_ROW_P #undef CHECK_MAT #undef MAT_VIEW_P gsl-1.15.3/ext/tensor_source.c0000644000175000017500000010557212220252463015612 0ustar boutilboutil/* tensor_source.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ /* The tensor package is developed by Jordi Burguet-Caltell, and distributed separately as an add-on package. http://savannah.nongnu.org/projects/tensor/ */ #ifdef HAVE_TENSOR_TENSOR_H #include "rb_gsl_config.h" #include "rb_gsl_tensor.h" #include "rb_gsl_common.h" #ifdef BASE_DOUBLE VALUE cgsl_tensor, cgsl_tensor_int; VALUE cgsl_tensor_view, cgsl_tensor_int_view; #define NUMCONV(x) NUM2DBL(x) #define C_TO_VALUE(x) rb_float_new(x) #define CHECK_TEN(x) CHECK_TENSOR(x) #define TEN_P(x) TENSOR_P(x) #define VEC_P(x) VECTOR_P(x) #define MAT_P(x) MATRIX_P(x) #else defined(BASE_INT) #define NUMCONV(x) FIX2INT(x) #define C_TO_VALUE(x) INT2FIX(x) #define CHECK_TEN(x) CHECK_TENSOR_INT(x) #define TEN_P(x) TENSOR_INT_P(x) #define VEC_P(x) VECTOR_INT_P(x) #define MAT_P(x) MATRIX_INT_P(x) #endif GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,alloc)(const unsigned int rank, const size_t dimension) { GSL_TYPE(rbgsl_tensor) *t; t = ALLOC(GSL_TYPE(rbgsl_tensor)); t->tensor = FUNCTION(tensor,alloc)(rank, dimension); if (rank == 0) t->indices = gsl_permutation_alloc(1); else t->indices = gsl_permutation_alloc(rank); return t; } GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,calloc)(const unsigned int rank, const size_t dimension) { GSL_TYPE(rbgsl_tensor) *t; t = ALLOC(GSL_TYPE(rbgsl_tensor)); t->tensor = FUNCTION(tensor,calloc)(rank, dimension); if (rank == 0) t->indices = gsl_permutation_alloc(1); else t->indices = gsl_permutation_alloc(rank); return t; } GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,copy)(const GSL_TYPE(rbgsl_tensor) *t) { GSL_TYPE(rbgsl_tensor) *tnew; tnew = ALLOC(GSL_TYPE(rbgsl_tensor)); if (t->tensor->rank == 0) tnew->indices = gsl_permutation_alloc(1); else tnew->indices = gsl_permutation_alloc(t->tensor->rank); tnew->tensor = FUNCTION(tensor,copy)(t->tensor); return tnew; } void FUNCTION(rbgsl_tensor,free)(GSL_TYPE(rbgsl_tensor) *t) { gsl_permutation_free(t->indices); FUNCTION(tensor,free)(t->tensor); free((GSL_TYPE(rbgsl_tensor) *) t); } void FUNCTION(rbgsl_tensor,free2)(GSL_TYPE(rbgsl_tensor) *t) { gsl_permutation_free(t->indices); free((GSL_TYPE(tensor)*) t->tensor); free((GSL_TYPE(rbgsl_tensor) *) t); } /* singleton methods */ static VALUE FUNCTION(rb_tensor,new)(int argc, VALUE *argv, VALUE klass) { unsigned int rank; size_t dim; GSL_TYPE(rbgsl_tensor) *t = NULL; switch (argc) { case 2: rank = FIX2UINT(argv[0]); dim = (size_t) FIX2UINT(argv[1]); t = FUNCTION(rbgsl_tensor,alloc)(rank, dim); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2, rank and dimension)", argc); break; } return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), t); } static VALUE FUNCTION(rb_tensor,calloc)(VALUE klass, VALUE r, VALUE s) { unsigned int rank; size_t dim; GSL_TYPE(rbgsl_tensor) *t = NULL; rank = FIX2UINT(r); dim = (size_t) FIX2UINT(s); t = FUNCTION(rbgsl_tensor,calloc)(rank, dim); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), t); } static VALUE FUNCTION(rb_tensor,copy_singleton)(VALUE klass, VALUE obj) { GSL_TYPE(rbgsl_tensor) *t = NULL, *tnew = NULL; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); tnew = FUNCTION(rbgsl_tensor,copy(t)); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), tnew); } static VALUE FUNCTION(rb_tensor,memcpy_singleton)(VALUE klass, VALUE a, VALUE b) { GSL_TYPE(rbgsl_tensor) *dst, *src; CHECK_TEN(b); Data_Get_Struct(a, GSL_TYPE(rbgsl_tensor), dst); Data_Get_Struct(b, GSL_TYPE(rbgsl_tensor), src); return INT2FIX(FUNCTION(tensor,memcpy)(dst->tensor, src->tensor)); } static VALUE FUNCTION(rb_tensor,swap_singleton)(VALUE klass, VALUE a, VALUE b) { GSL_TYPE(rbgsl_tensor) *t1, *t2; CHECK_TEN(b); Data_Get_Struct(a, GSL_TYPE(rbgsl_tensor), t1); Data_Get_Struct(b, GSL_TYPE(rbgsl_tensor), t2); return INT2FIX(FUNCTION(tensor,swap)(t1->tensor, t2->tensor)); } /*****/ static VALUE FUNCTION(rb_tensor,copy)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t = NULL, *tnew = NULL; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); tnew = FUNCTION(rbgsl_tensor,copy)(t); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), tnew); } static VALUE FUNCTION(rb_tensor,set_zero)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t = NULL; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); FUNCTION(tensor,set_zero)(t->tensor); return obj; } static VALUE FUNCTION(rb_tensor,set_all)(VALUE obj, VALUE xx) { GSL_TYPE(rbgsl_tensor) *t = NULL; BASE x; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); x = NUMCONV(xx); FUNCTION(tensor,set_all)(t->tensor, x); return obj; } static void rb_tensor_get_indices_array(tensor_indices *v, VALUE ary); static void rbgsl_tensor_get_indices(int argc, VALUE *argv, tensor_indices *indices, size_t *n); #ifdef BASE_DOUBLE static void rb_tensor_get_indices_array(tensor_indices *v, VALUE ary) { size_t i, nn; // nn = (size_t) GSL_MIN_INT((int) v->size, (int) RARRAY(ary)->len); nn = (size_t) GSL_MIN_INT((int) v->size, (int) RARRAY_LEN(ary)); for (i = 0; i < nn; i++) v->data[i] = FIX2UINT(rb_ary_entry(ary, i)); } static void rbgsl_tensor_get_indices(int argc, VALUE *argv, tensor_indices *indices, size_t *n) { size_t i; for (i = 0; i < indices->size; i++) indices->data[i] = 0; switch (argc) { case 1: switch (TYPE(argv[0])) { case T_ARRAY: // *n = (size_t) GSL_MIN_INT((int) indices->size, (int) RARRAY(argv[0])->len); *n = (size_t) GSL_MIN_INT((int) indices->size, (int) RARRAY_LEN(argv[0])); rb_tensor_get_indices_array(indices, argv[0]); break; case T_FIXNUM: *n = 1; indices->data[0] = FIX2INT(argv[0]); break; default: rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)", rb_class2name(CLASS_OF(argv[0]))); break; } break; default: *n = (size_t) GSL_MIN_INT(argc, (int) indices->size); for (i = 0; i < *n; i++) { CHECK_FIXNUM(argv[i]); indices->data[i] = FIX2INT(argv[i]); } break; } } #endif size_t FUNCTION(tensor,position)(const size_t * indices, const GSL_TYPE(tensor) * t); static VALUE FUNCTION(rb_tensor,position)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(rbgsl_tensor) *t = NULL; size_t n, position; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); rbgsl_tensor_get_indices(argc, argv, t->indices, &n); position = (size_t) FUNCTION(tensor,position)(t->indices->data,t->tensor); return INT2FIX(position); } static VALUE FUNCTION(rb_tensor,subtensor)(int argc, VALUE *argv, VALUE obj); static VALUE FUNCTION(rb_tensor,get)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(rbgsl_tensor) *t = NULL; BASE x; size_t n; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); rbgsl_tensor_get_indices(argc, argv, t->indices, &n); if (n < t->tensor->rank) { return FUNCTION(rb_tensor,subtensor)(argc, argv, obj); } else { x = FUNCTION(tensor,get)(t->tensor, t->indices->data); return C_TO_VALUE(x); } return Qnil; } static VALUE FUNCTION(rb_tensor,set)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(rbgsl_tensor) *t = NULL; size_t n; BASE x; if (argc < 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 2)", argc); Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); rbgsl_tensor_get_indices(argc-1, argv, t->indices, &n); x = NUMCONV(argv[argc-1]); FUNCTION(tensor,set)(t->tensor, t->indices->data, x); return obj; } static VALUE FUNCTION(rb_tensor,fread)(VALUE obj, VALUE io) { GSL_TYPE(rbgsl_tensor) *t = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); f = rb_gsl_open_readfile(io, &flag); status = FUNCTION(tensor,fread)(f, t->tensor); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE FUNCTION(rb_tensor,fwrite)(VALUE obj, VALUE io) { GSL_TYPE(rbgsl_tensor) *t = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); f = rb_gsl_open_writefile(io, &flag); status = FUNCTION(tensor,fwrite)(f, t->tensor); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE FUNCTION(rb_tensor,fprintf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(rbgsl_tensor) *h = NULL; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), h); fp = rb_gsl_open_writefile(argv[0], &flag); switch (argc) { case 2: if (TYPE(argv[1]) == T_STRING) status = FUNCTION(tensor,fprintf)(fp, h->tensor, STR2CSTR(argv[1])); else rb_raise(rb_eTypeError, "argv 2 String expected"); break; default: status = FUNCTION(tensor,fprintf)(fp, h->tensor, OUT_FORMAT); break; } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE FUNCTION(rb_tensor,printf)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(rbgsl_tensor) *h = NULL; int status; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), h); if (argc == 1) { if (TYPE(argv[0]) != T_STRING) rb_raise(rb_eTypeError, "String expected"); else status = FUNCTION(tensor,fprintf)(stdout, h->tensor, STR2CSTR(argv[0])); } else { status = FUNCTION(tensor,fprintf)(stdout, h->tensor, OUT_FORMAT); } return INT2FIX(status); } static VALUE FUNCTION(rb_tensor,fscanf)(VALUE obj, VALUE io) { GSL_TYPE(rbgsl_tensor) *h = NULL; FILE *fp = NULL; int status, flag = 0; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), h); fp = rb_gsl_open_readfile(io, &flag); status = FUNCTION(tensor,fscanf)(fp, h->tensor); if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE FUNCTION(rb_tensor,swap_indices)(VALUE obj, VALUE ii, VALUE jj) { GSL_TYPE(rbgsl_tensor) *t, *tnew; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); tnew = ALLOC(GSL_TYPE(rbgsl_tensor)); if (t->tensor->rank == 0) tnew->indices = gsl_permutation_alloc(1); else tnew->indices = gsl_permutation_alloc(t->tensor->rank); tnew->tensor = FUNCTION(tensor,swap_indices)(t->tensor, FIX2INT(ii), FIX2INT(jj)); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), tnew); } static VALUE FUNCTION(rb_tensor,max)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); return C_TO_VALUE(FUNCTION(tensor,max)(t->tensor)); } static VALUE FUNCTION(rb_tensor,min)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); return C_TO_VALUE(FUNCTION(tensor,min)(t->tensor)); } static VALUE FUNCTION(rb_tensor,minmax)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; BASE min, max; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); FUNCTION(tensor,minmax)(t->tensor, &min, &max); return rb_ary_new3(2, C_TO_VALUE(min), C_TO_VALUE(max)); } static VALUE FUNCTION(rb_tensor,max_index)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); FUNCTION(tensor,max_index)(t->tensor, t->indices->data); return Data_Wrap_Struct(cgsl_index, 0, NULL, t->indices); } static VALUE FUNCTION(rb_tensor,min_index)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); FUNCTION(tensor,min_index)(t->tensor, t->indices->data); return Data_Wrap_Struct(cgsl_index, 0, NULL, t->indices); } static VALUE FUNCTION(rb_tensor,minmax_index)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; gsl_permutation *min, *max; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); if (t->tensor->rank == 0) { min = gsl_permutation_alloc(1); max = gsl_permutation_alloc(1); } else { min = gsl_permutation_alloc(t->tensor->rank); max = gsl_permutation_alloc(t->tensor->rank); } FUNCTION(tensor,minmax_index)(t->tensor, min->data, max->data); return rb_ary_new3(2, Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, min), Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, max)); } static VALUE FUNCTION(rb_tensor,isnull)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); return INT2FIX(FUNCTION(tensor,isnull)(t->tensor)); } static VALUE FUNCTION(rb_tensor,isnull2)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; int status; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); status = FUNCTION(tensor,isnull)(t->tensor); if (status) return Qtrue; else return Qfalse; } static VALUE FUNCTION(rb_tensor,oper)(VALUE obj, VALUE bb, int flag) { GSL_TYPE(rbgsl_tensor) *a, *b, *anew; BASE x; int (*f)(GSL_TYPE(tensor)*, const GSL_TYPE(tensor)*); int (*f2)(GSL_TYPE(tensor)*, const double); Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), a); anew = FUNCTION(rbgsl_tensor,copy)(a); if (TEN_P(bb)) { Data_Get_Struct(bb, GSL_TYPE(rbgsl_tensor), b); switch (flag) { case TENSOR_ADD: f = FUNCTION(&tensor,add); break; case TENSOR_SUB: f = FUNCTION(&tensor,sub); break; case TENSOR_MUL_ELEMENTS: f = FUNCTION(&tensor,mul_elements); break; case TENSOR_DIV_ELEMENTS: f = FUNCTION(&tensor,div_elements); break; default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } (*f)(anew->tensor, b->tensor); } else { switch (flag) { case TENSOR_ADD: case TENSOR_ADD_CONSTANT: x = NUMCONV(bb); f2 = FUNCTION(&tensor,add_constant); break; case TENSOR_SUB: x = -NUMCONV(bb); f2 = FUNCTION(&tensor,add_constant); break; case TENSOR_ADD_DIAGONAL: f2 = FUNCTION(&tensor,add_diagonal); break; case TENSOR_MUL_ELEMENTS: case TENSOR_SCALE: x = NUMCONV(bb); f2 = FUNCTION(&tensor,scale); break; case TENSOR_DIV_ELEMENTS: x = 1.0/NUMCONV(bb); f2 = FUNCTION(&tensor,scale); break; default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } (*f2)(anew->tensor, x); } return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), anew); } static VALUE FUNCTION(rb_tensor,oper_bang)(VALUE obj, VALUE bb, int flag) { GSL_TYPE(rbgsl_tensor) *a, *b; BASE x; int (*f)(GSL_TYPE(tensor)*, const GSL_TYPE(tensor)*); int (*f2)(GSL_TYPE(tensor)*, const double); Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), a); if (TEN_P(bb)) { Data_Get_Struct(bb, GSL_TYPE(rbgsl_tensor), b); switch (flag) { case TENSOR_ADD: f = FUNCTION(&tensor,add); break; case TENSOR_SUB: f = FUNCTION(&tensor,sub); break; case TENSOR_MUL_ELEMENTS: f = FUNCTION(&tensor,mul_elements); break; case TENSOR_DIV_ELEMENTS: f = FUNCTION(&tensor,div_elements); break; default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } (*f)(a->tensor, b->tensor); } else { switch (flag) { case TENSOR_ADD: case TENSOR_ADD_CONSTANT: x = NUMCONV(bb); f2 = FUNCTION(&tensor,add_constant); break; case TENSOR_SUB: x = -NUMCONV(bb); f2 = FUNCTION(&tensor,add_constant); break; case TENSOR_ADD_DIAGONAL: f2 = FUNCTION(&tensor,add_diagonal); break; case TENSOR_MUL_ELEMENTS: case TENSOR_SCALE: x = NUMCONV(bb); f2 = FUNCTION(&tensor,scale); break; case TENSOR_DIV_ELEMENTS: x = 1.0/NUMCONV(bb); f2 = FUNCTION(&tensor,scale); break; default: rb_raise(rb_eRuntimeError, "unknown operation"); break; } (*f2)(a->tensor, x); } return obj; } static VALUE FUNCTION(rb_tensor,add)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper)(obj, bb, TENSOR_ADD); } static VALUE FUNCTION(rb_tensor,sub)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper)(obj, bb, TENSOR_SUB); } static VALUE FUNCTION(rb_tensor,mul_elements)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper)(obj, bb, TENSOR_MUL_ELEMENTS); } static VALUE FUNCTION(rb_tensor,div_elements)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper)(obj, bb, TENSOR_DIV_ELEMENTS); } static VALUE FUNCTION(rb_tensor,add_constant)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper)(obj, bb, TENSOR_ADD_CONSTANT); } static VALUE FUNCTION(rb_tensor,add_diagonal)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper)(obj, bb, TENSOR_ADD_DIAGONAL); } static VALUE FUNCTION(rb_tensor,scale)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper)(obj, bb, TENSOR_SCALE); } /***/ static VALUE FUNCTION(rb_tensor,add_bang)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper_bang)(obj, bb, TENSOR_ADD); } static VALUE FUNCTION(rb_tensor,sub_bang)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper_bang)(obj, bb, TENSOR_SUB); } static VALUE FUNCTION(rb_tensor,mul_elements_bang)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper_bang)(obj, bb, TENSOR_MUL_ELEMENTS); } static VALUE FUNCTION(rb_tensor,div_elements_bang)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper_bang)(obj, bb, TENSOR_DIV_ELEMENTS); } static VALUE FUNCTION(rb_tensor,add_constant_bang)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper_bang)(obj, bb, TENSOR_ADD_CONSTANT); } static VALUE FUNCTION(rb_tensor,add_diagonal_bang)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper_bang)(obj, bb, TENSOR_ADD_DIAGONAL); } static VALUE FUNCTION(rb_tensor,scale_bang)(VALUE obj, VALUE bb) { return FUNCTION(rb_tensor,oper_bang)(obj, bb, TENSOR_SCALE); } /*****/ static VALUE FUNCTION(rb_tensor,product_singleton)(VALUE obj, VALUE aa, VALUE bb) { GSL_TYPE(rbgsl_tensor) *a, *b, *c; CHECK_TEN(aa); CHECK_TEN(bb); Data_Get_Struct(aa, GSL_TYPE(rbgsl_tensor), a); switch (TYPE(bb)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return FUNCTION(rb_tensor,mul_elements)(aa, bb); break; default: Data_Get_Struct(bb, GSL_TYPE(rbgsl_tensor), b); c = ALLOC(GSL_TYPE(rbgsl_tensor)); c->tensor = FUNCTION(tensor,product(a->tensor, b->tensor)); if (c->tensor->rank == 0) c->indices = gsl_permutation_alloc(1); else c->indices = gsl_permutation_alloc(c->tensor->rank); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), c); break; } } static VALUE FUNCTION(rb_tensor,product)(VALUE obj, VALUE bb) { GSL_TYPE(rbgsl_tensor) *a, *b, *c; switch (TYPE(bb)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return FUNCTION(rb_tensor,mul_elements)(obj, bb); break; default: CHECK_TEN(bb); Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), a); Data_Get_Struct(bb, GSL_TYPE(rbgsl_tensor), b); c = ALLOC(GSL_TYPE(rbgsl_tensor)); c->tensor = FUNCTION(tensor,product(a->tensor, b->tensor)); if (c->tensor->rank == 0) c->indices = gsl_permutation_alloc(1); else c->indices = gsl_permutation_alloc(c->tensor->rank); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), c); break; } } static VALUE FUNCTION(rb_tensor,contract)(VALUE obj, VALUE ii, VALUE jj) { GSL_TYPE(rbgsl_tensor) *t, *tnew; size_t rank; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); tnew = ALLOC(GSL_TYPE(rbgsl_tensor)); tnew->tensor = FUNCTION(tensor,contract)(t->tensor, FIX2INT(ii), FIX2INT(jj)); if (tnew->tensor->rank == 0) rank = 1; else rank = tnew->tensor->rank; tnew->indices = gsl_permutation_alloc(rank); return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), tnew); } static VALUE FUNCTION(rb_tensor,size)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); return INT2FIX(t->tensor->size); } static VALUE FUNCTION(rb_tensor,rank)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); return INT2FIX(t->tensor->rank); } static VALUE FUNCTION(rb_tensor,dimension)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); return INT2FIX(t->tensor->dimension); } static VALUE FUNCTION(rb_tensor,data)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; QUALIFIED_VIEW(gsl_vector,view) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); v = FUNCTION(rb_gsl_make_vector,view)(t->tensor->data, t->tensor->size, 1); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, free, v); } static VALUE FUNCTION(rb_tensor,2matrix)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; GSL_TYPE(gsl_matrix) *m = NULL; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); m = (GSL_TYPE(gsl_matrix)*) FUNCTION(tensor,2matrix)(t->tensor); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_matrix,view), 0, FUNCTION(gsl_matrix,free), m); } static VALUE FUNCTION(rb_tensor,2vector)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; GSL_TYPE(gsl_vector) *v = NULL; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); v = (GSL_TYPE(gsl_vector) *) FUNCTION(tensor,2vector)(t->tensor); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, FUNCTION(gsl_vector,free), v); } static VALUE FUNCTION(rb_tensor,to_v)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; GSL_TYPE(gsl_vector) *v; v = FUNCTION(gsl_vector,alloc)(t->tensor->size); memcpy(v->data, t->tensor->data, sizeof(BASE)*v->size); return Data_Wrap_Struct(GSL_TYPE(cgsl_vector), 0, FUNCTION(gsl_vector,free), v); } /* Creates a subtensor slicing the existing tensor. NOTE: no new data region is malloced. t: Tensor rank: rank of the tensor created */ GSL_TYPE(tensor) FUNCTION(tensor,subtensor)(const GSL_TYPE(tensor) *t, const unsigned int rank, size_t *indices) { GSL_TYPE(tensor) tnew; size_t position; tnew.rank = rank; tnew.dimension = t->dimension; tnew.size = quick_pow(t->dimension, rank); position = FUNCTION(tensor,position)(indices, t); if (position >= t->size) rb_raise(rb_eRangeError, "wrong indices given"); tnew.data = t->data + position; return tnew; } static VALUE FUNCTION(rb_tensor,subtensor)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(rbgsl_tensor) *t, *tnew; unsigned int rank; size_t n; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); /* n: number of indices given */ rbgsl_tensor_get_indices(argc, argv, t->indices, &n); rank = t->tensor->rank - n; tnew = ALLOC(GSL_TYPE(rbgsl_tensor)); tnew->tensor = (GSL_TYPE(tensor)*) malloc(sizeof(GSL_TYPE(tensor))); *(tnew->tensor) = FUNCTION(tensor,subtensor)(t->tensor, rank, t->indices->data); if (rank == 0) tnew->indices = gsl_permutation_alloc(1); else tnew->indices = gsl_permutation_alloc(rank); return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_tensor,view), 0, FUNCTION(rbgsl_tensor,free2), tnew); } #ifdef BASE_DOUBLE #define SHOW_ELM 6 #define PRINTF_FORMAT "%4.3e " #else #define SHOW_ELM 15 #define PRINTF_FORMAT "%d " #endif static VALUE FUNCTION(rb_tensor,to_s)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; QUALIFIED_VIEW(gsl_matrix,view) matrix; QUALIFIED_VIEW(gsl_vector,view) vector; GSL_TYPE(gsl_matrix) *m; GSL_TYPE(gsl_vector) *v; char buf[16]; size_t i, j; VALUE str; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); str = rb_str_new2("[ "); switch (t->tensor->rank) { case 2: matrix.matrix.data = t->tensor->data; matrix.matrix.size1 = t->tensor->dimension; matrix.matrix.size2 = t->tensor->dimension; matrix.matrix.tda = t->tensor->dimension; matrix.matrix.block = 0; matrix.matrix.owner = 0; m = &(matrix.matrix); for (i = 0; i < m->size1; i++) { if (i != 0) { strcpy(buf, " "); rb_str_cat(str, buf, strlen(buf)); } for (j = 0; j < m->size2; j++) { sprintf(buf, PRINTF_FORMAT, FUNCTION(gsl_matrix,get)(m, i, j)); rb_str_cat(str, buf, strlen(buf)); if (j == SHOW_ELM) { strcpy(buf, "... "); rb_str_cat(str, buf, strlen(buf)); break; } } if (i == 6) { strcpy(buf, "\n ... ]"); rb_str_cat(str, buf, strlen(buf)); break; } if (i == m->size1 - 1) { strcpy(buf, "]"); rb_str_cat(str, buf, strlen(buf)); } else { strcpy(buf, "\n"); rb_str_cat(str, buf, strlen(buf)); } } return str; break; default: vector.vector.data = t->tensor->data; vector.vector.stride = 1; vector.vector.size = t->tensor->size; vector.vector.owner = 0; vector.vector.block = 0; v = &(vector.vector); sprintf(buf, PRINTF_FORMAT, FUNCTION(gsl_vector,get)(v, 0)); rb_str_cat(str, buf, strlen(buf)); for (i = 1; i < v->size; i++) { sprintf(buf, PRINTF_FORMAT, FUNCTION(gsl_vector,get)(v, i)); rb_str_cat(str, buf, strlen(buf)); if (i == SHOW_ELM && i != v->size-1) { strcpy(buf, "... "); rb_str_cat(str, buf, strlen(buf)); break; } } sprintf(buf, "]"); rb_str_cat(str, buf, strlen(buf)); return str; break; } } #undef SHOW_ELM #undef PRINTF_FORMAT static VALUE FUNCTION(rb_tensor,inspect)(VALUE obj) { VALUE str; char buf[64]; sprintf(buf, "%s\n", rb_class2name(CLASS_OF(obj))); str = rb_str_new2(buf); return rb_str_concat(str, FUNCTION(rb_tensor,to_s)(obj)); } VALUE FUNCTION(rb_tensor,equal)(int argc, VALUE *argv, VALUE obj) { GSL_TYPE(rbgsl_tensor) *a, *b; GSL_TYPE(gsl_matrix) *m; GSL_TYPE(gsl_vector) *v; VALUE other; double eps = 1e-10; size_t i; switch (argc) { case 2: other = argv[0]; eps = NUM2DBL(argv[1]); break; case 1: other = argv[0]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), a); if (TEN_P(other)) { Data_Get_Struct(other, GSL_TYPE(rbgsl_tensor), b); if (a->tensor->rank != b->tensor->rank) return Qfalse; if (a->tensor->dimension != b->tensor->dimension) return Qfalse; if (a->tensor->size != b->tensor->size) return Qfalse; for (i = 0; i < a->tensor->size; i++) if (fabs(a->tensor->data[i]-b->tensor->data[i]) > eps) return Qfalse; return Qtrue; } else if (MAT_P(other)) { if (a->tensor->rank != 2) return Qfalse; Data_Get_Struct(other, GSL_TYPE(gsl_matrix), m); if (a->tensor->dimension != m->size1 || a->tensor->dimension != m->size2) return Qfalse; for (i = 0; i < a->tensor->size; i++) if (fabs(a->tensor->data[i]-m->data[i]) > eps) return Qfalse; return Qtrue; } else if (VEC_P(other)) { Data_Get_Struct(other, GSL_TYPE(gsl_vector), v); if (a->tensor->size != v->size) return Qfalse; for (i = 0; i < a->tensor->size; i++) if (fabs(a->tensor->data[i]-v->data[i]) > eps) return Qfalse; return Qtrue; } else { rb_raise(rb_eTypeError, "wrong argument type %s (Tensor, Matrix or Vector expected)", rb_class2name(CLASS_OF(other))); } } static VALUE FUNCTION(rb_tensor,uplus)(VALUE obj) { return obj; } static VALUE FUNCTION(rb_tensor,uminus)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t, *tnew; size_t i; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); tnew = FUNCTION(rbgsl_tensor,copy)(t); for (i = 0; i < tnew->tensor->size; i++) tnew->tensor->data[i] *= -1; return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), tnew); } static VALUE FUNCTION(rb_tensor,coerce)(VALUE obj, VALUE other) { GSL_TYPE(rbgsl_tensor) *t, *tnew; VALUE tt; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: tnew = FUNCTION(rbgsl_tensor,alloc)(t->tensor->rank, t->tensor->dimension); FUNCTION(tensor,set_all)(tnew->tensor, NUMCONV(other)); tt = Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), tnew); return rb_ary_new3(2, tt, obj); break; default: rb_raise(rb_eRuntimeError, "undefined operation with %s", rb_class2name(CLASS_OF(other))); break; } } static VALUE FUNCTION(rb_tensor,info)(VALUE obj) { GSL_TYPE(rbgsl_tensor) *t; char buf[256]; Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t); sprintf(buf, "Class: %s\n", rb_class2name(CLASS_OF(obj))); // sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super)); sprintf(buf, "%sRank: %d\n", buf, (int) t->tensor->rank); sprintf(buf, "%sDimension: %d\n", buf, (int) t->tensor->dimension); sprintf(buf, "%sSize: %d\n", buf, (int) t->tensor->size); return rb_str_new2(buf); } void FUNCTION(Init_tensor,init)(VALUE module) { #ifdef BASE_DOUBLE cgsl_tensor = rb_define_class_under(module, "Tensor", cGSL_Object); cgsl_tensor_int = rb_define_class_under(cgsl_tensor, "Int", cGSL_Object); cgsl_tensor_view = rb_define_class_under(cgsl_tensor, "View", cgsl_tensor); cgsl_tensor_int_view = rb_define_class_under(cgsl_tensor_int, "View", cgsl_tensor_int); /* cgsl_index = rb_define_class_under(cgsl_tensor, "Index", cgsl_permutation);*/ #endif rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "new", FUNCTION(rb_tensor,new), -1); rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "[]", FUNCTION(rb_tensor,new), -1); rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "alloc", FUNCTION(rb_tensor,new), -1); rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "calloc", FUNCTION(rb_tensor,calloc), 2); rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "copy", FUNCTION(rb_tensor,copy_singleton), 1); rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "memcpy", FUNCTION(rb_tensor,memcpy_singleton), 2); rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "swap", FUNCTION(rb_tensor,swap_singleton), 2); /*****/ rb_define_method(GSL_TYPE(cgsl_tensor), "copy", FUNCTION(rb_tensor,copy), 0); rb_define_alias(GSL_TYPE(cgsl_tensor), "clone", "copy"); rb_define_alias(GSL_TYPE(cgsl_tensor), "duplicate", "copy"); rb_define_method(GSL_TYPE(cgsl_tensor), "set_zero", FUNCTION(rb_tensor,set_zero), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "set_all", FUNCTION(rb_tensor,set_all), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "position", FUNCTION(rb_tensor,position), -1); rb_define_method(GSL_TYPE(cgsl_tensor), "get", FUNCTION(rb_tensor,get), -1); rb_define_alias(GSL_TYPE(cgsl_tensor), "[]", "get"); rb_define_method(GSL_TYPE(cgsl_tensor), "set", FUNCTION(rb_tensor,set), -1); rb_define_alias(GSL_TYPE(cgsl_tensor), "[]=", "set"); rb_define_method(GSL_TYPE(cgsl_tensor), "fread", FUNCTION(rb_tensor,fread), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "fwrite", FUNCTION(rb_tensor,fwrite), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "fprintf", FUNCTION(rb_tensor,fprintf), -1); rb_define_method(GSL_TYPE(cgsl_tensor), "printf", FUNCTION(rb_tensor,printf), -1); rb_define_method(GSL_TYPE(cgsl_tensor), "fscanf", FUNCTION(rb_tensor,fscanf), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "swap_indices", FUNCTION(rb_tensor,swap_indices), 2); rb_define_method(GSL_TYPE(cgsl_tensor), "max", FUNCTION(rb_tensor,max), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "min", FUNCTION(rb_tensor,min), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "minmax", FUNCTION(rb_tensor,minmax), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "max_index", FUNCTION(rb_tensor,max_index), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "min_index", FUNCTION(rb_tensor,min_index), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "minmax_index", FUNCTION(rb_tensor,minmax_index), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "isnull", FUNCTION(rb_tensor,isnull), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "isnull?", FUNCTION(rb_tensor,isnull2), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "add", FUNCTION(rb_tensor,add), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "sub", FUNCTION(rb_tensor,sub), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "mul_elements", FUNCTION(rb_tensor,mul_elements), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "div_elements", FUNCTION(rb_tensor,div_elements), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "add_constant", FUNCTION(rb_tensor,add_constant), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "add_diagonal", FUNCTION(rb_tensor,add_diagonal), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "scale", FUNCTION(rb_tensor,scale), 1); rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "product", FUNCTION(rb_tensor,product_singleton), 2); rb_define_method(GSL_TYPE(cgsl_tensor), "product", FUNCTION(rb_tensor,product), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "contract", FUNCTION(rb_tensor,contract), 2); rb_define_alias(GSL_TYPE(cgsl_tensor), "+", "add"); rb_define_alias(GSL_TYPE(cgsl_tensor), "-", "sub"); /* rb_define_alias(GSL_TYPE(cgsl_tensor), "*", "mul_elements");*/ rb_define_alias(GSL_TYPE(cgsl_tensor), "/", "div_elements"); rb_define_alias(GSL_TYPE(cgsl_tensor), "*", "product"); rb_define_method(GSL_TYPE(cgsl_tensor), "add!", FUNCTION(rb_tensor,add_bang), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "sub!", FUNCTION(rb_tensor,sub_bang), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "mul_elements!", FUNCTION(rb_tensor,mul_elements_bang), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "div_elements!", FUNCTION(rb_tensor,div_elements_bang), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "add_constant!", FUNCTION(rb_tensor,add_constant_bang), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "add_diagonal!", FUNCTION(rb_tensor,add_diagonal_bang), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "scale!", FUNCTION(rb_tensor,scale_bang), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "+@", FUNCTION(rb_tensor,uplus), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "-@", FUNCTION(rb_tensor,uminus), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "size", FUNCTION(rb_tensor,size), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "rank", FUNCTION(rb_tensor,rank), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "dimension", FUNCTION(rb_tensor,dimension), 0); rb_define_alias(GSL_TYPE(cgsl_tensor), "dim", "dimension"); rb_define_method(GSL_TYPE(cgsl_tensor), "data", FUNCTION(rb_tensor,data), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "to_v", FUNCTION(rb_tensor,to_v), 0); rb_define_alias(GSL_TYPE(cgsl_tensor), "to_gv", "to_v"); rb_define_method(GSL_TYPE(cgsl_tensor), "to_vector", FUNCTION(rb_tensor,2vector), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "to_matrix", FUNCTION(rb_tensor,2matrix), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "subtensor", FUNCTION(rb_tensor,subtensor), -1); rb_define_alias(GSL_TYPE(cgsl_tensor), "view", "subtensor"); rb_define_method(GSL_TYPE(cgsl_tensor), "to_s", FUNCTION(rb_tensor,to_s), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "inspect", FUNCTION(rb_tensor,inspect), 0); rb_define_method(GSL_TYPE(cgsl_tensor), "equal?", FUNCTION(rb_tensor,equal), -1); rb_define_alias(GSL_TYPE(cgsl_tensor), "==", "equal?"); rb_define_method(GSL_TYPE(cgsl_tensor), "coerce", FUNCTION(rb_tensor,coerce), 1); rb_define_method(GSL_TYPE(cgsl_tensor), "info", FUNCTION(rb_tensor,info), 0); } #undef NUMCONV #undef C_TO_VALUE #undef CHECK_TEN #undef TEN_P #undef VEC_P #undef MAT_P #endif gsl-1.15.3/ext/sf_debye.c0000644000175000017500000001121712220252463014470 0ustar boutilboutil/* sf_debye.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_debye_1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_debye_1, x); } static VALUE rb_gsl_sf_debye_1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_debye_1_e, x); } static VALUE rb_gsl_sf_debye_2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_debye_2, x); } static VALUE rb_gsl_sf_debye_2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_debye_2_e, x); } static VALUE rb_gsl_sf_debye_3(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_debye_3, x); } static VALUE rb_gsl_sf_debye_3_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_debye_3_e, x); } static VALUE rb_gsl_sf_debye_4(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_debye_4, x); } static VALUE rb_gsl_sf_debye_4_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_debye_4_e, x); } static VALUE rb_gsl_sf_debye_n(int argc, VALUE *argv, VALUE obj) { int n; VALUE x; switch (argc) { case 1: n = 1; x = argv[0]; break; case 2: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); x = argv[1]; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } switch (n) { case 1: return rb_gsl_sf_eval1(gsl_sf_debye_1, x); break; case 2: return rb_gsl_sf_eval1(gsl_sf_debye_2, x); break; case 3: return rb_gsl_sf_eval1(gsl_sf_debye_3, x); break; case 4: return rb_gsl_sf_eval1(gsl_sf_debye_4, x); break; #ifdef GSL_1_8_LATER case 5: return rb_gsl_sf_eval1(gsl_sf_debye_5, x); break; case 6: return rb_gsl_sf_eval1(gsl_sf_debye_6, x); break; #endif default: rb_raise(rb_eRuntimeError, "n must be 1, 2, 3, or 4"); break; } } #ifdef GSL_1_8_LATER static VALUE rb_gsl_sf_debye_5(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_debye_5, x); } static VALUE rb_gsl_sf_debye_5_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_debye_5_e, x); } static VALUE rb_gsl_sf_debye_6(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_debye_6, x); } static VALUE rb_gsl_sf_debye_6_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_debye_6_e, x); } #endif void Init_gsl_sf_debye(VALUE module) { VALUE mgsl_sf_debye; rb_define_module_function(module, "debye_1", rb_gsl_sf_debye_1, 1); rb_define_module_function(module, "debye_1_e", rb_gsl_sf_debye_1_e, 1); rb_define_module_function(module, "debye_2", rb_gsl_sf_debye_2, 1); rb_define_module_function(module, "debye_2_e", rb_gsl_sf_debye_2_e, 1); rb_define_module_function(module, "debye_3", rb_gsl_sf_debye_3, 1); rb_define_module_function(module, "debye_3_e", rb_gsl_sf_debye_3_e, 1); rb_define_module_function(module, "debye_4", rb_gsl_sf_debye_4, 1); rb_define_module_function(module, "debye_4_e", rb_gsl_sf_debye_4_e, 1); #ifdef GSL_1_8_LATER rb_define_module_function(module, "debye_5", rb_gsl_sf_debye_5, 1); rb_define_module_function(module, "debye_5_e", rb_gsl_sf_debye_5_e, 1); rb_define_module_function(module, "debye_6", rb_gsl_sf_debye_6, 1); rb_define_module_function(module, "debye_6_e", rb_gsl_sf_debye_6_e, 1); #endif rb_define_module_function(module, "debye_n", rb_gsl_sf_debye_n, -1); mgsl_sf_debye = rb_define_module_under(module, "Debye"); rb_define_module_function(mgsl_sf_debye, "one", rb_gsl_sf_debye_1, 1); rb_define_module_function(mgsl_sf_debye, "one_e", rb_gsl_sf_debye_1_e, 1); rb_define_module_function(mgsl_sf_debye, "two", rb_gsl_sf_debye_2, 1); rb_define_module_function(mgsl_sf_debye, "two_e", rb_gsl_sf_debye_2_e, 1); rb_define_module_function(mgsl_sf_debye, "three", rb_gsl_sf_debye_3, 1); rb_define_module_function(mgsl_sf_debye, "three_e", rb_gsl_sf_debye_3_e, 1); rb_define_module_function(mgsl_sf_debye, "four", rb_gsl_sf_debye_4, 1); rb_define_module_function(mgsl_sf_debye, "four_e", rb_gsl_sf_debye_4_e, 1); #ifdef GSL_1_8_LATER rb_define_module_function(mgsl_sf_debye, "five", rb_gsl_sf_debye_5, 1); rb_define_module_function(mgsl_sf_debye, "five_e", rb_gsl_sf_debye_5_e, 1); rb_define_module_function(mgsl_sf_debye, "six", rb_gsl_sf_debye_6, 1); rb_define_module_function(mgsl_sf_debye, "six_e", rb_gsl_sf_debye_6_e, 1); #endif rb_define_module_function(mgsl_sf_debye, "n", rb_gsl_sf_debye_n, -1); } gsl-1.15.3/ext/tensor.c0000644000175000017500000000151712220252463014224 0ustar boutilboutil/* tensor.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2004 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ /* The gsl_tensor package is developed by J.Burguet, and distributed separately as an add-on package. */ #ifdef HAVE_TENSOR_TENSOR_H #include "rb_gsl_config.h" #include "rb_gsl_tensor.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif #define BASE_DOUBLE #include "templates_on.h" #include "tensor_source.c" #include "templates_off.h" #undef BASE_DOUBLE #define BASE_INT #include "templates_on.h" #include "tensor_source.c" #include "templates_off.h" #undef BASE_INT #endif gsl-1.15.3/ext/sf_coulomb.c0000644000175000017500000001755712220252463015055 0ustar boutilboutil/* sf_coulomb.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" EXTERN VALUE cgsl_vector; static VALUE rb_gsl_sf_hydrogenicR_1(VALUE obj, VALUE Z, VALUE r) { return rb_gsl_sf_eval_double_double(gsl_sf_hydrogenicR_1, Z, r); } static VALUE rb_gsl_sf_hydrogenicR_1_e(VALUE obj, VALUE Z, VALUE r) { return rb_gsl_sf_eval_e_double2(gsl_sf_hydrogenicR_1_e, Z, r); } static VALUE rb_gsl_sf_hydrogenicR(VALUE obj, VALUE n, VALUE l, VALUE Z, VALUE r) { return rb_float_new(gsl_sf_hydrogenicR(FIX2INT(n), FIX2INT(l), NUM2DBL(Z), NUM2DBL(r))); } static VALUE rb_gsl_sf_hydrogenicR_e(VALUE obj, VALUE n, VALUE l, VALUE Z, VALUE r) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(n); CHECK_FIXNUM(l); Need_Float(Z); Need_Float(r); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_hydrogenicR_e(FIX2INT(n), FIX2INT(l), NUM2DBL(Z), NUM2DBL(r), rslt); return v; } static VALUE rb_gsl_sf_coulomb_wave_FG_e(VALUE obj, VALUE eta, VALUE x, VALUE L_F, VALUE k) { gsl_sf_result *F, *Fp, *G, *Gp; VALUE vF, vFp, vG, vGp; double exp_G, exp_F; int status; Need_Float(eta); Need_Float(x); Need_Float(L_F); CHECK_FIXNUM(k); vF = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, F); vFp = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, Fp); vG = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, G); vGp = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, Gp); status = gsl_sf_coulomb_wave_FG_e(NUM2DBL(eta), NUM2DBL(x), NUM2DBL(L_F), FIX2INT(k), F, Fp, G, Gp, &exp_F, &exp_G); return rb_ary_new3(7, vF, vFp, vG, vGp, rb_float_new(exp_F), rb_float_new(exp_G), INT2FIX(status)); } static VALUE rb_gsl_sf_coulomb_wave_F_array(VALUE obj, VALUE Lmin, VALUE kmax, VALUE eta, VALUE x) { double F_exponent; int status; size_t size; gsl_vector *v = NULL; CHECK_FIXNUM(kmax); Need_Float(Lmin); Need_Float(eta); Need_Float(x); size = FIX2INT(kmax); v = gsl_vector_alloc(size); status = gsl_sf_coulomb_wave_F_array(NUM2DBL(Lmin), size, NUM2DBL(eta), NUM2DBL(x), v->data, &F_exponent); return rb_ary_new3(3, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v), rb_float_new(F_exponent), INT2FIX(status)); } static VALUE rb_gsl_sf_coulomb_wave_FG_array(VALUE obj, VALUE Lmin, VALUE kmax, VALUE eta, VALUE x) { double F_exponent, G_exponent; int status; size_t size; gsl_vector *vf = NULL, *vg = NULL; VALUE fary, gary; CHECK_FIXNUM(kmax); Need_Float(Lmin); Need_Float(eta); Need_Float(x); size = FIX2INT(kmax); vf = gsl_vector_alloc(size); vg = gsl_vector_alloc(size); status = gsl_sf_coulomb_wave_FG_array(NUM2DBL(Lmin), size, NUM2DBL(eta), NUM2DBL(x), vf->data, vg->data, &F_exponent, &G_exponent); fary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vf); gary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vf); return rb_ary_new3(5, fary, gary, rb_float_new(F_exponent), rb_float_new(G_exponent), INT2FIX(status)); } static VALUE rb_gsl_sf_coulomb_wave_FGp_array(VALUE obj, VALUE Lmin, VALUE kmax, VALUE eta, VALUE x) { double F_exponent, G_exponent; int status; size_t size; gsl_vector *vf = NULL, *vg = NULL, *vfp = NULL, *vgp = NULL; VALUE fary, gary, fpary, gpary; CHECK_FIXNUM(kmax); Need_Float(Lmin); Need_Float(eta); Need_Float(x); size = FIX2INT(kmax); vf = gsl_vector_alloc(size); vfp = gsl_vector_alloc(size); vg = gsl_vector_alloc(size); vgp = gsl_vector_alloc(size); status = gsl_sf_coulomb_wave_FGp_array(NUM2DBL(Lmin), size, NUM2DBL(eta), NUM2DBL(x), vf->data, vfp->data, vg->data, vgp->data, &F_exponent, &G_exponent); fary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vf); fpary =Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vfp); gary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vg); gpary =Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vgp); return rb_ary_new3(7, fary, fpary, gary, gpary, rb_float_new(F_exponent), rb_float_new(G_exponent), INT2FIX(status)); } static VALUE rb_gsl_sf_coulomb_wave_sphF_array(VALUE obj, VALUE Lmin, VALUE kmax, VALUE eta, VALUE x) { int status; size_t size; gsl_vector *v = NULL, *v2 = NULL; CHECK_FIXNUM(kmax); Need_Float(Lmin); Need_Float(eta); Need_Float(x); size = FIX2INT(kmax); v = gsl_vector_alloc(size); v2 = gsl_vector_alloc(size); status = gsl_sf_coulomb_wave_sphF_array(NUM2DBL(Lmin), size, NUM2DBL(eta), NUM2DBL(x), v->data, v2->data); return rb_ary_new3(3, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v), Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2), INT2FIX(status)); } static VALUE rb_gsl_sf_coulomb_CL_e(VALUE obj, VALUE L, VALUE eta) { return rb_gsl_sf_eval_e_double2(gsl_sf_coulomb_CL_e, L, eta); } static VALUE rb_gsl_sf_coulomb_CL_array(VALUE obj, VALUE Lmin, VALUE kmax, VALUE eta) { gsl_vector *v = NULL; size_t size; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(kmax); Need_Float(Lmin); Need_Float(eta); size = FIX2INT(kmax); v = gsl_vector_alloc(size); /*status =*/ gsl_sf_coulomb_CL_array(NUM2DBL(Lmin), size, NUM2DBL(eta), v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } void Init_gsl_sf_coulomb(VALUE module) { VALUE mgsl_sf_coulomb; rb_define_module_function(module, "hydrogenicR_1", rb_gsl_sf_hydrogenicR_1, 2); rb_define_module_function(module, "hydrogenicR_1_e", rb_gsl_sf_hydrogenicR_1_e, 2); rb_define_module_function(module, "hydrogenicR", rb_gsl_sf_hydrogenicR, 4); rb_define_module_function(module, "hydrogenicR_e", rb_gsl_sf_hydrogenicR_e, 4); rb_define_module_function(module, "coulomb_wave_FG_e", rb_gsl_sf_coulomb_wave_FG_e, 4); rb_define_module_function(module, "coulomb_wave_F_array", rb_gsl_sf_coulomb_wave_F_array, 4); rb_define_module_function(module, "coulomb_wave_FG_array", rb_gsl_sf_coulomb_wave_FG_array, 4); rb_define_module_function(module, "coulomb_wave_FGp_array", rb_gsl_sf_coulomb_wave_FGp_array, 4); rb_define_module_function(module, "coulomb_wave_sphF_array ", rb_gsl_sf_coulomb_wave_sphF_array, 4); rb_define_module_function(module, "coulomb_CL_e", rb_gsl_sf_coulomb_CL_e, 2); rb_define_module_function(module, "coulomb_CL_array", rb_gsl_sf_coulomb_CL_array, 3); mgsl_sf_coulomb = rb_define_module_under(module, "Coulomb"); rb_define_module_function(mgsl_sf_coulomb, "hydrogenicR_1", rb_gsl_sf_hydrogenicR_1, 2); rb_define_module_function(mgsl_sf_coulomb, "hydrogenicR_1_e", rb_gsl_sf_hydrogenicR_1_e, 2); rb_define_module_function(mgsl_sf_coulomb, "hydrogenicR", rb_gsl_sf_hydrogenicR, 4); rb_define_module_function(mgsl_sf_coulomb, "hydrogenicR_e", rb_gsl_sf_hydrogenicR_e, 4); rb_define_module_function(mgsl_sf_coulomb, "wave_FG_e", rb_gsl_sf_coulomb_wave_FG_e, 4); rb_define_module_function(mgsl_sf_coulomb, "wave_F_array", rb_gsl_sf_coulomb_wave_F_array, 4); rb_define_module_function(mgsl_sf_coulomb, "wave_FG_array", rb_gsl_sf_coulomb_wave_FG_array, 4); rb_define_module_function(mgsl_sf_coulomb, "wave_FGp_array", rb_gsl_sf_coulomb_wave_FGp_array, 4); rb_define_module_function(mgsl_sf_coulomb, "wave_sphF_array ", rb_gsl_sf_coulomb_wave_sphF_array, 4); rb_define_module_function(mgsl_sf_coulomb, "CL_e", rb_gsl_sf_coulomb_CL_e, 2); rb_define_module_function(mgsl_sf_coulomb, "CL_array", rb_gsl_sf_coulomb_CL_array, 3); } gsl-1.15.3/ext/sf_coupling.c0000644000175000017500000001205612220252463015222 0ustar boutilboutil/* sf_coupling.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_coupling_3j(VALUE obj, VALUE two_ja, VALUE two_jb, VALUE two_jc, VALUE two_ma, VALUE two_mb, VALUE two_mc) { CHECK_FIXNUM(two_ja); CHECK_FIXNUM(two_jb); CHECK_FIXNUM(two_jc); CHECK_FIXNUM(two_ma); CHECK_FIXNUM(two_mb); CHECK_FIXNUM(two_mc); return rb_float_new(gsl_sf_coupling_3j(FIX2INT(two_ja), FIX2INT(two_jb), FIX2INT(two_jc), FIX2INT(two_ma), FIX2INT(two_mb), FIX2INT(two_mc))); } static VALUE rb_gsl_sf_coupling_3j_e(VALUE obj, VALUE two_ja, VALUE two_jb, VALUE two_jc, VALUE two_ma, VALUE two_mb, VALUE two_mc) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(two_ja); CHECK_FIXNUM(two_jb); CHECK_FIXNUM(two_jc); CHECK_FIXNUM(two_ma); CHECK_FIXNUM(two_mb); CHECK_FIXNUM(two_mc); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_coupling_3j_e(FIX2INT(two_ja), FIX2INT(two_jb), FIX2INT(two_jc), FIX2INT(two_ma), FIX2INT(two_mb), FIX2INT(two_mc), rslt); return v; } static VALUE rb_gsl_sf_coupling_6j(VALUE obj, VALUE two_ja, VALUE two_jb, VALUE two_jc, VALUE two_jd, VALUE two_je, VALUE two_jf) { CHECK_FIXNUM(two_ja); CHECK_FIXNUM(two_jb); CHECK_FIXNUM(two_jc); CHECK_FIXNUM(two_jd); CHECK_FIXNUM(two_je); CHECK_FIXNUM(two_jf); return rb_float_new(gsl_sf_coupling_6j(FIX2INT(two_ja), FIX2INT(two_jb), FIX2INT(two_jc), FIX2INT(two_jd), FIX2INT(two_je), FIX2INT(two_jf))); } static VALUE rb_gsl_sf_coupling_6j_e(VALUE obj, VALUE two_ja, VALUE two_jb, VALUE two_jc, VALUE two_jd, VALUE two_je, VALUE two_jf) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(two_ja); CHECK_FIXNUM(two_jb); CHECK_FIXNUM(two_jc); CHECK_FIXNUM(two_jd); CHECK_FIXNUM(two_je); CHECK_FIXNUM(two_jf); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_coupling_6j_e(FIX2INT(two_ja), FIX2INT(two_jb), FIX2INT(two_jc), FIX2INT(two_jd), FIX2INT(two_je), FIX2INT(two_jf), rslt); return v; } static VALUE rb_gsl_sf_coupling_9j(VALUE obj, VALUE two_ja, VALUE two_jb, VALUE two_jc, VALUE two_jd, VALUE two_je, VALUE two_jf, VALUE two_jg, VALUE two_jh, VALUE two_ji) { CHECK_FIXNUM(two_ja); CHECK_FIXNUM(two_jb); CHECK_FIXNUM(two_jc); CHECK_FIXNUM(two_jd); CHECK_FIXNUM(two_je); CHECK_FIXNUM(two_jf); CHECK_FIXNUM(two_jg); CHECK_FIXNUM(two_jh); CHECK_FIXNUM(two_ji); return rb_float_new(gsl_sf_coupling_9j(FIX2INT(two_ja), FIX2INT(two_jb), FIX2INT(two_jc), FIX2INT(two_jd), FIX2INT(two_je), FIX2INT(two_jf), FIX2INT(two_jg), FIX2INT(two_jh), FIX2INT(two_ji))); } static VALUE rb_gsl_sf_coupling_9j_e(VALUE obj, VALUE two_ja, VALUE two_jb, VALUE two_jc, VALUE two_jd, VALUE two_je, VALUE two_jf, VALUE two_jg, VALUE two_jh, VALUE two_ji) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; CHECK_FIXNUM(two_ja); CHECK_FIXNUM(two_jb); CHECK_FIXNUM(two_jc); CHECK_FIXNUM(two_jd); CHECK_FIXNUM(two_je); CHECK_FIXNUM(two_jf); CHECK_FIXNUM(two_jg); CHECK_FIXNUM(two_jh); CHECK_FIXNUM(two_ji); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_coupling_9j_e(FIX2INT(two_ja), FIX2INT(two_jb), FIX2INT(two_jc), FIX2INT(two_jd), FIX2INT(two_je), FIX2INT(two_jf), FIX2INT(two_jg), FIX2INT(two_jh), FIX2INT(two_ji), rslt); return v; } void Init_gsl_sf_coupling(VALUE module) { VALUE mgsl_sf_coupling; rb_define_module_function(module, "coupling_3j", rb_gsl_sf_coupling_3j, 6); rb_define_module_function(module, "coupling_3j_e", rb_gsl_sf_coupling_3j_e, 6); rb_define_module_function(module, "coupling_6j", rb_gsl_sf_coupling_6j, 6); rb_define_module_function(module, "coupling_6j_e", rb_gsl_sf_coupling_6j_e, 6); rb_define_module_function(module, "coupling_9j", rb_gsl_sf_coupling_9j, 9); rb_define_module_function(module, "coupling_9j_e", rb_gsl_sf_coupling_9j_e, 9); mgsl_sf_coupling = rb_define_module_under(module, "Coupling"); rb_define_module_function(mgsl_sf_coupling, "3j", rb_gsl_sf_coupling_3j, 6); rb_define_module_function(mgsl_sf_coupling, "3j_e", rb_gsl_sf_coupling_3j_e, 6); rb_define_module_function(mgsl_sf_coupling, "6j", rb_gsl_sf_coupling_6j, 6); rb_define_module_function(mgsl_sf_coupling, "6j_e", rb_gsl_sf_coupling_6j_e, 6); rb_define_module_function(mgsl_sf_coupling, "9j", rb_gsl_sf_coupling_9j, 9); rb_define_module_function(mgsl_sf_coupling, "9j_e", rb_gsl_sf_coupling_9j_e, 9); } gsl-1.15.3/ext/multimin_fsdf.c0000644000175000017500000001214612220252463015552 0ustar boutilboutil#ifdef HAVE_GSL_GSL_MULTIMIN_FSDF_H #include "rb_gsl.h" #include "gsl/gsl_multimin_fsdf.h" static VALUE cfsdf; #ifndef CHECK_MULTIMIN_FUNCTION_FSDF #define CHECK_MULTIMIN_FUNCTION_FSDF(x) if(CLASS_OF(x)!=cfsdf)\ rb_raise(rb_eTypeError,\ "wrong argument type %s (GSL::MultiMin::Function_fsdf expected)",\ rb_class2name(CLASS_OF(x))); #endif extern VALUE cgsl_multimin_function_fdf; static const gsl_multimin_fsdfminimizer_type* get_fsdfminimizer_type(VALUE t) { char name[64]; switch (TYPE(t)) { case T_STRING: strcpy(name, STR2CSTR(t)); if (strcmp(name, "bundle") == 0 || strcmp(name, "bundle_method") == 0) return gsl_multimin_fsdfminimizer_bundle_method; else rb_raise(rb_eTypeError, "%s: unknown minimizer type", name); break; default: rb_raise(rb_eTypeError, "type is given by a String or a Fixnum"); break; } } static VALUE rb_gsl_fsdfminimizer_alloc(VALUE klass, VALUE t, VALUE n) { gsl_multimin_fsdfminimizer *gmf = NULL; const gsl_multimin_fsdfminimizer_type *T; T = get_fsdfminimizer_type(t); gmf = gsl_multimin_fsdfminimizer_alloc(T, FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_multimin_fsdfminimizer_free, gmf); } static VALUE rb_gsl_fsdfminimizer_set(VALUE obj, VALUE ff, VALUE xx, VALUE ss) { gsl_multimin_fsdfminimizer *gmf = NULL; gsl_multimin_function_fsdf *F = NULL; gsl_vector *x; size_t bundle_size; int status; CHECK_MULTIMIN_FUNCTION_FSDF(ff); Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); Data_Get_Struct(ff, gsl_multimin_function_fsdf, F); Data_Get_Vector(xx, x); bundle_size = (size_t) FIX2INT(ss); status = gsl_multimin_fsdfminimizer_set(gmf, F, x, bundle_size); return INT2FIX(status); } static VALUE rb_gsl_fsdfminimizer_name(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); return rb_str_new2(gsl_multimin_fsdfminimizer_name(gmf)); } static VALUE rb_gsl_fsdfminimizer_iterate(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); return INT2FIX(gsl_multimin_fsdfminimizer_iterate(gmf)); } static VALUE rb_gsl_fsdfminimizer_x(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; gsl_vector *x = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); x = gsl_multimin_fsdfminimizer_x(gmf); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, x); } static VALUE rb_gsl_fsdfminimizer_subgradient(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; gsl_vector *gradient = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); gradient = gsl_multimin_fsdfminimizer_subgradient(gmf); return Data_Wrap_Struct(cgsl_vector_view_ro, 0, NULL, gradient); } static VALUE rb_gsl_fsdfminimizer_minimum(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; double min; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); min = gsl_multimin_fsdfminimizer_minimum(gmf); return rb_float_new(min); } static VALUE rb_gsl_fsdfminimizer_f(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); return rb_float_new(gmf->f); } static VALUE rb_gsl_fsdfminimizer_restart(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); return INT2FIX(gsl_multimin_fsdfminimizer_restart(gmf)); } static VALUE rb_gsl_fsdfminimizer_test_gradient(VALUE obj, VALUE ea) { gsl_multimin_fsdfminimizer *gmf = NULL; gsl_vector *g = NULL; Need_Float(ea); Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); g = gsl_multimin_fsdfminimizer_subgradient(gmf); return INT2FIX(gsl_multimin_test_gradient(g, NUM2DBL(ea))); } static VALUE rb_gsl_fsdfminimizer_test_convergence(VALUE obj, VALUE eps) { gsl_multimin_fsdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); return INT2FIX(gsl_multimin_test_convergence(gmf, NUM2DBL(eps))); } static VALUE rb_gsl_fsdfminimizer_eps(VALUE obj) { gsl_multimin_fsdfminimizer *gmf = NULL; Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf); return rb_float_new(gmf->eps); } void Init_multimin_fsdf(VALUE module) { VALUE cmin; cmin = rb_define_class_under(module, "FsdfMinimizer", cGSL_Object); cfsdf = rb_define_class_under(module, "Function_fsdf", cgsl_multimin_function_fdf); rb_define_singleton_method(cmin, "alloc", rb_gsl_fsdfminimizer_alloc, 2); rb_define_method(cmin, "set", rb_gsl_fsdfminimizer_set, 3); rb_define_method(cmin, "name", rb_gsl_fsdfminimizer_name, 0); rb_define_method(cmin, "iterate", rb_gsl_fsdfminimizer_iterate, 0); rb_define_method(cmin, "x", rb_gsl_fsdfminimizer_x, 0); rb_define_method(cmin, "f", rb_gsl_fsdfminimizer_f, 0); rb_define_method(cmin, "subgradient", rb_gsl_fsdfminimizer_subgradient, 0); rb_define_method(cmin, "minimum", rb_gsl_fsdfminimizer_minimum, 0); rb_define_method(cmin, "restart", rb_gsl_fsdfminimizer_restart, 0); rb_define_method(cmin, "test_gradient", rb_gsl_fsdfminimizer_test_gradient, 1); rb_define_method(cmin, "test_convergence", rb_gsl_fsdfminimizer_test_convergence, 1); rb_define_method(cmin, "eps", rb_gsl_fsdfminimizer_eps, 0); } #endif gsl-1.15.3/ext/matrix_complex.c0000644000175000017500000016145612220252463015756 0ustar boutilboutil/* matrix_complex.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_complex.h" enum { GSL_MATRIX_COMPLEX_ADD, GSL_MATRIX_COMPLEX_SUB, GSL_MATRIX_COMPLEX_MUL, GSL_MATRIX_COMPLEX_DIV, }; // From complex.c gsl_complex rb_gsl_obj_to_gsl_complex(VALUE obj, gsl_complex *z); // From ext/vector_source.c void get_range_beg_en_n(VALUE range, double *beg, double *en, size_t *n, int *step); // From ext/matrix_source.c void parse_submatrix_args(int argc, VALUE *argv, size_t size1, size_t size2, size_t *i, size_t *j, size_t *n1, size_t *n2); static VALUE rb_gsl_matrix_complex_arithmetics(int flag, VALUE obj, VALUE bb) { gsl_matrix *m = NULL; gsl_matrix_complex *cm = NULL, *cmb = NULL, *cmnew = NULL; gsl_complex *c = NULL, z; gsl_vector *v = NULL; gsl_vector_complex *cv = NULL, *cvnew = NULL, *cvb = NULL; Data_Get_Struct(obj, gsl_matrix_complex, cm); switch (TYPE(bb)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: z = gsl_complex_rect(NUM2DBL(bb), 0.0); switch (flag) { case GSL_MATRIX_COMPLEX_ADD: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_add_constant(cmnew, z); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; case GSL_MATRIX_COMPLEX_SUB: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_add_constant(cmnew, gsl_complex_negative(z)); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; case GSL_MATRIX_COMPLEX_MUL: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_scale(cmnew, z); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; case GSL_MATRIX_COMPLEX_DIV: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_scale(cmnew, gsl_complex_inverse(z)); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } break; default: if (rb_obj_is_kind_of(bb, cgsl_matrix_complex)) { Data_Get_Struct(bb, gsl_matrix_complex, cmb); switch (flag) { case GSL_MATRIX_COMPLEX_ADD: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_add(cmnew, cmb); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; case GSL_MATRIX_COMPLEX_SUB: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_sub(cmnew,cmb); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; case GSL_MATRIX_COMPLEX_MUL: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_mul_elements(cmnew, cmb); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; case GSL_MATRIX_COMPLEX_DIV: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_div_elements(cmnew, cmb); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } } else if (rb_obj_is_kind_of(bb, cgsl_matrix)) { Data_Get_Struct(bb, gsl_matrix, m); cmb = matrix_to_complex(m); cmnew = make_matrix_complex_clone(cm); switch (flag) { case GSL_MATRIX_COMPLEX_ADD: gsl_matrix_complex_add(cmnew, cmb); break; case GSL_MATRIX_COMPLEX_SUB: gsl_matrix_complex_sub(cmnew,cmb); break; case GSL_MATRIX_COMPLEX_MUL: gsl_matrix_complex_mul_elements(cmnew, cmb); break; case GSL_MATRIX_COMPLEX_DIV: gsl_matrix_complex_div_elements(cmnew, cmb); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); } else if (rb_obj_is_kind_of(bb, cgsl_complex)) { Data_Get_Struct(bb, gsl_complex, c); switch (flag) { case GSL_MATRIX_COMPLEX_ADD: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_add_constant(cmnew, *c); break; case GSL_MATRIX_COMPLEX_SUB: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_add_constant(cmnew, gsl_complex_negative(*c)); break; case GSL_MATRIX_COMPLEX_MUL: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_scale(cmnew, *c); break; case GSL_MATRIX_COMPLEX_DIV: cmnew = make_matrix_complex_clone(cm); gsl_matrix_complex_scale(cmnew, gsl_complex_inverse(*c)); break; default: rb_raise(rb_eRuntimeError, "operation not defined"); break; } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); } else if (rb_obj_is_kind_of(bb, cgsl_vector)) { Data_Get_Struct(bb, gsl_vector, v); switch (flag) { case GSL_MATRIX_COMPLEX_MUL: cvb = vector_to_complex(v); cvnew = gsl_vector_complex_alloc(v->size); if (cvnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_matrix_complex_mul_vector(cvnew, cm, cvb); gsl_vector_complex_free(cvb); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, cvnew); break; default: rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix_Complex", rb_class2name(CLASS_OF(bb))); break; } } else if (rb_obj_is_kind_of(bb, cgsl_vector_complex)) { if (!VECTOR_COMPLEX_COL_P(bb)) rb_raise(rb_eTypeError, "Operation is not defined with %s (Vector::Complex::Col expected)", rb_class2name(CLASS_OF(bb))); Data_Get_Struct(bb, gsl_vector_complex, cv); switch (flag) { case GSL_MATRIX_COMPLEX_MUL: cvnew = gsl_vector_complex_alloc(cv->size); if (cvnew == NULL) rb_raise(rb_eNoMemError, "gsl_vector_complex_alloc failed"); gsl_matrix_complex_mul_vector(cvnew, cm, cv); return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, cvnew);; default: rb_raise(rb_eRuntimeError, "operation is not defined %s and Matrix_Complex", rb_class2name(CLASS_OF(bb))); break; } } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(bb))); } } /* never reach here */ return Qnil; } static VALUE rb_gsl_matrix_complex_new(VALUE klass, VALUE s1, VALUE s2) { gsl_matrix_complex *m = NULL; CHECK_FIXNUM(s1); CHECK_FIXNUM(s2); m = gsl_matrix_complex_calloc(FIX2INT(s1), FIX2INT(s2)); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); return Data_Wrap_Struct(klass, 0, gsl_matrix_complex_free, m); } static VALUE rb_gsl_matrix_complex_eye(int argc, VALUE *argv, VALUE klass) { size_t n, i; gsl_matrix_complex *m = NULL; gsl_complex z, *pz = &z; switch (argc) { case 1: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); z = gsl_complex_rect(1.0, 0.0); break; case 2: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); switch (TYPE(argv[1])) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: z = gsl_complex_rect(NUM2DBL(argv[1]), 0.0); break; case T_ARRAY: // if (RARRAY(argv[1])->len < 2) rb_raise(rb_eArgError, "wrong argument"); if (RARRAY_LEN(argv[1]) < 2) rb_raise(rb_eArgError, "wrong argument"); z = gsl_complex_rect(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1))); break; default: if (rb_obj_is_kind_of(argv[1], cgsl_complex)) { Data_Get_Struct(argv[1], gsl_complex, pz); z = *pz; } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv[1]))); } break; } break; case 3: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); Need_Float(argv[1]); Need_Float(argv[2]); z = gsl_complex_rect(NUM2DBL(argv[1]), NUM2DBL(argv[2])); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1, 2, or 3)", argc); break; } m = gsl_matrix_complex_calloc(n, n); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); for (i = 0; i < n; i++) gsl_matrix_complex_set(m, i, i, z); return Data_Wrap_Struct(klass, 0, gsl_matrix_complex_free, m); } static VALUE rb_gsl_matrix_complex_identity(VALUE klass, VALUE nn) { size_t n, i; gsl_matrix_complex *m = NULL; gsl_complex z; CHECK_FIXNUM(nn); n = FIX2INT(nn); m = gsl_matrix_complex_calloc(n, n); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_calloc failed"); z = gsl_complex_rect(1.0, 0.0); for (i = 0; i < n; i++) gsl_matrix_complex_set(m, i, i, z); return Data_Wrap_Struct(klass, 0, gsl_matrix_complex_free, m); } static VALUE rb_gsl_matrix_complex_set_zero(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); gsl_matrix_complex_set_zero(m); return obj; } static VALUE rb_gsl_matrix_complex_set_identity(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); gsl_matrix_complex_set_identity(m); return obj; } static VALUE rb_gsl_matrix_complex_set_all(VALUE obj, VALUE s) { gsl_matrix_complex *m = NULL; gsl_complex c, *z = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); switch (TYPE(s)) { case T_FLOAT: case T_BIGNUM: case T_FIXNUM: c.dat[0] = NUM2DBL(s); c.dat[1] = 0.0; gsl_matrix_complex_set_all(m, c); break; case T_ARRAY: c.dat[0] = NUM2DBL(rb_ary_entry(s, 0)); c.dat[1] = NUM2DBL(rb_ary_entry(s, 1)); gsl_matrix_complex_set_all(m, c); break; default: if (rb_obj_is_kind_of(s, cgsl_complex)) { Data_Get_Struct(s, gsl_complex, z); gsl_matrix_complex_set_all(m, *z); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(s))); } break; } return obj; } void rb_gsl_vector_complex_set_subvector(int argc, VALUE *argv, gsl_vector_complex *v, VALUE other); static VALUE rb_gsl_matrix_complex_set(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mother; gsl_matrix_complex_view mv; gsl_vector_complex_view vv; gsl_complex tmp; VALUE other, row, row_set_argv[2]; int ii, ij, step; size_t i, j, k, n1, n2, nother; double beg, end; if(argc < 1 || argc > 5) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1-5)", argc); } Data_Get_Struct(obj, gsl_matrix_complex, m); other = argv[argc-1]; if(argc == 1) { // m[] = x gsl_matrix_complex_set_all(m, rb_gsl_obj_to_gsl_complex(other, NULL)); } else if(argc == 3 && TYPE(argv[0]) == T_FIXNUM && TYPE(argv[1]) == T_FIXNUM) { // m[i,j] = x ii = FIX2INT(argv[0]); ij = FIX2INT(argv[1]); if(ii < 0) ii += m->size1; if(ij < 0) ij += m->size2; gsl_matrix_complex_set(m, (size_t)ii, (size_t)ij, rb_gsl_obj_to_gsl_complex(other, NULL)); } else if(TYPE(argv[0]) == T_ARRAY) { // m.set(row0...) row_set_argv[0] = INT2FIX(0); row_set_argv[1] = INT2FIX(m->size2); for(k = 0; k < argc && k < m->size1; k++) { vv = gsl_matrix_complex_row(m, k); rb_gsl_vector_complex_set_subvector(2, row_set_argv, &vv.vector, argv[k]); } } else { // x -> assignment to m.submatrix(i...) parse_submatrix_args(argc-1, argv, m->size1, m->size2, &i, &j, &n1, &n2); if(n1 == 0) n1 = 1; if(n2 == 0) n2 = 1; mv = gsl_matrix_complex_submatrix(m, i, j, n1, n2); if(rb_obj_is_kind_of(other, cgsl_matrix_complex)) { // m[...] = m_other Data_Get_Struct(other, gsl_matrix_complex, mother); if(n1 * n2 != mother->size1 * mother->size2) { rb_raise(rb_eRangeError, "sizes do not match (%d x %d != %d x %d)", (int) n1, (int) n2, (int) mother->size1, (int) mother->size2); } // TODO Change to gsl_matrix_memmove if/when GSL has such a function // because gsl_matrix_memcpy does not handle overlapping regions (e.g. // Views) well. gsl_matrix_complex_memcpy(&mv.matrix, mother); } else if(rb_obj_is_kind_of(other, rb_cArray)) { row_set_argv[0] = INT2FIX(0); row_set_argv[1] = INT2FIX(n2); if(n1 == 1) { // m[...] = [col0, ...] # single row vv = gsl_matrix_complex_row(&mv.matrix, 0); rb_gsl_vector_complex_set_subvector(2, row_set_argv, &vv.vector, other); } else { // m[...] = [[row0], [row1], ...] # multiple rows if(n1 != RARRAY_LEN(other)) { rb_raise(rb_eRangeError, "row counts do not match (%d != %d)", (int) n1, (int) RARRAY_LEN(other)); } for(k = 0; k < n1; k++) { vv = gsl_matrix_complex_row(&mv.matrix, k); row = rb_ary_entry(other, k); rb_gsl_vector_complex_set_subvector(2, row_set_argv, &vv.vector, row); } } } else if(rb_obj_is_kind_of(other, rb_cRange)) { // m[...] = beg..end get_range_beg_en_n(other, &beg, &end, ¬her, &step); if(n1 * n2 != nother) { rb_raise(rb_eRangeError, "sizes do not match (%d x %d != %d)", (int) n1, (int) n2, (int) nother); } tmp = gsl_complex_rect(beg, 0.0); for(k = 0; k < nother; k++) { gsl_matrix_complex_set(&mv.matrix, k / n2, k % n2, tmp); GSL_SET_REAL(&tmp, GSL_REAL(tmp) + step); } } else { // m[...] = x gsl_matrix_complex_set_all(&mv.matrix, rb_gsl_obj_to_gsl_complex(other, NULL)); } } return obj; } static VALUE rb_gsl_matrix_complex_set_row(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; size_t i, k; gsl_complex z, *pz = &z; if (argc < 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 2)", argc); CHECK_FIXNUM(argv[0]); Data_Get_Struct(obj, gsl_matrix_complex, A); i = FIX2INT(argv[0]); for (k = 1; k < argc; k++) { if (k-1 >= A->size1) break; switch (TYPE(argv[k])) { case T_ARRAY: z = ary2complex(argv[k]); break; default: CHECK_COMPLEX(argv[k]); Data_Get_Struct(argv[k], gsl_complex, pz); z = *pz; break; } gsl_matrix_complex_set(A, i, k-1, z); } return obj; } static VALUE rb_gsl_matrix_complex_set_col(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL; int j, k; gsl_complex z, *pz = &z; if (argc < 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 2)", argc); CHECK_FIXNUM(argv[0]); Data_Get_Struct(obj, gsl_matrix_complex, A); j = FIX2INT(argv[0]); for (k = 1; k < argc; k++) { if (k-1 >= A->size2) break; switch (TYPE(argv[k])) { case T_ARRAY: z = ary2complex(argv[k]); break; default: CHECK_COMPLEX(argv[k]); Data_Get_Struct(argv[k], gsl_complex, pz); z = *pz; break; } gsl_matrix_complex_set(A, k-1, j, z); } return obj; } static VALUE rb_gsl_matrix_complex_submatrix(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_matrix_complex_get(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL; gsl_complex *c = NULL; VALUE retval; int ii, ij; if(argc == 2 && TYPE(argv[0]) == T_FIXNUM && TYPE(argv[1]) == T_FIXNUM) { // m[i,j] Data_Get_Struct(obj, gsl_matrix_complex, m); ii = FIX2INT(argv[0]); ij = FIX2INT(argv[1]); if(ii < 0) ii += m->size1; if(ij < 0) ij += m->size2; c = ALLOC(gsl_complex); *c = gsl_matrix_complex_get(m, (size_t)ii, (size_t)ij); retval = Data_Wrap_Struct(cgsl_complex, 0, free, c); } else if(argc == 1 && TYPE(argv[0]) == T_FIXNUM) { // m[i] Data_Get_Struct(obj, gsl_matrix_complex, m); ii = FIX2INT(argv[0]); if(ii < 0) ii += m->size1 * m->size2; c = ALLOC(gsl_complex); *c = gsl_matrix_complex_get(m, (size_t)(ii / m->size2), (size_t)(ii % m->size2)); retval = Data_Wrap_Struct(cgsl_complex, 0, free, c); } else if(argc == 1 && TYPE(argv[0]) == T_ARRAY) { // m[[i,j]], to have parity with Real Matrix types if(RARRAY_LEN(argv[0]) == 2) { Data_Get_Struct(obj, gsl_matrix_complex, m); ii = FIX2INT(RARRAY_PTR(argv[0])[0]); ij = FIX2INT(RARRAY_PTR(argv[0])[1]); if(ii < 0) ii += m->size1; if(ij < 0) ij += m->size2; c = ALLOC(gsl_complex); *c = gsl_matrix_complex_get(m, (size_t)ii, (size_t)ij); retval = Data_Wrap_Struct(cgsl_complex, 0, free, c); } else { rb_raise(rb_eArgError, "Array index must have length 2, not %d", (int) RARRAY_LEN(argv[0])); } } else { retval = rb_gsl_matrix_complex_submatrix(argc, argv, obj); } return retval; } static void rb_gsl_matrix_complex_collect_native(gsl_matrix_complex *src, gsl_matrix_complex *dst) { VALUE vz; gsl_complex * zp; size_t i, j; for (i = 0; i < src->size1; i++) { for (j = 0; j < src->size2; j++) { vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, zp); *zp = gsl_matrix_complex_get(src, i, j); vz = rb_yield(vz); CHECK_COMPLEX(vz); Data_Get_Struct(vz, gsl_complex, zp); gsl_matrix_complex_set(dst, i, j, *zp); } } } static VALUE rb_gsl_matrix_complex_collect(VALUE obj) { gsl_matrix_complex *m = NULL, *mnew; Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); rb_gsl_matrix_complex_collect_native(m, mnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } static VALUE rb_gsl_matrix_complex_collect_bang(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); rb_gsl_matrix_complex_collect_native(m, m); return obj; } static VALUE rb_gsl_matrix_complex_to_a(VALUE obj) { gsl_matrix_complex *m; gsl_complex *c; VALUE ma, ra; size_t i, j; Data_Get_Struct(obj, gsl_matrix_complex, m); ma = rb_ary_new2(m->size1); for(i=0; i < m->size1; i++) { ra = rb_ary_new2(m->size2); rb_ary_store(ma, i, ra); for(j=0; j < m->size2; j++) { c = ALLOC(gsl_complex); *c = gsl_matrix_complex_get(m, i, j); rb_ary_store(ra, j, Data_Wrap_Struct(cgsl_complex, 0, free, c)); } } return ma; } static VALUE rb_gsl_matrix_complex_ptr(VALUE obj, VALUE i, VALUE j) { gsl_matrix_complex *m = NULL; gsl_complex *c = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); c = gsl_matrix_complex_ptr(m, FIX2INT(i), FIX2INT(j)); return Data_Wrap_Struct(cgsl_complex, 0, NULL, c); } static VALUE rb_gsl_matrix_complex_printf(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *h = NULL; int status; Data_Get_Struct(obj, gsl_matrix_complex, h); if (argc == 1) { Check_Type(argv[0], T_STRING); status = gsl_matrix_complex_fprintf(stdout, h, STR2CSTR(argv[0])); } else { status = gsl_matrix_complex_fprintf(stdout, h, "%g"); } return INT2FIX(status); } static VALUE rb_gsl_matrix_complex_print(VALUE obj) { gsl_matrix_complex *h = NULL; gsl_complex *z = NULL; size_t i, j; Data_Get_Struct(obj, gsl_matrix_complex, h); printf("[ "); for (i = 0; i < h->size1; i++) { if (i != 0) printf(" "); for (j = 0; j < h->size2; j++) { z = gsl_matrix_complex_ptr(h, i, j); printf("[%4.3e %4.3e] ", GSL_REAL(*z), GSL_IMAG(*z)); } if (i != h->size1 -1) printf("\n"); else printf("]\n"); } return obj; } static VALUE rb_gsl_matrix_complex_to_s(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL; char buf[64]; size_t i, j; VALUE str; gsl_complex z; int max_rows = 4; int max_cols = 4; switch(argc){ case 2: max_cols = NUM2INT(argv[1]); case 1: max_rows = NUM2INT(argv[0]); case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0, 1, or 2)", argc); } Data_Get_Struct(obj, gsl_matrix_complex, m); if (m->size1 == 0 && m->size2 == 0) return rb_str_new2("[ ]"); str = rb_str_new2("[ "); for (i = 0; i < m->size1; i++) { if (i != 0) { rb_str_cat(str, "\n ", 3); } for (j = 0; j < m->size2; j++) { z = gsl_matrix_complex_get(m, i, j); sprintf(buf, "%s[ %4.3e %4.3e ]", (j==0) ? "" : " ", GSL_REAL(z), GSL_IMAG(z)); rb_str_cat(str, buf, strlen(buf)); // if too many cols if (j >= max_cols-1 && j != m->size2-1) { rb_str_cat(str, " ...", 4); break; } } // if too many rows if (i >= max_rows-1 && i != m->size1-1) { rb_str_cat(str, "\n ...", 6); break; } } rb_str_cat(str, " ]", 2); return str; } static VALUE rb_gsl_matrix_complex_inspect(int argc, VALUE *argv, VALUE obj) { VALUE str; char buf[128]; gsl_matrix_complex *m; Data_Get_Struct(obj, gsl_matrix_complex, m); sprintf(buf, "#<%s[%lu,%lu]:%#lx>\n", rb_class2name(CLASS_OF(obj)), m->size1, m->size2, NUM2ULONG(rb_obj_id(obj))); str = rb_str_new2(buf); return rb_str_concat(str, rb_gsl_matrix_complex_to_s(argc, argv, obj)); } static VALUE rb_gsl_matrix_complex_fwrite(VALUE obj, VALUE io) { gsl_matrix_complex *h = NULL; FILE *fp = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_matrix_complex, h); fp = rb_gsl_open_writefile(io, &flag); status = gsl_matrix_complex_fwrite(fp, h); if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_matrix_complex_fread(VALUE obj, VALUE io) { gsl_matrix_complex *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_matrix_complex, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_matrix_complex_fread(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } static VALUE rb_gsl_matrix_complex_fprintf(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *h = NULL; FILE *fp = NULL; int status, flag = 0; if (argc != 1 && argc != 2) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); } Data_Get_Struct(obj, gsl_matrix_complex, h); fp = rb_gsl_open_writefile(argv[0], &flag); if (argc == 2) { Check_Type(argv[1], T_STRING); status = gsl_matrix_complex_fprintf(fp, h, STR2CSTR(argv[1])); } else { status = gsl_matrix_complex_fprintf(fp, h, "%g"); } if (flag == 1) fclose(fp); return INT2FIX(status); } static VALUE rb_gsl_matrix_complex_fscanf(VALUE obj, VALUE io) { gsl_matrix_complex *h = NULL; FILE *f = NULL; int status, flag = 0; Data_Get_Struct(obj, gsl_matrix_complex, h); f = rb_gsl_open_readfile(io, &flag); status = gsl_matrix_complex_fscanf(f, h); if (flag == 1) fclose(f); return INT2FIX(status); } gsl_matrix_complex_view* gsl_matrix_complex_view_alloc() { gsl_matrix_complex_view *vv = NULL; vv = ALLOC(gsl_matrix_complex_view); if (vv == NULL) rb_raise(rb_eRuntimeError, "malloc failed"); return vv; } void gsl_matrix_complex_view_free(gsl_matrix_view * vv) { free((gsl_matrix_complex_view *) vv); } /* singleton */ static VALUE rb_gsl_matrix_complex_memcpy(VALUE obj, VALUE dst, VALUE src) { gsl_matrix_complex *m, *dest; CHECK_MATRIX_COMPLEX(dst); CHECK_MATRIX_COMPLEX(src); Data_Get_Struct(dst, gsl_matrix_complex, dest); Data_Get_Struct(src, gsl_matrix_complex, m); gsl_matrix_complex_memcpy(dest, m); return dst; } static VALUE rb_gsl_matrix_complex_clone(VALUE obj) { gsl_matrix_complex *m, *mnew = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); if (mnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_memcpy(mnew, m); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } static VALUE rb_gsl_matrix_complex_swap_rows(VALUE obj, VALUE i, VALUE j) { gsl_matrix_complex *m = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, gsl_matrix_complex, m); gsl_matrix_complex_swap_rows(m, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE rb_gsl_matrix_complex_swap_columns(VALUE obj, VALUE i, VALUE j) { gsl_matrix_complex *m = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, gsl_matrix_complex, m); gsl_matrix_complex_swap_columns(m, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE rb_gsl_matrix_complex_swap_rowcol(VALUE obj, VALUE i, VALUE j) { gsl_matrix_complex *m = NULL; CHECK_FIXNUM(i); CHECK_FIXNUM(j); Data_Get_Struct(obj, gsl_matrix_complex, m); gsl_matrix_complex_swap_rowcol(m, FIX2INT(i), FIX2INT(j)); return obj; } static VALUE rb_gsl_matrix_complex_transpose(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); gsl_matrix_complex_transpose(m); return obj; } static VALUE rb_gsl_matrix_complex_isnull(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); if (gsl_matrix_complex_isnull(m)) return Qtrue; else return Qfalse; } static VALUE rb_gsl_matrix_complex_add(VALUE obj, VALUE mmb) { return rb_gsl_matrix_complex_arithmetics(GSL_MATRIX_COMPLEX_ADD, obj, mmb); } static VALUE rb_gsl_matrix_complex_sub(VALUE obj, VALUE mmb) { return rb_gsl_matrix_complex_arithmetics(GSL_MATRIX_COMPLEX_SUB, obj, mmb); } static VALUE rb_gsl_matrix_complex_mul_elements(VALUE obj, VALUE mmb) { return rb_gsl_matrix_complex_arithmetics(GSL_MATRIX_COMPLEX_MUL, obj, mmb); } static VALUE rb_gsl_matrix_complex_div_elements(VALUE obj, VALUE mmb) { return rb_gsl_matrix_complex_arithmetics(GSL_MATRIX_COMPLEX_DIV, obj, mmb); } static VALUE rb_gsl_matrix_complex_scale(VALUE obj, VALUE s) { return rb_gsl_matrix_complex_arithmetics(GSL_MATRIX_COMPLEX_MUL, obj, s); } static VALUE rb_gsl_matrix_complex_scale_bang(VALUE obj, VALUE s) { gsl_matrix_complex *m; gsl_complex c, *z = &c; Data_Get_Struct(obj, gsl_matrix_complex, m); switch (TYPE(s)) { case T_FIXNUM: case T_FLOAT: GSL_SET_REAL(z, NUM2DBL(s)); GSL_SET_IMAG(z, 0.0); break; default: CHECK_COMPLEX(s); Data_Get_Struct(s, gsl_complex, z); break; } gsl_matrix_complex_scale(m, *z); return obj; } static VALUE rb_gsl_matrix_complex_mul(VALUE obj, VALUE mb) { gsl_matrix_complex *cm = NULL, *cmb = NULL, *cmnew = NULL; gsl_matrix *m = NULL; gsl_vector *v = NULL; gsl_vector_complex *vc = NULL, *vcnew = NULL; gsl_complex a, b; int flag = 0; if (COMPLEX_P(mb) || TYPE(mb) == T_FIXNUM || TYPE(mb) == T_FLOAT) return rb_gsl_matrix_complex_mul_elements(obj, mb); Data_Get_Struct(obj, gsl_matrix_complex, cm); if (VECTOR_P(mb)) { Data_Get_Struct(mb, gsl_vector, v); vc = vector_to_complex(v); vcnew = gsl_vector_complex_calloc(vc->size); a.dat[0] = 1.0; a.dat[1] = 0.0; b.dat[0] = 0.0; b.dat[1] = 0.0; gsl_blas_zgemv(CblasNoTrans, a, cm, vc, b, vcnew); gsl_vector_complex_free(vc); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vcnew); } if (VECTOR_COMPLEX_P(mb)) { Data_Get_Struct(mb, gsl_vector_complex, vc); vcnew = gsl_vector_complex_calloc(vc->size); a.dat[0] = 1.0; a.dat[1] = 0.0; b.dat[0] = 0.0; b.dat[1] = 0.0; gsl_blas_zgemv(CblasNoTrans, a, cm, vc, b, vcnew); return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vcnew); } if (MATRIX_P(mb)) { Data_Get_Struct(mb, gsl_matrix, m); cmb = matrix_to_complex(m); flag = 1; } else { CHECK_MATRIX_COMPLEX(mb); Data_Get_Struct(mb, gsl_matrix_complex, cmb); } cmnew = gsl_matrix_complex_alloc(cm->size1, cm->size2); if (cmnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_mul(cmnew, cm, cmb); if (flag == 1) gsl_matrix_complex_free(cmb); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); } static VALUE rb_gsl_matrix_complex_mul2(VALUE obj, VALUE mb) { gsl_matrix_complex *cm = NULL, *cmb = NULL, *cmnew = NULL; gsl_matrix *m = NULL; int flag = 0; Data_Get_Struct(obj, gsl_matrix_complex, cm); if (MATRIX_P(mb)) { Data_Get_Struct(mb, gsl_matrix, m); cmb = matrix_to_complex(m); flag = 1; } else { CHECK_MATRIX_COMPLEX(mb); Data_Get_Struct(mb, gsl_matrix_complex, cmb); } cmnew = gsl_matrix_complex_alloc(cm->size1, cm->size2); if (cmnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_mul(cmnew, cm, cmb); gsl_matrix_complex_memcpy(cm, cmnew); if (flag == 1) gsl_matrix_complex_free(cmb); return obj; } static VALUE rb_gsl_matrix_complex_add_diagonal(VALUE obj, VALUE s) { gsl_matrix_complex *m = NULL; gsl_complex c, *z = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); switch (TYPE(s)) { case T_FLOAT: case T_BIGNUM: case T_FIXNUM: c.dat[0] = NUM2DBL(s); c.dat[1] = 0.0; gsl_matrix_complex_add_diagonal(m, c); break; case T_ARRAY: c.dat[0] = NUM2DBL(rb_ary_entry(s, 0)); c.dat[1] = NUM2DBL(rb_ary_entry(s, 1)); gsl_matrix_complex_add_diagonal(m, c); break; default: if (rb_obj_is_kind_of(s, cgsl_complex)) { Data_Get_Struct(s, gsl_complex, z); gsl_matrix_complex_add_diagonal(m, *z); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(s))); } break; } return obj; } static VALUE rb_gsl_matrix_complex_submatrix(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL; gsl_matrix_complex_view *mv = NULL; gsl_vector_complex_view *vv = NULL; size_t i, j, n1, n2; Data_Get_Struct(obj, gsl_matrix_complex, m); parse_submatrix_args(argc, argv, m->size1, m->size2, &i, &j, &n1, &n2); if(n1 == 0) { vv = ALLOC(gsl_vector_complex_view); *vv = gsl_matrix_complex_subrow(m, i, j, n2); return Data_Wrap_Struct(cgsl_vector_complex_view, 0, free, vv); } else if(n2 == 0) { vv = ALLOC(gsl_vector_complex_view); *vv = gsl_matrix_complex_subcolumn(m, j, i, n1); return Data_Wrap_Struct(cgsl_vector_complex_col_view, 0, free, vv); } else { mv = ALLOC(gsl_matrix_complex_view); *mv = gsl_matrix_complex_submatrix(m, i, j, n1, n2); return Data_Wrap_Struct(cgsl_matrix_complex_view, 0, free, mv); } } static VALUE rb_gsl_matrix_complex_row(VALUE obj, VALUE i) { gsl_matrix_complex *m = NULL; gsl_vector_complex_view *vv = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_matrix_complex, m); vv = gsl_vector_complex_view_alloc(); *vv = gsl_matrix_complex_row(m, FIX2INT(i)); return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, vv); } static VALUE rb_gsl_matrix_complex_column(VALUE obj, VALUE i) { gsl_matrix_complex *m = NULL; gsl_vector_complex_view *vv = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_matrix_complex, m); vv = gsl_vector_complex_view_alloc(); *vv = gsl_matrix_complex_column(m, FIX2INT(i)); return Data_Wrap_Struct(cgsl_vector_complex_col_view, 0, gsl_vector_complex_view_free, vv); } static VALUE rb_gsl_matrix_complex_diagonal(VALUE obj) { gsl_matrix_complex *m = NULL; gsl_vector_complex_view *vv = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); vv = gsl_vector_complex_view_alloc(); *vv = gsl_matrix_complex_diagonal(m); return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, vv); } static VALUE rb_gsl_matrix_complex_set_diagonal(VALUE obj, VALUE diag) { gsl_matrix_complex *m = NULL; gsl_vector_complex *v; size_t i; Data_Get_Struct(obj, gsl_matrix_complex, m); if (VECTOR_COMPLEX_P(diag)) { Data_Get_Struct(diag, gsl_vector_complex, v); for (i = 0; i < m->size1; i++) gsl_matrix_complex_set(m, i, i, gsl_vector_complex_get(v, i)); } else { rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Vector_Complex or Array expected)", rb_class2name(CLASS_OF(diag))); } return obj; } static VALUE rb_gsl_matrix_complex_subdiagonal(VALUE obj, VALUE i) { gsl_matrix_complex *m = NULL; gsl_vector_complex_view *vv = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_matrix_complex, m); vv = gsl_vector_complex_view_alloc(); *vv = gsl_matrix_complex_subdiagonal(m, FIX2INT(i)); return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, vv); } static VALUE rb_gsl_matrix_complex_superdiagonal(VALUE obj, VALUE i) { gsl_matrix_complex *m = NULL; gsl_vector_complex_view *vv = NULL; CHECK_FIXNUM(i); Data_Get_Struct(obj, gsl_matrix_complex, m); vv = gsl_vector_complex_view_alloc(); *vv = gsl_matrix_complex_superdiagonal(m, FIX2INT(i)); return Data_Wrap_Struct(cgsl_vector_complex_view, 0, gsl_vector_complex_view_free, vv); } static VALUE rb_gsl_matrix_complex_coerce(VALUE obj, VALUE other) { gsl_matrix_complex *cm = NULL, *cmnew = NULL; gsl_matrix *m = NULL; gsl_complex z; VALUE vcm; Data_Get_Struct(obj, gsl_matrix_complex, cm); switch (TYPE(other)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: cmnew = gsl_matrix_complex_alloc(cm->size1, cm->size2); if (cmnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); GSL_SET_REAL(&z, NUM2DBL(other)); GSL_SET_IMAG(&z, 0.0); gsl_matrix_complex_set_all(cmnew, z); vcm = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); return rb_ary_new3(2, vcm, obj); break; default: if (rb_obj_is_kind_of(other, cgsl_matrix)) { Data_Get_Struct(other, gsl_matrix, m); cmnew = matrix_to_complex(m); vcm = Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); return rb_ary_new3(2, vcm, obj); } else { rb_raise(rb_eTypeError, "cannot coerce %s to GSL::Matrix::Complex", rb_class2name(CLASS_OF(other))); } break; } } static VALUE rb_gsl_matrix_complex_real(VALUE obj) { gsl_matrix_complex *cm = NULL; gsl_matrix *m = NULL; gsl_complex z; size_t i, j; Data_Get_Struct(obj, gsl_matrix_complex, cm); m = gsl_matrix_alloc(cm->size1, cm->size2); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); for (i = 0; i < cm->size1; i++) { for (j = 0; j < cm->size2; j++) { z = gsl_matrix_complex_get(cm, i, j); gsl_matrix_set(m, i, j, GSL_REAL(z)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m); } static VALUE rb_gsl_matrix_complex_imag(VALUE obj) { gsl_matrix_complex *cm = NULL; gsl_matrix *m = NULL; gsl_complex z; size_t i, j; Data_Get_Struct(obj, gsl_matrix_complex, cm); m = gsl_matrix_alloc(cm->size1, cm->size2); if (m == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_alloc failed"); for (i = 0; i < cm->size1; i++) { for (j = 0; j < cm->size2; j++) { z = gsl_matrix_complex_get(cm, i, j); gsl_matrix_set(m, i, j, GSL_IMAG(z)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m); } static void gsl_matrix_complex_conjugate(gsl_matrix_complex *cm) { gsl_complex z; size_t i, j; for (i = 0; i < cm->size1; i++) { for (j = 0; j < cm->size2; j++) { z = gsl_matrix_complex_get(cm, i, j); gsl_matrix_complex_set(cm, i, j, gsl_complex_conjugate(z)); } } } static void gsl_matrix_complex_conjugate2(gsl_matrix_complex *cmnew, gsl_matrix_complex *cm) { gsl_complex z; size_t i, j; for (i = 0; i < cm->size1; i++) { for (j = 0; j < cm->size2; j++) { z = gsl_matrix_complex_get(cm, i, j); gsl_matrix_complex_set(cmnew, i, j, gsl_complex_conjugate(z)); } } } static VALUE rb_gsl_matrix_complex_conjugate(VALUE obj) { gsl_matrix_complex *cm = NULL; Data_Get_Struct(obj, gsl_matrix_complex, cm); gsl_matrix_complex_conjugate(cm); return obj; } static VALUE rb_gsl_matrix_complex_conjugate2(VALUE obj) { gsl_matrix_complex *cm = NULL, *cmnew = NULL; Data_Get_Struct(obj, gsl_matrix_complex, cm); cmnew = gsl_matrix_complex_alloc(cm->size1, cm->size2); if (cmnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_conjugate2(cmnew, cm); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); } static VALUE rb_gsl_matrix_complex_dagger(VALUE obj) { gsl_matrix_complex *cm = NULL; Data_Get_Struct(obj, gsl_matrix_complex, cm); gsl_matrix_complex_conjugate(cm); gsl_matrix_complex_transpose(cm); return obj; } static VALUE rb_gsl_matrix_complex_dagger2(VALUE obj) { gsl_matrix_complex *cm = NULL, *cmnew = NULL; Data_Get_Struct(obj, gsl_matrix_complex, cm); cmnew = gsl_matrix_complex_alloc(cm->size1, cm->size2); if (cmnew == NULL) rb_raise(rb_eNoMemError, "gsl_matrix_complex_alloc failed"); gsl_matrix_complex_conjugate2(cmnew, cm); gsl_matrix_complex_transpose(cmnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, cmnew); } static VALUE rb_gsl_matrix_complex_trace(VALUE obj) { gsl_matrix_complex *m = NULL; gsl_complex *trace = NULL; VALUE vtrace; size_t i; Data_Get_Struct(obj, gsl_matrix_complex, m); vtrace = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, trace); trace->dat[0] = 0.0; trace->dat[1] = 0.0; for (i = 0; i < m->size1; i++) *trace = gsl_complex_add(*trace, gsl_matrix_complex_get(m, i, i)); return vtrace; } static VALUE rb_gsl_matrix_complex_each_row(VALUE obj) { gsl_matrix_complex *m = NULL; gsl_vector_complex_view *vv; size_t i; Data_Get_Struct(obj, gsl_matrix_complex, m); for (i = 0; i < m->size1; i++) { vv = ALLOC(gsl_vector_complex_view); *vv = gsl_matrix_complex_row(m, i); rb_yield(Data_Wrap_Struct(cgsl_vector_complex_view, 0, free, vv)); } return obj; } static VALUE rb_gsl_matrix_complex_each_col(VALUE obj) { gsl_matrix_complex *m = NULL; gsl_vector_complex_view *vv; size_t i; Data_Get_Struct(obj, gsl_matrix_complex, m); for (i = 0; i < m->size2; i++) { vv = ALLOC(gsl_vector_complex_view); *vv = gsl_matrix_complex_column(m, i); rb_yield(Data_Wrap_Struct(cgsl_vector_complex_col_view, 0, free, vv)); } return obj; } static VALUE rb_gsl_matrix_complex_size1(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); return INT2FIX(m->size1); } static VALUE rb_gsl_matrix_complex_size2(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); return INT2FIX(m->size2); } static VALUE rb_gsl_matrix_complex_shape(VALUE obj) { gsl_matrix_complex *m = NULL; Data_Get_Struct(obj, gsl_matrix_complex, m); return rb_ary_new3(2, INT2FIX(m->size1), INT2FIX(m->size2)); } static VALUE rb_gsl_matrix_complex_uplus(VALUE obj) { return obj; } static VALUE rb_gsl_matrix_complex_uminus(VALUE obj) { gsl_matrix_complex *m = NULL, *mnew; size_t i, j; Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_complex_set(mnew, i, j, gsl_complex_negative(gsl_matrix_complex_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } static VALUE rb_gsl_matrix_complex_XXX(VALUE obj, double (*f)(gsl_complex)) { gsl_matrix_complex *m; gsl_matrix *mnew; size_t i, j; Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_complex_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } static VALUE rb_gsl_matrix_complex_arg(VALUE obj) { return rb_gsl_matrix_complex_XXX(obj, gsl_complex_arg); } static VALUE rb_gsl_matrix_complex_abs(VALUE obj) { return rb_gsl_matrix_complex_XXX(obj, gsl_complex_abs); } static VALUE rb_gsl_matrix_complex_abs2(VALUE obj) { return rb_gsl_matrix_complex_XXX(obj, gsl_complex_abs2); } static VALUE rb_gsl_matrix_complex_logabs(VALUE obj) { return rb_gsl_matrix_complex_XXX(obj, gsl_complex_logabs); } static VALUE rb_gsl_matrix_complex_XXX_complex(VALUE obj, gsl_complex (*f)(gsl_complex)) { gsl_matrix_complex *m, *mnew; size_t i, j; Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_complex_set(mnew, i, j, (*f)(gsl_matrix_complex_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } static VALUE rb_gsl_matrix_complex_sqrt(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_sqrt); } static VALUE rb_gsl_matrix_complex_exp(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_exp); } static VALUE rb_gsl_matrix_complex_log(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_log); } static VALUE rb_gsl_matrix_complex_log10(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_log10); } static VALUE rb_gsl_matrix_complex_sin(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_sin); } static VALUE rb_gsl_matrix_complex_cos(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_cos); } static VALUE rb_gsl_matrix_complex_tan(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_tan); } static VALUE rb_gsl_matrix_complex_sec(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_sec); } static VALUE rb_gsl_matrix_complex_csc(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_csc); } static VALUE rb_gsl_matrix_complex_cot(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_cot); } static VALUE rb_gsl_matrix_complex_arcsin(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arcsin); } static VALUE rb_gsl_matrix_complex_arccos(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arccos); } static VALUE rb_gsl_matrix_complex_arctan(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arctan); } static VALUE rb_gsl_matrix_complex_arcsec(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arcsec); } static VALUE rb_gsl_matrix_complex_arccsc(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arccsc); } static VALUE rb_gsl_matrix_complex_arccot(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arccot); } static VALUE rb_gsl_matrix_complex_sinh(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_sinh); } static VALUE rb_gsl_matrix_complex_cosh(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_cosh); } static VALUE rb_gsl_matrix_complex_tanh(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_tanh); } static VALUE rb_gsl_matrix_complex_sech(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_sech); } static VALUE rb_gsl_matrix_complex_csch(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_csch); } static VALUE rb_gsl_matrix_complex_coth(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_coth); } static VALUE rb_gsl_matrix_complex_arcsinh(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arcsinh); } static VALUE rb_gsl_matrix_complex_arccosh(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arccosh); } static VALUE rb_gsl_matrix_complex_arctanh(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arctanh); } static VALUE rb_gsl_matrix_complex_arcsech(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arcsech); } static VALUE rb_gsl_matrix_complex_arccsch(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arccsch); } static VALUE rb_gsl_matrix_complex_arccoth(VALUE obj) { return rb_gsl_matrix_complex_XXX_complex(obj, gsl_complex_arccoth); } static VALUE rb_gsl_matrix_complex_indgen_bang(int argc, VALUE *argv[], VALUE obj) { gsl_matrix_complex *m = NULL; double start = 0, step = 1, x; size_t i, j; switch (argc) { case 0: break; case 1: start = NUM2DBL(argv[0]); break; case 2: start = NUM2DBL(argv[0]); step = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2)", argc); } Data_Get_Struct(obj, gsl_matrix_complex, m); x = start; for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_complex_set(m, i, j, gsl_complex_rect(x, 0)); x += step; } } return obj; } static VALUE rb_gsl_matrix_complex_indgen(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mnew; double start = 0, step = 1, x; size_t i, j; switch (argc) { case 0: break; case 1: start = NUM2DBL(argv[0]); break; case 2: start = NUM2DBL(argv[0]); step = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-2)", argc); } Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_calloc(m->size1, m->size2); x = start; for (i = 0; i < mnew->size1; i++) { for (j = 0; j < mnew->size2; j++) { gsl_matrix_complex_set(mnew, i, j, gsl_complex_rect(x, 0)); x += step; } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } static VALUE rb_gsl_matrix_complex_indgen_singleton(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *mnew; double start = 0, step = 1, x; size_t n1, n2, i, j; switch (argc) { case 2: n1 = (size_t) NUM2INT(argv[0]); n2 = (size_t) NUM2INT(argv[1]); break; case 3: n1 = (size_t) NUM2INT(argv[0]); n2 = (size_t) NUM2INT(argv[1]); start = NUM2DBL(argv[2]); break; case 4: n1 = (size_t) NUM2INT(argv[0]); n2 = (size_t) NUM2INT(argv[1]); start = NUM2DBL(argv[2]); step = NUM2DBL(argv[3]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0-4)", argc); } mnew = gsl_matrix_complex_calloc(n1, n2); x = start; for (i = 0; i < mnew->size1; i++) { for (j = 0; j < mnew->size2; j++) { gsl_matrix_complex_set(mnew, i, j, gsl_complex_rect(x, 0)); x += step; } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } // Starting with version 1.15, GSL provides a gsl_matrix_complex_equal // function, but it only determines absolute equality (i.e. is has no epsilon // argument). static int gsl_matrix_complex_equal_eps(const gsl_matrix_complex *m1, const gsl_matrix_complex *m2, double eps) { gsl_complex z1, z2; size_t i, j; if (m1->size1 != m2->size1) return 0; if (m1->size2 != m2->size2) return 0; for (i = 0; i < m1->size1; i++) { for (j = 0; j < m1->size2; j++) { z1 = gsl_matrix_complex_get(m1, i, j); z2 = gsl_matrix_complex_get(m2, i, j); if (!rbgsl_complex_equal(&z1, &z2, eps)) return 0; } } return 1; } static VALUE rb_gsl_matrix_complex_equal(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m1, *m2; double eps = 1e-8; int ret; switch (argc) { case 1: eps = 1e-8; break; case 2: eps = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)\n", argc); } Data_Get_Struct(obj, gsl_matrix_complex, m1); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m2); ret = gsl_matrix_complex_equal_eps(m1, m2, eps); if (ret == 1) return Qtrue; else return Qfalse; } static VALUE rb_gsl_matrix_complex_not_equal(int argc, VALUE *argv, VALUE obj) { VALUE ret; ret = rb_gsl_matrix_complex_equal(argc, argv, obj); if (ret == Qtrue) return Qfalse; else return Qtrue; } void Init_gsl_matrix_complex(VALUE module) { // rb_define_singleton_method(cgsl_matrix_complex, "new", rb_gsl_matrix_complex_new, 2); rb_define_singleton_method(cgsl_matrix_complex, "alloc", rb_gsl_matrix_complex_new, 2); rb_define_singleton_method(cgsl_matrix_complex, "[]", rb_gsl_matrix_complex_new, 2); rb_define_singleton_method(cgsl_matrix_complex, "calloc", rb_gsl_matrix_complex_new, 2); rb_define_singleton_method(cgsl_matrix_complex, "eye", rb_gsl_matrix_complex_eye, -1); rb_define_singleton_method(cgsl_matrix_complex, "diagonal", rb_gsl_matrix_complex_eye, -1); rb_define_singleton_method(cgsl_matrix_complex, "identity", rb_gsl_matrix_complex_identity, 1); rb_define_singleton_method(cgsl_matrix_complex, "unit", rb_gsl_matrix_complex_identity, 1); rb_define_singleton_method(cgsl_matrix_complex, "I", rb_gsl_matrix_complex_identity, 1); rb_define_method(cgsl_matrix_complex, "set", rb_gsl_matrix_complex_set, -1); rb_define_alias(cgsl_matrix_complex, "[]=", "set"); rb_define_method(cgsl_matrix_complex, "set_row", rb_gsl_matrix_complex_set_row, -1); rb_define_method(cgsl_matrix_complex, "set_col", rb_gsl_matrix_complex_set_col, -1); rb_define_method(cgsl_matrix_complex, "get", rb_gsl_matrix_complex_get, -1); rb_define_alias(cgsl_matrix_complex, "[]", "get"); rb_define_method(cgsl_matrix_complex, "ptr", rb_gsl_matrix_complex_ptr, 2); rb_define_method(cgsl_matrix_complex, "to_s", rb_gsl_matrix_complex_to_s, -1); rb_define_method(cgsl_matrix_complex, "fprintf", rb_gsl_matrix_complex_fprintf, -1); rb_define_method(cgsl_matrix_complex, "printf", rb_gsl_matrix_complex_printf, -1); rb_define_method(cgsl_matrix_complex, "print", rb_gsl_matrix_complex_print, 0); rb_define_method(cgsl_matrix_complex, "inspect", rb_gsl_matrix_complex_inspect, -1); rb_define_method(cgsl_matrix_complex, "fwrite", rb_gsl_matrix_complex_fwrite, 1); rb_define_method(cgsl_matrix_complex, "fread", rb_gsl_matrix_complex_fread, 1); rb_define_method(cgsl_matrix_complex, "fscanf", rb_gsl_matrix_complex_fscanf, 1); rb_define_singleton_method(cgsl_matrix_complex, "memcpy", rb_gsl_matrix_complex_memcpy, 2); rb_define_method(cgsl_matrix_complex, "clone", rb_gsl_matrix_complex_clone, 0); rb_define_alias(cgsl_matrix_complex, "duplicate", "clone"); rb_define_alias(cgsl_matrix_complex, "dup", "clone"); rb_define_method(cgsl_matrix_complex, "swap_rows", rb_gsl_matrix_complex_swap_rows, 2); rb_define_method(cgsl_matrix_complex, "swap_columns", rb_gsl_matrix_complex_swap_columns, 2); rb_define_method(cgsl_matrix_complex, "swap_rowcol", rb_gsl_matrix_complex_swap_rowcol, 2); rb_define_method(cgsl_matrix_complex, "transpose", rb_gsl_matrix_complex_transpose, 0); rb_define_method(cgsl_matrix_complex, "isnull", rb_gsl_matrix_complex_isnull, 0); rb_define_method(cgsl_matrix_complex, "add", rb_gsl_matrix_complex_add, 1); rb_define_alias(cgsl_matrix_complex, "add_constant", "add"); rb_define_alias(cgsl_matrix_complex, "+", "add"); rb_define_method(cgsl_matrix_complex, "sub", rb_gsl_matrix_complex_sub, 1); rb_define_alias(cgsl_matrix_complex, "-", "sub"); rb_define_method(cgsl_matrix_complex, "mul_elements", rb_gsl_matrix_complex_mul_elements, 1); rb_define_method(cgsl_matrix_complex, "div_elements", rb_gsl_matrix_complex_div_elements, 1); rb_define_alias(cgsl_matrix_complex, "/", "div_elements"); rb_define_method(cgsl_matrix_complex, "scale", rb_gsl_matrix_complex_scale, 1); rb_define_method(cgsl_matrix_complex, "scale!", rb_gsl_matrix_complex_scale_bang, 1); rb_define_method(cgsl_matrix_complex, "add_diagonal", rb_gsl_matrix_complex_add_diagonal, 1); rb_define_method(cgsl_matrix_complex, "set_zero", rb_gsl_matrix_complex_set_zero, 0); rb_define_method(cgsl_matrix_complex, "set_identity", rb_gsl_matrix_complex_set_identity, 0); rb_define_method(cgsl_matrix_complex, "set_all", rb_gsl_matrix_complex_set_all, 1); rb_define_method(cgsl_matrix_complex, "submatrix", rb_gsl_matrix_complex_submatrix, -1); rb_define_alias(cgsl_matrix_complex, "view", "submatrix"); rb_define_method(cgsl_matrix_complex, "row", rb_gsl_matrix_complex_row, 1); /* rb_define_alias(cgsl_matrix_complex, "[]", "row");*/ rb_define_method(cgsl_matrix_complex, "column", rb_gsl_matrix_complex_column, 1); rb_define_alias(cgsl_matrix_complex, "col", "column"); rb_define_method(cgsl_matrix_complex, "diagonal", rb_gsl_matrix_complex_diagonal, 0); rb_define_alias(cgsl_matrix_complex, "diag", "diagonal"); rb_define_method(cgsl_matrix_complex, "set_diagonal", rb_gsl_matrix_complex_set_diagonal, 1); rb_define_method(cgsl_matrix_complex, "subdiagonal", rb_gsl_matrix_complex_subdiagonal, 1); rb_define_method(cgsl_matrix_complex, "superdiagonal", rb_gsl_matrix_complex_superdiagonal, 1); rb_define_method(cgsl_matrix_complex, "coerce", rb_gsl_matrix_complex_coerce, 1); rb_define_method(cgsl_matrix_complex, "mul", rb_gsl_matrix_complex_mul, 1); rb_define_alias(cgsl_matrix_complex, "*", "mul"); rb_define_method(cgsl_matrix_complex, "mul!", rb_gsl_matrix_complex_mul2, 1); rb_define_method(cgsl_matrix_complex, "real", rb_gsl_matrix_complex_real, 0); rb_define_alias(cgsl_matrix_complex, "to_real", "real"); rb_define_alias(cgsl_matrix_complex, "re", "real"); rb_define_method(cgsl_matrix_complex, "imag", rb_gsl_matrix_complex_imag, 0); rb_define_alias(cgsl_matrix_complex, "im", "imag"); /* 25.June.2004 */ rb_define_method(cgsl_matrix_complex, "conjugate!", rb_gsl_matrix_complex_conjugate, 0); rb_define_alias(cgsl_matrix_complex, "conj!", "conjugate!"); rb_define_method(cgsl_matrix_complex, "conjugate", rb_gsl_matrix_complex_conjugate2, 0); rb_define_alias(cgsl_matrix_complex, "conj", "conjugate"); rb_define_method(cgsl_matrix_complex, "dagger!", rb_gsl_matrix_complex_dagger, 0); rb_define_method(cgsl_matrix_complex, "dagger", rb_gsl_matrix_complex_dagger2, 0); rb_define_method(cgsl_matrix_complex, "trace", rb_gsl_matrix_complex_trace, 0); rb_define_method(cgsl_matrix_complex, "each_row", rb_gsl_matrix_complex_each_row, 0); rb_define_method(cgsl_matrix_complex, "each_col", rb_gsl_matrix_complex_each_col, 0); rb_define_alias(cgsl_matrix_complex, "each_column", "each_col"); rb_define_method(cgsl_matrix_complex, "collect", rb_gsl_matrix_complex_collect, 0); rb_define_method(cgsl_matrix_complex, "collect!", rb_gsl_matrix_complex_collect_bang, 0); rb_define_alias(cgsl_matrix_complex, "map", "collect"); rb_define_alias(cgsl_matrix_complex, "map!", "collect!"); rb_define_method(cgsl_matrix_complex, "to_a", rb_gsl_matrix_complex_to_a, 0); rb_define_method(cgsl_matrix_complex, "size1", rb_gsl_matrix_complex_size1, 0); rb_define_method(cgsl_matrix_complex, "size2", rb_gsl_matrix_complex_size2, 0); rb_define_method(cgsl_matrix_complex, "shape", rb_gsl_matrix_complex_shape, 0); rb_define_alias(cgsl_matrix_complex, "size", "shape"); /*****/ rb_define_method(cgsl_matrix_complex, "-@", rb_gsl_matrix_complex_uminus, 0); rb_define_method(cgsl_matrix_complex, "+@", rb_gsl_matrix_complex_uplus, 0); /****/ rb_define_method(cgsl_matrix_complex, "arg", rb_gsl_matrix_complex_arg, 0); rb_define_alias(cgsl_matrix_complex, "angle", "arg"); rb_define_alias(cgsl_matrix_complex, "phase", "arg"); rb_define_method(cgsl_matrix_complex, "abs", rb_gsl_matrix_complex_abs, 0); rb_define_alias(cgsl_matrix_complex, "amp", "abs"); rb_define_method(cgsl_matrix_complex, "abs2", rb_gsl_matrix_complex_abs2, 0); rb_define_method(cgsl_matrix_complex, "logabs", rb_gsl_matrix_complex_logabs, 0); rb_define_method(cgsl_matrix_complex, "sqrt", rb_gsl_matrix_complex_sqrt, 0); rb_define_method(cgsl_matrix_complex, "exp", rb_gsl_matrix_complex_exp, 0); rb_define_method(cgsl_matrix_complex, "log", rb_gsl_matrix_complex_log, 0); rb_define_method(cgsl_matrix_complex, "log10", rb_gsl_matrix_complex_log10, 0); rb_define_method(cgsl_matrix_complex, "sin", rb_gsl_matrix_complex_sin, 0); rb_define_method(cgsl_matrix_complex, "cos", rb_gsl_matrix_complex_cos, 0); rb_define_method(cgsl_matrix_complex, "tan", rb_gsl_matrix_complex_tan, 0); rb_define_method(cgsl_matrix_complex, "sec", rb_gsl_matrix_complex_sec, 0); rb_define_method(cgsl_matrix_complex, "csc", rb_gsl_matrix_complex_csc, 0); rb_define_method(cgsl_matrix_complex, "cot", rb_gsl_matrix_complex_cot, 0); rb_define_method(cgsl_matrix_complex, "arcsin", rb_gsl_matrix_complex_arcsin, 0); rb_define_method(cgsl_matrix_complex, "arccos", rb_gsl_matrix_complex_arccos, 0); rb_define_method(cgsl_matrix_complex, "arctan", rb_gsl_matrix_complex_arctan, 0); rb_define_method(cgsl_matrix_complex, "arcsec", rb_gsl_matrix_complex_arcsec, 0); rb_define_method(cgsl_matrix_complex, "arccsc", rb_gsl_matrix_complex_arccsc, 0); rb_define_method(cgsl_matrix_complex, "arccot", rb_gsl_matrix_complex_arccot, 0); rb_define_method(cgsl_matrix_complex, "sinh", rb_gsl_matrix_complex_sinh, 0); rb_define_method(cgsl_matrix_complex, "cosh", rb_gsl_matrix_complex_cosh, 0); rb_define_method(cgsl_matrix_complex, "tanh", rb_gsl_matrix_complex_tanh, 0); rb_define_method(cgsl_matrix_complex, "sech", rb_gsl_matrix_complex_sech, 0); rb_define_method(cgsl_matrix_complex, "csch", rb_gsl_matrix_complex_csch, 0); rb_define_method(cgsl_matrix_complex, "coth", rb_gsl_matrix_complex_coth, 0); rb_define_method(cgsl_matrix_complex, "arcsinh", rb_gsl_matrix_complex_arcsinh, 0); rb_define_method(cgsl_matrix_complex, "arccosh", rb_gsl_matrix_complex_arccosh, 0); rb_define_method(cgsl_matrix_complex, "arctanh", rb_gsl_matrix_complex_arctanh, 0); rb_define_method(cgsl_matrix_complex, "arcsech", rb_gsl_matrix_complex_arcsech, 0); rb_define_method(cgsl_matrix_complex, "arccsch", rb_gsl_matrix_complex_arccsch, 0); rb_define_method(cgsl_matrix_complex, "arccoth", rb_gsl_matrix_complex_arccoth, 0); rb_define_method(cgsl_matrix_complex, "indgen", rb_gsl_matrix_complex_indgen, -1); rb_define_method(cgsl_matrix_complex, "indgen!", rb_gsl_matrix_complex_indgen_bang, -1); rb_define_singleton_method(cgsl_matrix_complex, "indgen", rb_gsl_matrix_complex_indgen_singleton, -1); rb_define_method(cgsl_matrix_complex, "equal?", rb_gsl_matrix_complex_equal, -1); rb_define_alias(cgsl_matrix_complex, "==", "equal?"); rb_define_method(cgsl_matrix_complex, "not_equal?", rb_gsl_matrix_complex_not_equal, -1); rb_define_alias(cgsl_matrix_complex, "!=", "not_equal?"); } gsl-1.15.3/ext/sf_power.c0000644000175000017500000000274412220252463014541 0ustar boutilboutil/* sf_power.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" VALUE rb_gsl_complex_pow(int argc, VALUE *argv, VALUE obj); static VALUE rb_gsl_sf_pow_int(VALUE obj, VALUE x, VALUE n) { VALUE argv[2]; if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) { argv[0] = x; argv[1] = n; return rb_gsl_complex_pow(2, argv, obj); } return rb_gsl_sf_eval_double_int(gsl_sf_pow_int, x, n); } static VALUE rb_gsl_sf_pow_int_e(VALUE obj, VALUE x, VALUE n) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); CHECK_FIXNUM(n); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_pow_int_e(NUM2DBL(x), FIX2INT(n), rslt); return v; } void Init_gsl_sf_power(VALUE module) { VALUE mgsl_sf_pow; rb_define_module_function(module, "pow_int", rb_gsl_sf_pow_int, 2); rb_define_module_function(module, "pow_int_e", rb_gsl_sf_pow_int_e, 2); mgsl_sf_pow = rb_define_module_under(module, "Pow"); rb_define_module_function(mgsl_sf_pow, "int", rb_gsl_sf_pow_int, 2); rb_define_module_function(mgsl_sf_pow, "int_e", rb_gsl_sf_pow_int_e, 2); } gsl-1.15.3/ext/jacobi.c0000644000175000017500000005060612220252463014144 0ustar boutilboutil#ifdef HAVE_JACOBI_H #include "rb_gsl.h" #include "jacobi.h" static VALUE jac_eval3_e(VALUE x, VALUE a, VALUE b, int (*f)(double, double, double, gsl_sf_result*)) { gsl_sf_result *result; VALUE obj; obj = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, result); (*f)(NUM2DBL(x), NUM2DBL(a), NUM2DBL(b), result); return obj; } static VALUE jac_eval3(VALUE xx, VALUE aa, VALUE bb, double (*f)(double, double, double)) { gsl_vector *x, *y; double a, b; size_t i, len; VALUE ary; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif a = NUM2DBL(aa); b = NUM2DBL(bb); if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, x); y = gsl_vector_alloc(x->size); for (i = 0; i < x->size; i++) { gsl_vector_set(y, i, (*f)(gsl_vector_get(x, i), a, b)); } return Data_Wrap_Struct(VECTOR_ROW_COL(CLASS_OF(xx)), 0, gsl_vector_free, y); } else if (TYPE(xx) == T_ARRAY) { // len = RARRAY(xx)->len; len = RARRAY_LEN(xx); ary = rb_ary_new2(len); for (i = 0; i < len; i++) { rb_ary_store(ary, i, rb_float_new((*f)(NUM2DBL(rb_ary_entry(xx, i)), a, b))); } return ary; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(xx)) { GetNArray(xx, na); len = na->total; ptr1 = (double*) na->ptr; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < len; i++) { ptr2[i] = (*f)(ptr1[i], a, b); } return ary; #endif } else { return rb_float_new((*f)(NUM2DBL(xx), a, b)); } } static VALUE rb_jac_jacobi_eval(int argc, VALUE *argv, double (*f)(double, int, double, double), int (*f2)(int, const double*, int, double*, double, double, double*)) { gsl_vector *x, *ws, *y; double a, b; VALUE ary; size_t len, i; int n, flag = 0; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif if (argc < 4) rb_raise(rb_eArgError, "Too few arguments (%d for >= 4)", argc); if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, x); y = gsl_vector_alloc(x->size); ary = Data_Wrap_Struct(VECTOR_ROW_COL(CLASS_OF(x)), 0, gsl_vector_free, y); switch (argc) { case 4: ws = gsl_vector_alloc(2*x->size); flag = 1; break; case 5: CHECK_VECTOR(argv[4]); Data_Get_Struct(argv[4], gsl_vector, ws); break; default: rb_raise(rb_eArgError, "Too many arguments (%d for 4 or 5)", argc); } (*f2)(x->size, x->data, FIX2INT(argv[1]), y->data, NUM2DBL(argv[2]), NUM2DBL(argv[3]), ws->data); if (flag == 1) gsl_vector_free(ws); return ary; } else if (TYPE(argv[0]) == T_ARRAY) { n = FIX2INT(argv[1]); a = NUM2DBL(argv[2]); b = NUM2DBL(argv[3]); // len = RARRAY(argv[0])->len; len = RARRAY_LEN(argv[0]); ary = rb_ary_new2(len); for (i = 0; i < len; i++) { rb_ary_store(ary, i, rb_float_new((*f)(NUM2DBL(rb_ary_entry(argv[0], i)), n, a, b))); } return ary; #ifdef HAVE_NARRAY_H } else if (NA_IsNArray(argv[0])) { GetNArray(argv[0], na); len = na->total; ptr1 = (double*) na->ptr; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv[0])); ptr2 = NA_PTR_TYPE(ary, double*); n = FIX2INT(argv[1]); a = NUM2DBL(argv[2]); b = NUM2DBL(argv[3]); ws = gsl_vector_alloc(len); (*f2)(len, ptr1, n, ptr2, a, b, ws->data); gsl_vector_free(ws); return ary; #endif } else { return rb_float_new((*f)(NUM2DBL(argv[0]), FIX2INT(argv[1]), NUM2DBL(argv[2]), NUM2DBL(argv[3]))); } } static VALUE rb_jac_jacobi_P0_e(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3_e(x, a, b, jac_jacobi_P0_e); } static VALUE rb_jac_jacobi_P0(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3(x, a, b, jac_jacobi_P0); } static VALUE rb_jac_jacobi_P1_e(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3_e(x, a, b, jac_jacobi_P1_e); } static VALUE rb_jac_jacobi_P1(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3(x, a, b, jac_jacobi_P1); } static VALUE rb_jac_jacobi(int argc, VALUE *argv, VALUE module) { return rb_jac_jacobi_eval(argc, argv, jac_jacobi, jac_jacobi_array); } static VALUE rb_jac_djacobi_P0_e(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3_e(x, a, b, jac_djacobi_P0_e); } static VALUE rb_jac_djacobi_P0(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3(x, a, b, jac_djacobi_P0); } static VALUE rb_jac_djacobi_P1_e(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3_e(x, a, b, jac_djacobi_P1_e); } static VALUE rb_jac_djacobi_P1(VALUE module, VALUE x, VALUE a, VALUE b) { return jac_eval3(x, a, b, jac_djacobi_P1); } static VALUE rb_jac_djacobi(int argc, VALUE *argv, VALUE module) { return rb_jac_jacobi_eval(argc, argv, jac_djacobi, jac_djacobi_array); } static VALUE rb_jac_zeros_eval(int argc, VALUE *argv, VALUE module, int (*f)(double*, int, double, double)) { gsl_vector *x; int m, status; double a, b; VALUE xx; switch (argc) { case 3: if (FIXNUM_P(argv[0])) { m = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); x = gsl_vector_alloc(m); xx = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, x); } else if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, x); m = x->size; a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); xx = argv[0]; } else { rb_raise(rb_eTypeError, "Wrong argument type %s (Fixnum or GSL::Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } break; case 4: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, x); m = FIX2INT(argv[1]); a = NUM2DBL(argv[2]); b = NUM2DBL(argv[3]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 3 or 4)", argc); } status = (*f)(x->data, m, a, b); if (status != GSL_SUCCESS) rb_raise(rb_eRuntimeError, "Something wrong. (error code %d)", status); return xx; } static VALUE rb_jac_jacobi_zeros(int argc, VALUE *argv, VALUE module) { return rb_jac_zeros_eval(argc, argv, module, jac_jacobi_zeros); } static void jac_define_const(VALUE module) { rb_define_const(module, "GJ", INT2FIX(JAC_GJ)); rb_define_const(module, "GLJ", INT2FIX(JAC_GLJ)); rb_define_const(module, "GRJM", INT2FIX(JAC_GRJM)); rb_define_const(module, "GRJP", INT2FIX(JAC_GRJP)); } static VALUE rb_jac_quadrature_alloc(VALUE klass, VALUE vQ) { jac_quadrature *q; q = jac_quadrature_alloc(FIX2INT(vQ)); return Data_Wrap_Struct(klass, 0, jac_quadrature_free, q); } static VALUE rb_jac_quadrature_Q(VALUE obj) { jac_quadrature *q; Data_Get_Struct(obj, jac_quadrature, q); return INT2FIX(q->Q); } static VALUE rb_jac_quadrature_type(VALUE obj) { jac_quadrature *q; Data_Get_Struct(obj, jac_quadrature, q); return INT2FIX((int) q->type); } static VALUE rb_jac_quadrature_alpha(VALUE obj) { jac_quadrature *q; Data_Get_Struct(obj, jac_quadrature, q); return NUM2DBL(q->alpha); } static VALUE rb_jac_quadrature_beta(VALUE obj) { jac_quadrature *q; Data_Get_Struct(obj, jac_quadrature, q); return NUM2DBL(q->beta); } static VALUE rb_jac_quadrature_x(VALUE obj) { jac_quadrature *q; gsl_vector_view *v; Data_Get_Struct(obj, jac_quadrature, q); v = gsl_vector_view_alloc(); v->vector.data = q->x; v->vector.size = q->Q; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, v); } static VALUE rb_jac_quadrature_w(VALUE obj) { jac_quadrature *q; gsl_vector_view *v; Data_Get_Struct(obj, jac_quadrature, q); v = gsl_vector_view_alloc(); v->vector.data = q->w; v->vector.size = q->Q; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, v); } static VALUE rb_jac_quadrature_D(VALUE obj) { jac_quadrature *q; gsl_vector_view *v; Data_Get_Struct(obj, jac_quadrature, q); v = gsl_vector_view_alloc(); v->vector.data = q->D; v->vector.size = q->Q; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, v); } static VALUE rb_jac_quadrature_xp(VALUE obj) { jac_quadrature *q; gsl_vector_view *v; Data_Get_Struct(obj, jac_quadrature, q); v = gsl_vector_view_alloc(); v->vector.data = q->w; v->vector.size = q->np; v->vector.stride = 1; return Data_Wrap_Struct(cgsl_vector_view, 0, gsl_vector_view_free, v); } static VALUE rb_jac_interpmat_alloc(int argc, VALUE *argv, VALUE obj) { int err; jac_quadrature *q; gsl_vector *xp; int np; Data_Get_Struct(obj, jac_quadrature, q); switch (argc) { case 1: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, xp); np = xp->size; break; case 2: CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, xp); np = FIX2INT(argv[0]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)", argc); } err = jac_interpmat_alloc(q, np, xp->data); return FIX2INT(err); } static VALUE rb_jac_interpmat_free(VALUE obj) { jac_quadrature *q; Data_Get_Struct(obj, jac_quadrature, q); jac_interpmat_free(q); return Qtrue; } static VALUE rb_jac_quadrature_zwd(int argc, VALUE *argv, VALUE obj) { jac_quadrature *q; gsl_vector *ws; int flag = 0, type, status; double a, b; Data_Get_Struct(obj, jac_quadrature, q); switch (argc) { case 3: type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); ws = gsl_vector_alloc(q->Q); flag = 1; break; case 4: type = FIX2INT(argv[0]); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_vector, ws); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 3 or 4)", argc); } status = jac_quadrature_zwd(q, type, a, b, ws->data); if (flag == 1) gsl_vector_free(ws); return INT2FIX(status); } static VALUE rb_jac_integrate(VALUE obj, VALUE ff) { jac_quadrature *q; gsl_vector *f; CHECK_VECTOR(ff); Data_Get_Struct(obj, jac_quadrature, q); Data_Get_Struct(ff, gsl_vector, f); return rb_float_new(jac_integrate(q, f->data)); } static VALUE rb_jac_interpolate(int argc, VALUE *argv, VALUE obj) { jac_quadrature *q; gsl_vector *f, *fout; VALUE vfout; switch (argc) { case 1: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, f); fout = gsl_vector_alloc(f->size); vfout = Data_Wrap_Struct(VECTOR_ROW_COL(CLASS_OF(argv[0])), 0, gsl_vector_free, fout); break; case 2: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, f); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, fout); vfout = argv[1]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)", argc); } Data_Get_Struct(obj, jac_quadrature, q); jac_interpolate(q, f->data, fout->data); return vfout; } static VALUE rb_jac_differentiate(int argc, VALUE *argv, VALUE obj) { jac_quadrature *q; gsl_vector *f, *fout; VALUE vfout; switch (argc) { case 1: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, f); fout = gsl_vector_alloc(f->size); vfout = Data_Wrap_Struct(VECTOR_ROW_COL(CLASS_OF(argv[0])), 0, gsl_vector_free, fout); break; case 2: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, f); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[1], gsl_vector, fout); vfout = argv[1]; break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 1 or 2)", argc); } Data_Get_Struct(obj, jac_quadrature, q); jac_differentiate(q, f->data, fout->data); return vfout; } /*****/ static VALUE rb_jac_qeval(int argc, VALUE *argv, int (*f)(double*, double*, const int, double, double, double*)) { gsl_vector *z, *D, *ws; int Q; int flag = 0, status; double alpha, beta; VALUE vD; if (argc < 3) rb_raise(rb_eArgError, "Too few arguments (%d for >= 3)", argc); CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, z); argc -= 1; argv += 1; if (VECTOR_P(argv[argc-1])) { Data_Get_Struct(argv[argc-1], gsl_vector, ws); argc -= 1; } else { ws = gsl_vector_alloc(z->size); flag = 1; } switch (argc) { case 2: Q = z->size; D = gsl_vector_alloc(Q*Q); alpha = NUM2DBL(argv[0]); beta = NUM2DBL(argv[1]); vD = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, D); break; case 4: Data_Get_Struct(argv[0], gsl_vector, D); vD = argv[0]; Q = FIX2INT(argv[1]); alpha = NUM2DBL(argv[2]); beta = NUM2DBL(argv[3]); break; case 3: if (VECTOR_P(argv[0])) { Q = z->size; Data_Get_Struct(argv[0], gsl_vector, D); vD = argv[0]; } else { Q = FIX2INT(argv[0]); D = gsl_vector_alloc(Q*Q); vD = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, D); } alpha = NUM2DBL(argv[1]); beta = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments."); } status = (*f)(z->data, D->data, Q, alpha, beta, ws->data); if (flag == 1) gsl_vector_free(ws); if (status != GSL_SUCCESS) rb_raise(rb_eRuntimeError, "Something wrong."); return vD; } static VALUE rb_jac_diffmat_gj(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_diffmat_gj); } static VALUE rb_jac_diffmat_glj(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_diffmat_glj); } static VALUE rb_jac_diffmat_grjm(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_diffmat_grjm); } static VALUE rb_jac_diffmat_grjp(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_diffmat_grjp); } static VALUE rb_jac_weights_gj(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_weights_gj); } static VALUE rb_jac_weights_glj(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_weights_glj); } static VALUE rb_jac_weights_grjm(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_weights_grjm); } static VALUE rb_jac_weights_grjp(int argc, VALUE *argv, VALUE module) { return rb_jac_qeval(argc, argv, jac_weights_grjp); } static VALUE rb_jac_zeros_gj(int argc, VALUE *argv, VALUE module) { return rb_jac_zeros_eval(argc, argv, module, jac_zeros_gj); } static VALUE rb_jac_zeros_glj(int argc, VALUE *argv, VALUE module) { return rb_jac_zeros_eval(argc, argv, module, jac_zeros_glj); } static VALUE rb_jac_zeros_grjm(int argc, VALUE *argv, VALUE module) { return rb_jac_zeros_eval(argc, argv, module, jac_zeros_grjm); } static VALUE rb_jac_zeros_grjp(int argc, VALUE *argv, VALUE module) { return rb_jac_zeros_eval(argc, argv, module, jac_zeros_grjp); } static VALUE rb_jac_lagrange_eval(int argc, VALUE *argv, double (*f)(int, double, int, double*, double, double)) { gsl_vector *z; int i, Q; double alpha, beta, zz; switch (argc) { case 5: i = FIX2INT(argv[0]); zz = NUM2DBL(argv[1]); CHECK_VECTOR(argv[2]); Data_Get_Struct(argv[2], gsl_vector, z); Q = z->size; alpha = NUM2DBL(argv[3]); beta = NUM2DBL(argv[4]); break; case 6: i = FIX2INT(argv[0]); zz = NUM2DBL(argv[1]); Q = FIX2INT(argv[2]); CHECK_VECTOR(argv[3]); Data_Get_Struct(argv[3], gsl_vector, z); alpha = NUM2DBL(argv[4]); beta = NUM2DBL(argv[5]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments (%d for 5 or 6)", argc); } return rb_float_new((*f)(i, zz, Q, z->data, alpha, beta)); } static VALUE rb_jac_lagrange_gj(int argc, VALUE *argv, VALUE module) { return rb_jac_lagrange_eval(argc, argv, jac_lagrange_gj); } static VALUE rb_jac_lagrange_glj(int argc, VALUE *argv, VALUE module) { return rb_jac_lagrange_eval(argc, argv, jac_lagrange_glj); } static VALUE rb_jac_lagrange_grjm(int argc, VALUE *argv, VALUE module) { return rb_jac_lagrange_eval(argc, argv, jac_lagrange_grjm); } static VALUE rb_jac_lagrange_grjp(int argc, VALUE *argv, VALUE module) { return rb_jac_lagrange_eval(argc, argv, jac_lagrange_grjp); } static VALUE rb_jac_interpmat_eval(int argc, VALUE *argv, int (*f) (double*, double*, int, double*, int, double, double)) { gsl_vector *imat, *zp, *z; double alpha, beta; int np, Q, status; VALUE vimat; if (argc < 3) rb_raise(rb_eArgError, "Too few arguments (%d for >= 3)", argc); CHECK_VECTOR(argv[0]); if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[0], gsl_vector, imat); Data_Get_Struct(argv[1], gsl_vector, zp); vimat = argv[0]; if (FIXNUM_P(argv[2])) np = FIX2INT(argv[2]); argc -= 3; argv += 3; } else { Data_Get_Struct(argv[0], gsl_vector, zp); if (FIXNUM_P(argv[1])) np = FIX2INT(argv[1]); else np = zp->size; imat = gsl_vector_alloc(np); vimat = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, imat); argc -= 2; argv += 2; } CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, z); argc -= 1; argv += 1; switch (argc) { case 3: Q = FIX2INT(argv[0]); alpha = NUM2DBL(argv[1]); beta = NUM2DBL(argv[2]); break; case 2: Q = z->size; alpha = NUM2DBL(argv[0]); beta = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "Wrong number of arguments."); } (*f)(imat->data, zp->data, np, z->data, Q, alpha, beta); if (status != GSL_SUCCESS) rb_raise(rb_eRuntimeError, "Some error."); return vimat; } static VALUE rb_jac_interpmat_gj(int argc, VALUE *argv, VALUE module) { return rb_jac_interpmat_eval(argc, argv, jac_interpmat_gj); } static VALUE rb_jac_interpmat_glj(int argc, VALUE *argv, VALUE module) { return rb_jac_interpmat_eval(argc, argv, jac_interpmat_glj); } static VALUE rb_jac_interpmat_grjm(int argc, VALUE *argv, VALUE module) { return rb_jac_interpmat_eval(argc, argv, jac_interpmat_grjm); } static VALUE rb_jac_interpmat_grjp(int argc, VALUE *argv, VALUE module) { return rb_jac_interpmat_eval(argc, argv, jac_interpmat_grjp); } void Init_jacobi(VALUE module) { VALUE mjac, cjacq; mjac = rb_define_module("Jac"); jac_define_const(mjac); cjacq = rb_define_class_under(mjac, "Quadrature", cGSL_Object); rb_define_module_function(mjac, "jacobi_P0_e", rb_jac_jacobi_P0_e, 3); rb_define_module_function(mjac, "jacobi_P0", rb_jac_jacobi_P0, 3); rb_define_module_function(mjac, "jacobi_P1_e", rb_jac_jacobi_P1_e, 3); rb_define_module_function(mjac, "jacobi_P1", rb_jac_jacobi_P1, 3); rb_define_module_function(mjac, "jacobi", rb_jac_jacobi, -1); rb_define_module_function(mjac, "djacobi_P0_e", rb_jac_djacobi_P0_e, 3); rb_define_module_function(mjac, "djacobi_P0", rb_jac_djacobi_P0, 3); rb_define_module_function(mjac, "djacobi_P1_e", rb_jac_djacobi_P1_e, 3); rb_define_module_function(mjac, "djacobi_P1", rb_jac_djacobi_P1, 3); rb_define_module_function(mjac, "djacobi", rb_jac_djacobi, 4); rb_define_module_function(mjac, "jacobi_zeros", rb_jac_jacobi_zeros, -1); /*****/ rb_define_singleton_method(cjacq, "alloc", rb_jac_quadrature_alloc, 1); rb_define_method(cjacq, "Q", rb_jac_quadrature_Q, 0); rb_define_method(cjacq, "type", rb_jac_quadrature_type, 0); rb_define_method(cjacq, "alpha", rb_jac_quadrature_alpha, 0); rb_define_method(cjacq, "beta", rb_jac_quadrature_beta, 0); rb_define_method(cjacq, "x", rb_jac_quadrature_x, 0); rb_define_method(cjacq, "w", rb_jac_quadrature_w, 0); rb_define_method(cjacq, "D", rb_jac_quadrature_D, 0); rb_define_method(cjacq, "xp", rb_jac_quadrature_xp, 0); rb_define_method(cjacq, "interpmat_alloc", rb_jac_interpmat_alloc, -1); rb_define_method(cjacq, "interpmat_free", rb_jac_interpmat_free, 0); rb_define_method(cjacq, "zwd", rb_jac_quadrature_zwd, -1); rb_define_method(cjacq, "integrate", rb_jac_integrate, 1); rb_define_method(cjacq, "interpolate", rb_jac_interpolate, -1); rb_define_method(cjacq, "differentiate", rb_jac_differentiate, -1); /*****/ rb_define_module_function(mjac, "diffmat_gj", rb_jac_diffmat_gj, -1); rb_define_module_function(mjac, "diffmat_glj", rb_jac_diffmat_glj, -1); rb_define_module_function(mjac, "diffmat_grjm", rb_jac_diffmat_grjm, -1); rb_define_module_function(mjac, "diffmat_grjp", rb_jac_diffmat_grjp, -1); rb_define_module_function(mjac, "weights_gj", rb_jac_weights_gj, -1); rb_define_module_function(mjac, "weights_glj", rb_jac_weights_glj, -1); rb_define_module_function(mjac, "weights_grjm", rb_jac_weights_grjm, -1); rb_define_module_function(mjac, "weights_grjp", rb_jac_weights_grjp, -1); rb_define_module_function(mjac, "zeros_gj", rb_jac_zeros_gj, -1); rb_define_module_function(mjac, "zeros_glj", rb_jac_zeros_glj, -1); rb_define_module_function(mjac, "zeros_grjm", rb_jac_zeros_grjm, -1); rb_define_module_function(mjac, "zeros_grjp", rb_jac_zeros_grjp, -1); rb_define_module_function(mjac, "lagrange_gj", rb_jac_lagrange_gj, -1); rb_define_module_function(mjac, "lagrange_glj", rb_jac_lagrange_glj, -1); rb_define_module_function(mjac, "lagrange_grjm", rb_jac_lagrange_grjm, -1); rb_define_module_function(mjac, "lagrange_grjp", rb_jac_lagrange_grjp, -1); rb_define_module_function(mjac, "interpmat_gj", rb_jac_interpmat_gj, -1); rb_define_module_function(mjac, "interpmat_glj", rb_jac_interpmat_glj, -1); rb_define_module_function(mjac, "interpmat_grjm", rb_jac_interpmat_grjm, -1); rb_define_module_function(mjac, "interpmat_grjp", rb_jac_interpmat_grjp, -1); } #endif gsl-1.15.3/ext/sf_synchrotron.c0000644000175000017500000000316412220252463015772 0ustar boutilboutil/* sf_synchrotron.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_synchrotron_1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_synchrotron_1, x); } static VALUE rb_gsl_sf_synchrotron_1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_synchrotron_1_e, x); } static VALUE rb_gsl_sf_synchrotron_2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_synchrotron_2, x); } static VALUE rb_gsl_sf_synchrotron_2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_synchrotron_2_e, x); } void Init_gsl_sf_synchrotron(VALUE module) { VALUE mgsl_sf_synch; rb_define_module_function(module, "synchrotron_1", rb_gsl_sf_synchrotron_1, 1); rb_define_module_function(module, "synchrotron_1_e", rb_gsl_sf_synchrotron_1_e, 1); rb_define_module_function(module, "synchrotron_2", rb_gsl_sf_synchrotron_2, 1); rb_define_module_function(module, "synchrotron_2_e", rb_gsl_sf_synchrotron_2_e, 1); mgsl_sf_synch = rb_define_module_under(module, "Synchrotron"); rb_define_module_function(mgsl_sf_synch, "one", rb_gsl_sf_synchrotron_1, 1); rb_define_module_function(mgsl_sf_synch, "one_e", rb_gsl_sf_synchrotron_1_e, 1); rb_define_module_function(mgsl_sf_synch, "two", rb_gsl_sf_synchrotron_2, 1); rb_define_module_function(mgsl_sf_synch, "two_e", rb_gsl_sf_synchrotron_2_e, 1); } gsl-1.15.3/ext/fresnel.c0000644000175000017500000001776012220252463014357 0ustar boutilboutil/**************************************************************************** * fresnel.c - * Calculation of Fresnel integrals by expansion to Chebyshev series * Expansions are taken from the book * Y.L. Luke. Mathematical functions and their approximations. * Moscow, "Mir", 1980. PP. 145-149 (Russian edition) **************************************************************************** */ /* Modified for Ruby bindings 2006/Dec/24 Y. TSUNESADA */ #include #include "rb_gsl.h" #include "rb_gsl_sf.h" static const double sqrt_pi_2 = 1.2533141373155002512078826424; /* sqrt(pi/2) */ static const double sqrt_2_pi = 0.7978845608028653558798921199; /* sqrt(2/pi) */ static const double _1_sqrt_2pi = 0.3989422804014326779399460599; /* 1/sqrt(2*pi) */ static const double pi_2 = 1.5707963267948966192313216916; /* pi/2 */ static double f_data_a[18] = { 0.76435138664186000189, -0.43135547547660179313, 0.43288199979726653054, -0.26973310338387111029, 0.08416045320876935378, -0.01546524484461381958, 0.00187855423439822018, -0.00016264977618887547, 0.00001057397656383260, -0.00000053609339889243, 0.00000002181658454933, -0.00000000072901621186, 0.00000000002037332546, -0.00000000000048344033, 0.00000000000000986533, -0.00000000000000017502, 0.00000000000000000272, -0.00000000000000000004 }; static double f_data_b[17] = { 0.63041404314570539241, -0.42344511405705333544, 0.37617172643343656625, -0.16249489154509567415, 0.03822255778633008694, -0.00564563477132190899, 0.00057454951976897367, -0.00004287071532102004, 0.00000245120749923299, -0.00000011098841840868, 0.00000000408249731696, -0.00000000012449830219, 0.00000000000320048425, -0.00000000000007032416, 0.00000000000000133638, -0.00000000000000002219, 0.00000000000000000032 }; static double fresnel_cos_0_8(double x) { double x_8 = x/8.0; double xx = 2.0*x_8*x_8 - 1.0; double t0 = 1.0; double t1 = xx; double sumC = f_data_a[0] + f_data_a[1]*t1; double t2; int n; for (n=2; n < 18; n++) { t2 = 2.0*xx*t1 - t0; sumC += f_data_a[n]*t2; t0 = t1; t1 = t2; } return _1_sqrt_2pi*sqrt(x)*sumC; } static double fresnel_sin_0_8(double x) { double x_8 = x/8.0; double xx = 2.0*x_8*x_8 - 1.0; double t0 = 1.; double t1 = xx; double ot1 = x_8; double ot2 = 2.0*x_8*t1 - ot1; double sumS = f_data_b[0]*ot1 + f_data_b[1]*ot2; int n; double t2; for (n=2; n < 17; n++) { t2 = 2.0*xx*t1 - t0; ot1 = ot2; ot2 = 2.0*x_8*t2 - ot1; sumS += f_data_b[n]*ot2; t0 = t1; t1 = t2; } return _1_sqrt_2pi*sqrt(x)*sumS; } static double f_data_e[41] = { 0.97462779093296822410, -0.02424701873969321371, 0.00103400906842977317, -0.00008052450246908016, 0.00000905962481966582, -0.00000131016996757743, 0.00000022770820391497, -0.00000004558623552026, 0.00000001021567537083, -0.00000000251114508133, 0.00000000066704761275, -0.00000000018931512852, 0.00000000005689898935, -0.00000000001798219359, 0.00000000000594162963, -0.00000000000204285065, 0.00000000000072797580, -0.00000000000026797428, 0.00000000000010160694, -0.00000000000003958559, 0.00000000000001581262, -0.00000000000000646411, 0.00000000000000269981, -0.00000000000000115038, 0.00000000000000049942, -0.00000000000000022064, 0.00000000000000009910, -0.00000000000000004520, 0.00000000000000002092, -0.00000000000000000982, 0.00000000000000000467, -0.00000000000000000225, 0.00000000000000000110, -0.00000000000000000054, 0.00000000000000000027, -0.00000000000000000014, 0.00000000000000000007, -0.00000000000000000004, 0.00000000000000000002, -0.00000000000000000001, 0.00000000000000000001 }; static double f_data_f[35] = { 0.99461545179407928910, -0.00524276766084297210, 0.00013325864229883909, -0.00000770856452642713, 0.00000070848077032045, -0.00000008812517411602, 0.00000001359784717148, -0.00000000246858295747, 0.00000000050925789921, -0.00000000011653400634, 0.00000000002906578309, -0.00000000000779847361, 0.00000000000222802542, -0.00000000000067239338, 0.00000000000021296411, -0.00000000000007041482, 0.00000000000002419805, -0.00000000000000861080, 0.00000000000000316287, -0.00000000000000119596, 0.00000000000000046444, -0.00000000000000018485, 0.00000000000000007527, -0.00000000000000003131, 0.00000000000000001328, -0.00000000000000000574, 0.00000000000000000252, -0.00000000000000000113, 0.00000000000000000051, -0.00000000000000000024, 0.00000000000000000011, -0.00000000000000000005, 0.00000000000000000002, -0.00000000000000000001, 0.00000000000000000001 }; static double fresnel_cos_8_inf(double x) { double xx = 128.0/(x*x) - 1.0; /* 2.0*(8/x)^2 - 1 */ double t0 = 1.0; double t1 = xx; double sumP = f_data_e[0] + f_data_e[1]*t1; double sumQ = f_data_f[0] + f_data_f[1]*t1; double t2; int n; for(n = 2; n < 35; n++) { t2 = 2.0*xx*t1 - t0; sumP += f_data_e[n]*t2; /* sumP += f_data_e[n]*ChebyshevT(n,xx) */ sumQ += f_data_f[n]*t2; /* sumQ += f_data_f[n]*ChebyshevT(n,xx) */ t0 = t1; t1 = t2; } for(n = 35; n < 41; n++) { t2 = 2.0*xx*t1 - t0; sumP += f_data_e[n]*t2; /* sumP += f_data_e[n]*ChebyshevT(n,xx) */ t0 = t1; t1 = t2; } return 0.5 - _1_sqrt_2pi*(0.5*sumP*cos(x)/x - sumQ*sin(x))/sqrt(x); } static double fresnel_sin_8_inf(double x) { double xx = 128.0/(x*x) - 1.0; /* 2.0*(8/x)^2 - 1 */ double t0 = 1.0; double t1 = xx; double sumP = f_data_e[0] + f_data_e[1]*t1; double sumQ = f_data_f[0] + f_data_f[1]*t1; double t2; int n; for(n = 2; n < 35; n++) { t2 = 2.0*xx*t1 - t0; sumP += f_data_e[n]*t2; /* sumP += f_data_e[n]*ChebyshevT(n,xx) */ sumQ += f_data_f[n]*t2; /* sumQ += f_data_f[n]*ChebyshevT(n,xx) */ t0 = t1; t1 = t2; } for(n = 35; n < 41; n++) { t2 = 2.0*xx*t1 - t0; sumP += f_data_e[n]*t2; /* sumQ += f_data_f[n]*ChebyshevT(n,xx) */ t0 = t1; t1 = t2; } return 0.5 - _1_sqrt_2pi*(0.5*sumP*sin(x)/x + sumQ*cos(x))/sqrt(x); } double fresnel_c(double x) { double xx = x*x*pi_2; double ret_val; if(xx<=8.0) ret_val = fresnel_cos_0_8(xx); else ret_val = fresnel_cos_8_inf(xx); return (x<0.0) ? -ret_val : ret_val; } double fresnel_s(double x) { double xx = x*x*pi_2; double ret_val; if(xx<=8.0) ret_val = fresnel_sin_0_8(xx); else ret_val = fresnel_sin_8_inf(xx); return (x<0.0) ? -ret_val : ret_val; } double fresnel_c1(double x) { return fresnel_c(x*sqrt_2_pi); } double fresnel_s1(double x) { return fresnel_s(x*sqrt_2_pi); } static VALUE rb_fresnel_c(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(fresnel_c, x); } static VALUE rb_fresnel_s(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(fresnel_s, x); } static VALUE rb_fresnel_c1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(fresnel_c1, x); } static VALUE rb_fresnel_s1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(fresnel_s1, x); } void Init_fresnel(VALUE module) { VALUE mfresnel; mfresnel = rb_define_module_under(module, "Fresnel"); rb_define_module_function(module, "fresnel_c", rb_fresnel_c, 1); rb_define_module_function(module, "fresnel_s", rb_fresnel_s, 1); rb_define_module_function(module, "fresnel_c1", rb_fresnel_c1, 1); rb_define_module_function(module, "fresnel_s1", rb_fresnel_s1, 1); rb_define_module_function(mfresnel, "c", rb_fresnel_c, 1); rb_define_module_function(mfresnel, "s", rb_fresnel_s, 1); rb_define_module_function(mfresnel, "c1", rb_fresnel_c1, 1); rb_define_module_function(mfresnel, "s1", rb_fresnel_s1, 1); } gsl-1.15.3/ext/linalg_complex.c0000644000175000017500000005730512220252463015715 0ustar boutilboutil/* linalg_complex.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include #include "rb_gsl_array.h" #include "rb_gsl_common.h" #include "rb_gsl_linalg.h" EXTERN VALUE mgsl_linalg; EXTERN VALUE cgsl_complex; static VALUE cgsl_matrix_complex_LU; #ifdef GSL_1_10_LATER static VALUE cgsl_matrix_complex_C; #endif VALUE rb_gsl_linalg_complex_LU_decomp(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL; gsl_permutation *p = NULL; int signum, itmp; size_t size; VALUE obj2; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); itmp = 1; break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, m); itmp = 0; } size = m->size1; switch (argc-itmp) { case 0: p = gsl_permutation_alloc(size); gsl_linalg_complex_LU_decomp(m, p, &signum); if (itmp == 1) RBASIC(argv[0])->klass = cgsl_matrix_complex_LU; else RBASIC(obj)->klass = cgsl_matrix_complex_LU; obj2 = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); return rb_ary_new3(2, obj2, INT2FIX(signum)); break; case 1: /* when a permutation object is given */ CHECK_PERMUTATION(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_permutation, p); gsl_linalg_complex_LU_decomp(m, p, &signum); if (itmp == 1) RBASIC(argv[0])->klass = cgsl_matrix_complex_LU; else RBASIC(obj)->klass = cgsl_matrix_complex_LU; return INT2FIX(signum); break; default: rb_raise(rb_eArgError, "Usage: LU_decomp!() or LU_decomp!(permutation)"); } } VALUE rb_gsl_linalg_complex_LU_decomp2(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mnew = NULL; gsl_permutation *p = NULL; int signum, itmp; size_t size; VALUE objm, obj2; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); itmp = 1; break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, m); itmp = 0; } size = m->size1; mnew = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mnew, m); objm = Data_Wrap_Struct(cgsl_matrix_complex_LU, 0, gsl_matrix_complex_free, mnew); switch (argc-itmp) { case 0: p = gsl_permutation_alloc(size); gsl_linalg_complex_LU_decomp(mnew, p, &signum); obj2 = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); return rb_ary_new3(3, objm ,obj2, INT2FIX(signum)); break; case 1: /* when a permutation object is given */ CHECK_PERMUTATION(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_permutation, p); gsl_linalg_complex_LU_decomp(m, p, &signum); return rb_ary_new3(3, objm , argv[itmp], INT2FIX(signum)); break; default: rb_raise(rb_eArgError, "Usage: LU_decomp!() or LU_decomp!(permutation)"); } } static VALUE rb_gsl_linalg_complex_LU_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_vector_complex *b = NULL, *x = NULL; int flagm = 0, flagx = 0, itmp, signum; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2 || argc > 4) rb_raise(rb_eArgError, "Usage: solve(m, b), solve(m, b, x), solve(lu, p, b), solve(lu, p, b, x)"); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 1; break; default: if (argc < 1 || argc > 3) rb_raise(rb_eArgError, "Usage: LU_solve(b), LU_solve(p, b), LU_solve(b, x), solve(p, b, x)"); Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 0; } if (flagm == 1) { if (itmp != argc-1) rb_raise(rb_eArgError, "Usage: m.LU_solve(b)"); Data_Get_Struct(argv[itmp], gsl_vector_complex, b); x = gsl_vector_complex_alloc(b->size); p = gsl_permutation_alloc(b->size); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { Data_Get_Struct(argv[itmp], gsl_permutation, p); itmp++; Data_Get_Struct(argv[itmp], gsl_vector_complex, b); itmp++; if (itmp == argc-1) { Data_Get_Struct(argv[itmp], gsl_vector_complex, x); flagx = 1; } else { x = gsl_vector_complex_alloc(m->size1); } } gsl_linalg_complex_LU_solve(mtmp, p, b, x); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } if (flagx == 0) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, x); else return argv[argc-1]; } static VALUE rb_gsl_linalg_complex_LU_svx(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_vector_complex *x = NULL; int flagm = 0, itmp, signum; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 1; break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 0; } if (flagm == 1) { if (itmp != argc-1) rb_raise(rb_eArgError, "Usage: m.LU_solve(b)"); Data_Get_Struct(argv[itmp], gsl_vector_complex, x); p = gsl_permutation_alloc(x->size); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { Data_Get_Struct(argv[itmp], gsl_permutation, p); itmp++; Data_Get_Struct(argv[itmp], gsl_vector_complex, x); itmp++; } gsl_linalg_complex_LU_svx(mtmp, p, x); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return argv[argc-1]; } static VALUE rb_gsl_linalg_complex_LU_refine(VALUE obj, VALUE vm, VALUE lu, VALUE pp, VALUE bb, VALUE xx) { gsl_matrix_complex *m = NULL, *mlu = NULL; gsl_permutation *p = NULL; gsl_vector_complex *b = NULL, *x = NULL, *r = NULL; int flagb = 0; VALUE vr; if (CLASS_OF(obj) != cgsl_matrix_complex_LU) rb_raise(rb_eRuntimeError, "Decompose first!"); CHECK_MATRIX_COMPLEX(vm); CHECK_MATRIX_COMPLEX(lu); CHECK_PERMUTATION(pp); CHECK_VECTOR_COMPLEX(xx); Data_Get_Struct(vm, gsl_matrix_complex, m); Data_Get_Struct(lu, gsl_matrix_complex, mlu); Data_Get_Struct(pp, gsl_permutation, p); CHECK_VECTOR_COMPLEX(bb); Data_Get_Struct(bb, gsl_vector_complex, b); Data_Get_Struct(xx, gsl_vector_complex, x); r = gsl_vector_complex_alloc(m->size1); gsl_linalg_complex_LU_refine(m, mlu, p, b, x, r); vr = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r); if (flagb == 1) gsl_vector_complex_free(b); return rb_ary_new3(2, xx, vr); } static VALUE rb_gsl_linalg_complex_LU_invert(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL, *inverse = NULL; gsl_permutation *p = NULL; int flagm = 0, signum, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 1; break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 0; } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { Data_Get_Struct(argv[itmp], gsl_permutation, p); } inverse = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_linalg_complex_LU_invert(mtmp, p, inverse); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, inverse); } #ifdef GSL_1_1_1_LATER static VALUE rb_gsl_linalg_complex_LU_det(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_complex *z = NULL; VALUE vz; int flagm = 0, signum, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 1; break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 0; } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { if (itmp != argc-1) rb_raise(rb_eArgError, "signum not given"); signum = NUM2DBL(argv[itmp]); } vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, z); *z = gsl_linalg_complex_LU_det(mtmp, signum); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return vz; } static VALUE rb_gsl_linalg_complex_LU_lndet(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; double lndet; int flagm = 0, signum; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } lndet = gsl_linalg_complex_LU_lndet(mtmp); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return rb_float_new(lndet); } static VALUE rb_gsl_linalg_complex_LU_sgndet(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_complex *z = NULL; VALUE vz; int flagm = 0, signum, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 1; break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 0; } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { if (itmp != argc-1) rb_raise(rb_eArgError, "signum not given"); signum = NUM2DBL(argv[itmp]); } vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, z); *z = gsl_linalg_complex_LU_sgndet(mtmp, signum); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return vz; } #endif #ifdef GSL_1_10_LATER static VALUE rb_gsl_linalg_cholesky_decomp(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *Atmp = NULL; switch(TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, Atmp); break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, Atmp); break; } A = make_matrix_complex_clone(Atmp); gsl_linalg_complex_cholesky_decomp(A); return Data_Wrap_Struct(cgsl_matrix_complex_C, 0, gsl_matrix_complex_free, A); } static VALUE rb_gsl_linalg_cholesky_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *Atmp = NULL; gsl_vector_complex *b = NULL, *x = NULL; int flagb = 0, flaga = 0; VALUE vA, vb; switch(TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); vA = argv[0]; vb = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); vA = obj; vb = argv[0]; break; } CHECK_MATRIX_COMPLEX(vA); Data_Get_Struct(vA, gsl_matrix_complex, Atmp); CHECK_VECTOR_COMPLEX(vb); Data_Get_Struct(vb, gsl_vector_complex, b); if (CLASS_OF(vA) == cgsl_matrix_complex_C) { A = Atmp; } else { A = make_matrix_complex_clone(Atmp); flaga = 1; gsl_linalg_complex_cholesky_decomp(A); } x = gsl_vector_complex_alloc(b->size); gsl_linalg_complex_cholesky_solve(A, b, x); if (flaga == 1) gsl_matrix_complex_free(A); if (flagb == 1) gsl_vector_complex_free(b); return Data_Wrap_Struct(cgsl_vector_complex_col, 0, gsl_vector_complex_free, x); } static VALUE rb_gsl_linalg_cholesky_svx(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *Atmp = NULL; gsl_vector_complex *b = NULL; int flaga = 0; VALUE vA, vb; switch(TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 2) rb_raise(rb_eArgError, "wrong number of argument (%d for 2)", argc); vA = argv[0]; vb = argv[1]; break; default: if (argc != 1) rb_raise(rb_eArgError, "wrong number of argument (%d for 1)", argc); vA = obj; vb = argv[0]; break; } CHECK_MATRIX_COMPLEX(vA); Data_Get_Struct(vA, gsl_matrix_complex, Atmp); CHECK_VECTOR_COMPLEX(vb); Data_Get_Struct(vb, gsl_vector_complex, b); if (CLASS_OF(vA) == cgsl_matrix_complex_C) { A = Atmp; } else { A = make_matrix_complex_clone(Atmp); flaga = 1; gsl_linalg_complex_cholesky_decomp(A); } gsl_linalg_complex_cholesky_svx(A, b); if (flaga == 1) gsl_matrix_complex_free(A); return vb; } static VALUE rb_gsl_linalg_complex_householder_transform(int argc, VALUE *argv, VALUE obj) { gsl_vector_complex *v = NULL; gsl_complex *z; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 1) rb_raise(rb_eArgError, "too few arguments."); CHECK_VECTOR_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_vector_complex, v); break; default: Data_Get_Struct(obj, gsl_vector_complex, v); break; } z = (gsl_complex*) malloc(sizeof(gsl_complex)); *z = gsl_linalg_complex_householder_transform(v); return Data_Wrap_Struct(cgsl_complex, 0, free, z); } /* singleton */ static VALUE rb_gsl_linalg_complex_householder_hm(VALUE obj, VALUE t, VALUE vv, VALUE aa) { gsl_vector_complex *v = NULL; gsl_complex *tau; gsl_matrix_complex *A = NULL; CHECK_COMPLEX(t); CHECK_VECTOR_COMPLEX(vv); CHECK_MATRIX_COMPLEX(aa); Data_Get_Struct(t, gsl_complex, tau); Data_Get_Struct(vv, gsl_vector_complex, v); Data_Get_Struct(aa, gsl_matrix_complex, A); gsl_linalg_complex_householder_hm(*tau, v, A); return aa; } static VALUE rb_gsl_linalg_complex_householder_mh(VALUE obj, VALUE t, VALUE vv, VALUE aa) { gsl_vector_complex *v = NULL; gsl_complex *tau; gsl_matrix_complex *A = NULL; CHECK_COMPLEX(t); CHECK_VECTOR_COMPLEX(vv); CHECK_MATRIX_COMPLEX(aa); Data_Get_Struct(t, gsl_complex, tau); Data_Get_Struct(vv, gsl_vector_complex, v); Data_Get_Struct(aa, gsl_matrix_complex, A); gsl_linalg_complex_householder_hm(*tau, v, A); return aa; } static VALUE rb_gsl_linalg_complex_householder_hv(VALUE obj, VALUE t, VALUE vv, VALUE ww) { gsl_vector_complex *v = NULL, *w = NULL; gsl_complex *tau; CHECK_COMPLEX(t); CHECK_VECTOR_COMPLEX(vv); CHECK_VECTOR_COMPLEX(ww); Data_Get_Struct(t, gsl_complex, tau); Data_Get_Struct(vv, gsl_vector_complex, v); Data_Get_Struct(ww, gsl_vector_complex, w); gsl_linalg_complex_householder_hv(*tau, v, w); return ww; } #endif void Init_gsl_linalg_complex(VALUE module) { VALUE mgsl_linalg_complex; VALUE mgsl_linalg_complex_LU; mgsl_linalg_complex = rb_define_module_under(module, "Complex"); mgsl_linalg_complex_LU = rb_define_module_under(mgsl_linalg_complex, "LU"); cgsl_matrix_complex_LU = rb_define_class_under(mgsl_linalg_complex_LU, "LUMatrix", cgsl_matrix_complex); rb_define_singleton_method(mgsl_linalg_complex, "LU_decomp!", rb_gsl_linalg_complex_LU_decomp, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "decomp!", rb_gsl_linalg_complex_LU_decomp, -1); rb_define_method(cgsl_matrix_complex, "LU_decomp!", rb_gsl_linalg_complex_LU_decomp, -1); rb_define_alias(cgsl_matrix_complex, "decomp!", "LU_decomp!"); rb_define_singleton_method(mgsl_linalg_complex, "LU_decomp", rb_gsl_linalg_complex_LU_decomp2, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "decomp", rb_gsl_linalg_complex_LU_decomp2, -1); rb_define_method(cgsl_matrix_complex, "LU_decomp", rb_gsl_linalg_complex_LU_decomp2, -1); rb_define_alias(cgsl_matrix_complex, "decomp", "LU_decomp"); rb_define_singleton_method(mgsl_linalg_complex, "LU_solve", rb_gsl_linalg_complex_LU_solve, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "solve", rb_gsl_linalg_complex_LU_solve, -1); rb_define_method(cgsl_matrix_complex, "LU_solve", rb_gsl_linalg_complex_LU_solve, -1); rb_define_method(cgsl_matrix_complex_LU, "solve", rb_gsl_linalg_complex_LU_solve, -1); rb_define_singleton_method(mgsl_linalg_complex, "LU_svx", rb_gsl_linalg_complex_LU_svx, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "svx", rb_gsl_linalg_complex_LU_svx, -1); rb_define_method(cgsl_matrix_complex, "LU_svx", rb_gsl_linalg_complex_LU_svx, -1); rb_define_method(cgsl_matrix_complex_LU, "svx", rb_gsl_linalg_complex_LU_svx, -1); rb_define_singleton_method(mgsl_linalg_complex, "LU_refine", rb_gsl_linalg_complex_LU_refine, 5); rb_define_singleton_method(mgsl_linalg_complex_LU, "refine", rb_gsl_linalg_complex_LU_refine, 5); rb_define_singleton_method(mgsl_linalg_complex, "LU_invert", rb_gsl_linalg_complex_LU_invert, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "invert", rb_gsl_linalg_complex_LU_invert, -1); rb_define_method(cgsl_matrix_complex, "LU_invert", rb_gsl_linalg_complex_LU_invert, -1); rb_define_alias(cgsl_matrix_complex, "invert", "LU_invert"); rb_define_alias(cgsl_matrix_complex, "inv", "LU_invert"); rb_define_method(cgsl_matrix_complex_LU, "invert", rb_gsl_linalg_complex_LU_invert, -1); #ifdef GSL_1_1_1_LATER rb_define_singleton_method(mgsl_linalg_complex, "LU_det", rb_gsl_linalg_complex_LU_det, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "det", rb_gsl_linalg_complex_LU_det, -1); rb_define_method(cgsl_matrix_complex, "LU_det", rb_gsl_linalg_complex_LU_det, -1); rb_define_alias(cgsl_matrix_complex, "det", "LU_det"); rb_define_method(cgsl_matrix_complex_LU, "det", rb_gsl_linalg_complex_LU_det, -1); rb_define_singleton_method(mgsl_linalg_complex, "LU_lndet", rb_gsl_linalg_complex_LU_lndet, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "lndet", rb_gsl_linalg_complex_LU_lndet, -1); rb_define_method(cgsl_matrix_complex, "LU_lndet", rb_gsl_linalg_complex_LU_lndet, -1); rb_define_alias(cgsl_matrix_complex, "lndet", "LU_lndet"); rb_define_method(cgsl_matrix_complex_LU, "LU_lndet", rb_gsl_linalg_complex_LU_lndet, -1); rb_define_singleton_method(mgsl_linalg_complex, "LU_sgndet", rb_gsl_linalg_complex_LU_sgndet, -1); rb_define_singleton_method(mgsl_linalg_complex_LU, "sgndet", rb_gsl_linalg_complex_LU_sgndet, -1); rb_define_method(cgsl_matrix_complex, "LU_sgndet", rb_gsl_linalg_complex_LU_sgndet, -1); rb_define_alias(cgsl_matrix_complex, "sgndet", "LU_sgndet"); rb_define_method(cgsl_matrix_complex_LU, "LU_sgndet", rb_gsl_linalg_complex_LU_sgndet, -1); #endif #ifdef GSL_1_10_LATER VALUE mgsl_linalg_complex_chol; mgsl_linalg_complex_chol = rb_define_module_under(mgsl_linalg_complex, "Cholesky"); cgsl_matrix_complex_C = rb_define_class_under(mgsl_linalg_complex_chol, "CholeskyMatrix", cgsl_matrix_complex); rb_define_singleton_method(mgsl_linalg_complex_chol, "decomp", rb_gsl_linalg_cholesky_decomp, -1); rb_define_method(cgsl_matrix_complex, "cholesky_decomp", rb_gsl_linalg_cholesky_decomp, -1); rb_define_singleton_method(mgsl_linalg_complex_chol, "solve", rb_gsl_linalg_cholesky_solve, -1); rb_define_method(cgsl_matrix_complex, "cholesky_solve", rb_gsl_linalg_cholesky_solve, -1); rb_define_method(cgsl_matrix_complex_C, "solve", rb_gsl_linalg_cholesky_solve, -1); rb_define_singleton_method(mgsl_linalg_complex_chol, "svx", rb_gsl_linalg_cholesky_svx, -1); rb_define_method(cgsl_matrix_complex, "cholesky_svx", rb_gsl_linalg_cholesky_svx, -1); rb_define_method(cgsl_matrix_complex_C, "svx", rb_gsl_linalg_cholesky_svx, -1); VALUE mgsl_linalg_complex_Householder = rb_define_module_under(mgsl_linalg_complex, "Householder"); rb_define_singleton_method(mgsl_linalg_complex, "householder_transform", rb_gsl_linalg_complex_householder_transform, -1); rb_define_singleton_method(mgsl_linalg_complex_Householder, "transform", rb_gsl_linalg_complex_householder_transform, -1); rb_define_method(cgsl_vector_complex, "householder_transform", rb_gsl_linalg_complex_householder_transform, -1); rb_define_singleton_method(mgsl_linalg_complex, "householder_hm", rb_gsl_linalg_complex_householder_hm, 3); rb_define_singleton_method(mgsl_linalg_complex_Householder, "hm", rb_gsl_linalg_complex_householder_hm, 3); rb_define_singleton_method(mgsl_linalg_complex, "householder_mh", rb_gsl_linalg_complex_householder_mh, 3); rb_define_singleton_method(mgsl_linalg_complex_Householder, "mh", rb_gsl_linalg_complex_householder_mh, 3); rb_define_singleton_method(mgsl_linalg_complex, "householder_hv", rb_gsl_linalg_complex_householder_hv, 3); rb_define_singleton_method(mgsl_linalg_complex_Householder, "hv", rb_gsl_linalg_complex_householder_hv, 3); #endif } gsl-1.15.3/ext/sf.c0000644000175000017500000012340512220252463013323 0ustar boutilboutil/* sf.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_array.h" #include "rb_gsl_sf.h" #ifdef HAVE_NARRAY_H #include "narray.h" #endif VALUE cgsl_sf_result, cgsl_sf_result_e10; VALUE rb_gsl_sf_result_new(VALUE klass) { gsl_sf_result *rslt = NULL; return Data_Make_Struct(klass, gsl_sf_result, 0, free, rslt); } static VALUE rb_gsl_sf_result_print(VALUE obj) { gsl_sf_result *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result, rslt); printf("%10.9e %10.9e\n", rslt->val, rslt->err); return obj; } static VALUE rb_gsl_sf_result_to_s(VALUE obj); static VALUE rb_gsl_sf_result_inspect(VALUE obj) { char buf[64]; VALUE str; sprintf(buf, "%s\n", rb_class2name(CLASS_OF(obj))); str = rb_str_new2(buf); return rb_str_concat(str, rb_gsl_sf_result_to_s(obj)); } static VALUE rb_gsl_sf_result_val(VALUE obj) { gsl_sf_result *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result, rslt); return rb_float_new(rslt->val); } static VALUE rb_gsl_sf_result_err(VALUE obj) { gsl_sf_result *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result, rslt); return rb_float_new(rslt->err); } static VALUE rb_gsl_sf_result_to_a(VALUE obj) { gsl_sf_result *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result, rslt); return rb_ary_new3(2, rb_float_new(rslt->val), rb_float_new(rslt->err)); } static VALUE rb_gsl_sf_result_to_s(VALUE obj) { gsl_sf_result *rslt = NULL; char str[32]; Data_Get_Struct(obj, gsl_sf_result, rslt); sprintf(str, "%10.9e %10.9e", rslt->val, rslt->err); return rb_str_new2(str); } static VALUE rb_gsl_sf_result_e10_new(VALUE klass) { gsl_sf_result_e10 *rslt = NULL; return Data_Make_Struct(cgsl_sf_result, gsl_sf_result_e10, 0, free, rslt); } static VALUE rb_gsl_sf_result_e10_val(VALUE obj) { gsl_sf_result_e10 *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result_e10, rslt); return rb_float_new(rslt->val); } static VALUE rb_gsl_sf_result_e10_err(VALUE obj) { gsl_sf_result_e10 *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result_e10, rslt); return rb_float_new(rslt->err); } static VALUE rb_gsl_sf_result_e10_e10(VALUE obj) { gsl_sf_result_e10 *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result_e10, rslt); return INT2FIX(rslt->e10); } static VALUE rb_gsl_sf_result_e10_to_a(VALUE obj) { gsl_sf_result_e10 *rslt = NULL; Data_Get_Struct(obj, gsl_sf_result_e10, rslt); return rb_ary_new3(2, rb_float_new(rslt->val), rb_float_new(rslt->err)); } static VALUE rb_gsl_sf_result_e10_to_s(VALUE obj) { gsl_sf_result_e10 *rslt = NULL; char str[32]; Data_Get_Struct(obj, gsl_sf_result_e10, rslt); sprintf(str, "%10.9e %10.9e\n", rslt->val, rslt->err); return rb_str_new2(str); } VALUE rb_gsl_sf_eval1(double (*func)(double), VALUE argv) { if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(NUM2DBL(argv))); break; case T_ARRAY: return rb_gsl_ary_eval1(argv, func); break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { return rb_gsl_nary_eval1(argv, func); } #endif if (MATRIX_P(argv)) { return matrix_eval_create(argv, func); } else if (VECTOR_P(argv)) { return vector_eval_create(argv, func); } else if (COMPLEX_P(argv) || VECTOR_COMPLEX_P(argv) || MATRIX_COMPLEX_P(argv)) { return rb_gsl_sf_eval_complex(func, argv); } else { rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(argv))); } break; } } VALUE rb_gsl_sf_eval_int_double(double (*func)(int, double), VALUE jj, VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, xx; size_t i, j, k, n; double val; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif CHECK_FIXNUM(jj); j = FIX2INT(jj); if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(j, NUM2DBL(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(j, NUM2DBL(xx)); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(j, ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)(j, gsl_matrix_get(m, i, k)); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(j, gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double_int(double (*func)(double, int), VALUE argv, VALUE jj) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, xx; size_t i, j, k, n; double val; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif CHECK_FIXNUM(jj); j = FIX2INT(jj); if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(NUM2DBL(argv), j)); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(NUM2DBL(xx), j); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(ptr1[i], j); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)(gsl_matrix_get(m, i, k), j); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(gsl_vector_get(v, i), j); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } return Qnil; } VALUE rb_gsl_sf_eval_int_int_double(double (*func)(int, int, double), VALUE jj, VALUE jj2, VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, xx; size_t i, j, k, j2, n; double val; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif CHECK_FIXNUM(jj); CHECK_FIXNUM(jj2); j = FIX2INT(jj); j2 = FIX2INT(jj2); if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(j, j2, NUM2DBL(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(j, j2, NUM2DBL(xx)); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(j, j2, ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)(j, j2, gsl_matrix_get(m, i, k)); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(j, j2, gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_int_double_double(double (*func)(int, double, double), VALUE jj, VALUE ff, VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, xx; size_t i, j, k, n; double f, val; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif CHECK_FIXNUM(jj); Need_Float(ff); j = FIX2INT(jj); f = NUM2DBL(ff); if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(j, f, NUM2DBL(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(j, f, NUM2DBL(xx)); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(j, f, ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)(j, f, gsl_matrix_get(m, i, k)); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(j, f, gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double_double(double (*func)(double, double), VALUE ff, VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, xx; size_t i, k, n; double val, f; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Need_Float(ff); f = NUM2DBL(ff); if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(f, NUM2DBL(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(f, NUM2DBL(xx)); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(f, ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { gsl_matrix_set(mnew, i, k, (*func)(f, gsl_matrix_get(m, i, k))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, (*func)(f, gsl_vector_get(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double3(double (*func)(double, double, double), VALUE ff, VALUE ff2, VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, xx; size_t i, k, n; double val, f, f2; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Need_Float(ff); Need_Float(ff2); f = NUM2DBL(ff); f2 = NUM2DBL(ff2); if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(f, f2, NUM2DBL(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(f, f2, NUM2DBL(xx)); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(f, f2, ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)(f, f2, gsl_matrix_get(m, i, k)); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(f, f2, gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double4(double (*func)(double, double, double, double), VALUE ff, VALUE ff2, VALUE ff3, VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary, xx; size_t i, k, n; double val, f, f2, f3; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Need_Float(ff); Need_Float(ff2); Need_Float(ff3); f = NUM2DBL(ff); f2 = NUM2DBL(ff2); f3 = NUM2DBL(ff3); if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(f, f2, f3, NUM2DBL(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(f, f2, f3, NUM2DBL(xx)); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(f, f2, f3, ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)(f, f2, f3, gsl_matrix_get(m, i, k)); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(f, f2, f3, gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval1_int(double (*func)(int), VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary; size_t i, k, n; double val; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*func)(NUM2INT(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { val = (*func)(NUM2INT(rb_ary_entry(argv, i))); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)((int) ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)((int) gsl_matrix_get(m, i, k)); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)((int) gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval1_uint(double (*func)(unsigned int), VALUE argv) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; VALUE ary; size_t i, k, n; double val; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*func)(NUM2UINT(argv))); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { val = (*func)(NUM2UINT(rb_ary_entry(argv, i))); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { argv = na_change_type(argv, NA_DFLOAT); ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)((unsigned int) ptr1[i]); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (k = 0; k < m->size2; k++) { val = (*func)((unsigned int) gsl_matrix_get(m, i, k)); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)((unsigned int) gsl_vector_get(v, i)); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double_m(double (*func)(double, gsl_mode_t), VALUE argv, VALUE m) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *mm = NULL, *mnew = NULL; VALUE ary, xx; size_t i, k, n; double val; gsl_mode_t mode; char c; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif switch (TYPE(m)) { case T_STRING: c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; break; case T_FIXNUM: mode = FIX2INT(m); break; default: rb_raise(rb_eArgError, "wrong type argument %s (String or Fixnum expected)", rb_class2name(CLASS_OF(m))); } if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(NUM2DBL(argv), m)); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(NUM2DBL(xx), m); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(ptr1[i], m); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, mm); mnew = gsl_matrix_alloc(mm->size1, mm->size2); for (i = 0; i < mm->size1; i++) { for (k = 0; k < mm->size2; k++) { val = (*func)(gsl_matrix_get(mm, i, k), m); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(gsl_vector_get(v, i), m); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double2_m(double (*func)(double, double, gsl_mode_t), VALUE argv, VALUE x2, VALUE m) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *mm = NULL, *mnew = NULL; VALUE ary, xx; size_t i, k, n; double val, xx2; gsl_mode_t mode; char c; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Need_Float(x2); xx2 = NUM2DBL(x2); c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(NUM2DBL(argv), xx2, m)); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(NUM2DBL(xx), xx2, m); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(ptr1[i], xx2, m); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, mm); mnew = gsl_matrix_alloc(mm->size1, mm->size2); for (i = 0; i < mm->size1; i++) { for (k = 0; k < mm->size2; k++) { val = (*func)(gsl_matrix_get(mm, i, k), xx2, m); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(gsl_vector_get(v, i), xx2, m); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double3_m(double (*func)(double, double, double, gsl_mode_t), VALUE argv, VALUE x2, VALUE x3, VALUE m) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *mm = NULL, *mnew = NULL; VALUE ary, xx; size_t i, k, n; double val, xx2, xx3; gsl_mode_t mode; char c; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Need_Float(x2); Need_Float(x3); xx2 = NUM2DBL(x2); xx3 = NUM2DBL(x3); c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(NUM2DBL(argv), xx2, xx3, m)); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(NUM2DBL(xx), xx2, xx3, m); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(ptr1[i], xx2, xx3, m); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, mm); mnew = gsl_matrix_alloc(mm->size1, mm->size2); for (i = 0; i < mm->size1; i++) { for (k = 0; k < mm->size2; k++) { val = (*func)(gsl_matrix_get(mm, i, k), xx2, xx3, m); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(gsl_vector_get(v, i), xx2, xx3, m); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_double4_m(double (*func)(double, double, double, double, gsl_mode_t), VALUE argv, VALUE x2, VALUE x3, VALUE x4, VALUE m) { gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *mm = NULL, *mnew = NULL; VALUE ary, xx; size_t i, k, n; double val, xx2, xx3, xx4; gsl_mode_t mode; char c; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Need_Float(x2); Need_Float(x3); Need_Float(x4); xx2 = NUM2DBL(x2); xx3 = NUM2DBL(x3); xx4 = NUM2DBL(x4); c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; if (CLASS_OF(argv) == rb_cRange) argv = rb_gsl_range2ary(argv); switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(NUM2DBL(argv), NUM2DBL(x2), NUM2DBL(x3), NUM2DBL(x4), m)); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(NUM2DBL(xx), xx2, xx3, xx4, m); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(ptr1[i], xx2, xx3, xx4, m); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, mm); mnew = gsl_matrix_alloc(mm->size1, mm->size2); for (i = 0; i < mm->size1; i++) { for (k = 0; k < mm->size2; k++) { val = (*func)(gsl_matrix_get(mm, i, k), xx2, xx3, xx4, m); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(gsl_vector_get(v, i), xx2, xx3, xx4, m); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_e(int (*func)(double, gsl_sf_result*), VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(x), rslt); return v; } VALUE rb_gsl_sf_eval_e_int(int (*func)(int, gsl_sf_result*), VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; CHECK_FIXNUM(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2INT(x), rslt); return v; } VALUE rb_gsl_sf_eval_e_uint(int (*func)(unsigned int, gsl_sf_result*), VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2UINT(x), rslt); return v; } VALUE rb_gsl_sf_eval_e_int_uint(int (*func)(int, unsigned int, gsl_sf_result*), VALUE n, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; CHECK_FIXNUM(n); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(FIX2INT(n), NUM2UINT(x), rslt); return v; } VALUE rb_gsl_sf_eval_e_double_uint(int (*func)(double, unsigned int, gsl_sf_result*), VALUE y, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(y); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(y), NUM2UINT(x), rslt); return v; } VALUE rb_gsl_sf_eval_e_int_double(int (*func)(int, double, gsl_sf_result*), VALUE n, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; CHECK_FIXNUM(n); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(FIX2INT(n), NUM2DBL(x), rslt); return v; } VALUE rb_gsl_sf_eval_e_int_double2(int (*func)(int, double, double, gsl_sf_result*), VALUE n, VALUE x1, VALUE x2) { gsl_sf_result *rslt = NULL; VALUE v; int status; CHECK_FIXNUM(n); Need_Float(x1); Need_Float(x2); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(FIX2INT(n), NUM2DBL(x1), NUM2DBL(x2), rslt); return v; } VALUE rb_gsl_sf_eval_e_int_int_double(int (*func)(int, int, double, gsl_sf_result*), VALUE n1, VALUE n2, VALUE x) { gsl_sf_result *rslt = NULL; VALUE v; int status; CHECK_FIXNUM(n1); CHECK_FIXNUM(n2); Need_Float(x); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(FIX2INT(n1), FIX2INT(n2), NUM2DBL(x), rslt); return v; } VALUE rb_gsl_sf_eval_e_double2(int (*func)(double, double, gsl_sf_result*), VALUE x1, VALUE x2) { gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(x1); Need_Float(x2); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(x1), NUM2DBL(x2), rslt); return v; } VALUE rb_gsl_sf_eval_e_double3(int (*func)(double, double, double, gsl_sf_result*), VALUE x1, VALUE x2, VALUE x3) { gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(x1); Need_Float(x2); Need_Float(x3); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(x1), NUM2DBL(x2),NUM2DBL(x3), rslt); return v; } VALUE rb_gsl_sf_eval_e_m(int (*func)(double, gsl_mode_t, gsl_sf_result*), VALUE x, VALUE m) { gsl_mode_t mode; char c; gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(x); switch (TYPE(m)) { case T_STRING: c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; break; case T_FIXNUM: mode = FIX2INT(m); break; default: rb_raise(rb_eArgError, "wrong type argument %s (String or Fixnum expected)", rb_class2name(CLASS_OF(m))); break; } v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(x), mode, rslt); return v; } VALUE rb_gsl_sf_eval_e_double2_m(int (*func)(double, double, gsl_mode_t, gsl_sf_result*), VALUE x1, VALUE x2, VALUE m) { gsl_mode_t mode; char c; gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(x1); Need_Float(x2); switch (TYPE(m)) { case T_STRING: c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; break; case T_FIXNUM: mode = FIX2INT(m); break; default: rb_raise(rb_eArgError, "wrong type argument %s (String or Fixnum expected)", rb_class2name(CLASS_OF(m))); break; } v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(x1), NUM2DBL(x2), mode, rslt); return v; } VALUE rb_gsl_sf_eval_e_double3_m(int (*func)(double, double, double, gsl_mode_t, gsl_sf_result*), VALUE x1, VALUE x2, VALUE x3, VALUE m) { gsl_mode_t mode; char c; gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(x1); Need_Float(x2); Need_Float(x3); switch (TYPE(m)) { case T_STRING: c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; break; case T_FIXNUM: mode = FIX2INT(m); break; default: rb_raise(rb_eArgError, "wrong type argument %s (String or Fixnum expected)", rb_class2name(CLASS_OF(m))); break; } v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(x1), NUM2DBL(x2),NUM2DBL(x3), mode, rslt); return v; } VALUE rb_gsl_sf_eval_e_double4_m(int (*func)(double, double, double, double, gsl_mode_t, gsl_sf_result*), VALUE x1, VALUE x2, VALUE x3, VALUE x4, VALUE m) { gsl_mode_t mode; char c; gsl_sf_result *rslt = NULL; VALUE v; int status; Need_Float(x1); Need_Float(x2); Need_Float(x3); Need_Float(x4); switch (TYPE(m)) { case T_STRING: c = tolower(NUM2CHR(m)); if (c == 'd') mode = GSL_PREC_DOUBLE; else if (c == 's') mode = GSL_PREC_SINGLE; else if (c == 'a') mode = GSL_PREC_APPROX; else mode = GSL_PREC_DOUBLE; break; case T_FIXNUM: mode = FIX2INT(m); break; default: rb_raise(rb_eArgError, "wrong type argument %s (String or Fixnum expected)", rb_class2name(CLASS_OF(m))); break; } v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); status = (*func)(NUM2DBL(x1), NUM2DBL(x2),NUM2DBL(x3), NUM2DBL(x4), mode, rslt); return v; } VALUE eval_sf(double (*func)(double, gsl_mode_t), VALUE argv) { VALUE ary, xx; size_t i, k, n; double val; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *mm = NULL, *mnew = NULL; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif switch (TYPE(argv)) { case T_FLOAT: case T_FIXNUM: case T_BIGNUM: return rb_float_new((*func)(NUM2DBL(argv), GSL_PREC_DOUBLE)); break; case T_ARRAY: n = RARRAY_LEN(argv); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { xx = rb_ary_entry(argv, i); Need_Float(xx); val = (*func)(NUM2DBL(xx), GSL_PREC_DOUBLE); rb_ary_store(ary, i, rb_float_new(val)); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(argv)) { ptr1 = NA_PTR_TYPE(argv, double*); GetNArray(argv, na); n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*func)(ptr1[i], GSL_PREC_DOUBLE); return ary; } #endif if (rb_obj_is_kind_of(argv, cgsl_matrix)) { Data_Get_Struct(argv, gsl_matrix, mm); mnew = gsl_matrix_alloc(mm->size1, mm->size2); for (i = 0; i < mm->size1; i++) { for (k = 0; k < mm->size2; k++) { val = (*func)(gsl_matrix_get(mm, i, k), GSL_PREC_DOUBLE); gsl_matrix_set(mnew, i, k, val); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { CHECK_VECTOR(argv); Data_Get_Struct(argv, gsl_vector, v); n = v->size; vnew = gsl_vector_alloc(n); for (i = 0; i < n; i++) { val = (*func)(gsl_vector_get(v, i), GSL_PREC_DOUBLE); gsl_vector_set(vnew, i, val); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } break; } } VALUE rb_gsl_sf_eval_complex(double (*f)(double), VALUE obj) { gsl_complex *z, *znew, c; gsl_vector_complex *v, *vnew; gsl_matrix_complex *m, *mnew; size_t i, j; if (COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_complex, z); znew = xmalloc(sizeof(gsl_complex)); GSL_SET_REAL(znew, (*f)(GSL_REAL(*z))); GSL_SET_IMAG(znew, (*f)(GSL_IMAG(*z))); return Data_Wrap_Struct(cgsl_complex, 0, free, znew); } else if (VECTOR_COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_vector_complex, v); vnew = gsl_vector_complex_alloc(v->size); for (i = 0; i < v->size; i++) { z = GSL_COMPLEX_AT(v, i); GSL_SET_REAL(&c, (*f)(GSL_REAL(*z))); GSL_SET_IMAG(&c, (*f)(GSL_IMAG(*z))); gsl_vector_complex_set(vnew, i, c); } return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew); } else if (MATRIX_COMPLEX_P(obj)) { Data_Get_Struct(obj, gsl_matrix_complex, m); mnew = gsl_matrix_complex_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { c = gsl_matrix_complex_get(m, i, j); GSL_SET_REAL(&c, (*f)(GSL_REAL(c))); GSL_SET_IMAG(&c, (*f)(GSL_IMAG(c))); gsl_matrix_complex_set(mnew, i, j, c); } } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type %s " " (GSL::Complex or GSL::Vector::Complex expected)", rb_class2name(CLASS_OF(obj))); } } void Init_gsl_sf(VALUE module) { VALUE mgsl_sf; mgsl_sf = rb_define_module_under(module, "Sf"); cgsl_sf_result = rb_define_class_under(mgsl_sf, "Result", cGSL_Object); rb_define_singleton_method(cgsl_sf_result, "new", rb_gsl_sf_result_new, 0); rb_define_method(cgsl_sf_result, "print", rb_gsl_sf_result_print, 0); rb_define_method(cgsl_sf_result, "inspect", rb_gsl_sf_result_inspect, 0); rb_define_method(cgsl_sf_result, "val", rb_gsl_sf_result_val, 0); rb_define_method(cgsl_sf_result, "err", rb_gsl_sf_result_err, 0); rb_define_method(cgsl_sf_result, "to_a", rb_gsl_sf_result_to_a, 0); rb_define_method(cgsl_sf_result, "to_s", rb_gsl_sf_result_to_s, 0); cgsl_sf_result_e10 = rb_define_class_under(mgsl_sf, "Result_e10", cGSL_Object); rb_define_singleton_method(cgsl_sf_result_e10, "new", rb_gsl_sf_result_e10_new, 0); rb_define_method(cgsl_sf_result_e10, "val", rb_gsl_sf_result_e10_val, 0); rb_define_method(cgsl_sf_result_e10, "err", rb_gsl_sf_result_e10_err, 0); rb_define_method(cgsl_sf_result_e10, "e10", rb_gsl_sf_result_e10_e10, 0); rb_define_method(cgsl_sf_result_e10, "to_a", rb_gsl_sf_result_e10_to_a, 0); rb_define_method(cgsl_sf_result_e10, "to_s", rb_gsl_sf_result_e10_to_s, 0); Init_gsl_sf_airy(mgsl_sf); Init_gsl_sf_bessel(mgsl_sf); Init_gsl_sf_clausen(mgsl_sf); Init_gsl_sf_coulomb(mgsl_sf); Init_gsl_sf_coupling(mgsl_sf); Init_gsl_sf_dawson(mgsl_sf); Init_gsl_sf_debye(mgsl_sf); Init_gsl_sf_dilog(mgsl_sf); Init_gsl_sf_elementary(mgsl_sf); Init_gsl_sf_ellint(mgsl_sf); Init_gsl_sf_elljac(mgsl_sf); Init_gsl_sf_erfc(mgsl_sf); Init_gsl_sf_exp(mgsl_sf); Init_gsl_sf_expint(mgsl_sf); Init_gsl_sf_fermi_dirac(mgsl_sf); Init_gsl_sf_gamma(mgsl_sf); Init_gsl_sf_gegenbauer(mgsl_sf); Init_gsl_sf_hyperg(mgsl_sf); Init_gsl_sf_laguerre(mgsl_sf); Init_gsl_sf_lambert(mgsl_sf); Init_gsl_sf_legendre(mgsl_sf); Init_gsl_sf_log(mgsl_sf); Init_gsl_sf_power(mgsl_sf); Init_gsl_sf_psi(mgsl_sf); Init_gsl_sf_synchrotron(mgsl_sf); Init_gsl_sf_transport(mgsl_sf); Init_gsl_sf_trigonometric(mgsl_sf); Init_gsl_sf_zeta(mgsl_sf); #ifdef GSL_1_9_LATER Init_sf_mathieu(mgsl_sf); #endif } gsl-1.15.3/ext/fcmp.c0000644000175000017500000000325312220252463013636 0ustar boutilboutil/* sys/gsl_compare.c * * Copyright (C) 2002 Gert Van den Eynde * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or (at * your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Based on fcmp 1.2.2 Copyright (c) 1998-2000 Theodore C. Belding * University of Michigan Center for the Study of Complex Systems * Ted.Belding@umich.edu * */ #include "rb_gsl_config.h" #ifndef GSL_1_3_LATER #include #include #include int gsl_fcmp(const double x1, const double x2, const double epsilon) { int exponent; double delta, difference; /* Find exponent of largest absolute value */ { double max = (fabs (x1) > fabs (x2)) ? x1 : x2; frexp (max, &exponent); } /* Form a neighborhood of size 2 * delta */ delta = ldexp (epsilon, exponent); difference = x1 - x2; if (difference > delta) /* x1 > x2 */ { return 1; } else if (difference < -delta) /* x1 < x2 */ { return -1; } else /* -delta <= difference <= delta */ { return 0; /* x1 ~=~ x2 */ } } #endif gsl-1.15.3/ext/blas3.c0000644000175000017500000007044712220252463013726 0ustar boutilboutil/* blas3.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include #include "rb_gsl_common.h" #include "rb_gsl_complex.h" #include "rb_gsl_array.h" static VALUE rb_gsl_blas_dgemm(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL, *C = NULL; double alpha, beta; CBLAS_TRANSPOSE_t TransA, TransB; int flag = 0; switch (argc) { case 2: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_matrix, B); C = gsl_matrix_calloc(A->size1, B->size2); alpha = 1.0; beta = 0.0; TransA = CblasNoTrans; TransB = CblasNoTrans; flag = 1; break; case 5: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); Need_Float(argv[2]); CHECK_MATRIX(argv[3]); CHECK_MATRIX(argv[4]); TransA = FIX2INT(argv[0]); TransB = FIX2INT(argv[1]); alpha = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_matrix, B); C = gsl_matrix_calloc(A->size1, B->size2); beta = 0.0; flag = 1; break; case 6: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); Need_Float(argv[2]); CHECK_MATRIX(argv[3]); CHECK_MATRIX(argv[4]); Need_Float(argv[5]); TransA = FIX2INT(argv[0]); TransB = FIX2INT(argv[1]); alpha = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_matrix, B); beta = NUM2DBL(argv[5]); C = gsl_matrix_calloc(A->size1, B->size2); flag = 1; break; case 7: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); Need_Float(argv[2]); CHECK_MATRIX(argv[3]); CHECK_MATRIX(argv[4]); Need_Float(argv[5]); CHECK_MATRIX(argv[6]); TransA = FIX2INT(argv[0]); TransB = FIX2INT(argv[1]); alpha = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_matrix, B); beta = NUM2DBL(argv[5]); Data_Get_Struct(argv[6], gsl_matrix, C); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2, 5, 6, or 7)", argc); break; } gsl_blas_dgemm(TransA, TransB, alpha, A, B, beta, C); if (flag == 1) return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, C); else return argv[6]; } static VALUE rb_gsl_blas_zgemm(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL; gsl_complex alpha, beta, *pa = &alpha, *pb = β CBLAS_TRANSPOSE_t TransA, TransB; int flag = 0; alpha.dat[0] = 1.0; alpha.dat[1] = 0.0; beta.dat[0] = 0.0; beta.dat[1] = 0.0; switch (argc) { case 2: CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, A); Data_Get_Struct(argv[1], gsl_matrix_complex, B); C = gsl_matrix_complex_calloc(A->size1, B->size2); TransA = CblasNoTrans; TransB = CblasNoTrans; flag = 1; break; case 5: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); TransA = FIX2INT(argv[0]); TransB = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); C = gsl_matrix_complex_calloc(A->size1, B->size2); flag = 1; break; case 6: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); CHECK_COMPLEX(argv[5]); TransA = FIX2INT(argv[0]); TransB = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); Data_Get_Struct(argv[5], gsl_complex, pb); C = gsl_matrix_complex_calloc(A->size1, B->size2); flag = 1; break; case 7: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); CHECK_COMPLEX(argv[5]); CHECK_MATRIX_COMPLEX(argv[6]); TransA = FIX2INT(argv[0]); TransB = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); Data_Get_Struct(argv[5], gsl_complex, pb); Data_Get_Struct(argv[6], gsl_matrix_complex, C); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 7)", argc); break; } gsl_blas_zgemm(TransA, TransB, alpha, A, B, beta, C); if (flag == 1) return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, C); else return argv[6]; } static VALUE rb_gsl_blas_dsymm(int argc, VALUE *argv, VALUE obj) { gsl_matrix *A = NULL, *B = NULL, *C = NULL; double alpha, beta; CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; int flag = 0; switch (argc) { case 2: CHECK_MATRIX(argv[0]); CHECK_MATRIX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix, A); Data_Get_Struct(argv[1], gsl_matrix, B); C = gsl_matrix_calloc(A->size1, B->size2); alpha = 1.0; beta = 0.0; Side = CblasLeft; Uplo = CblasUpper; flag = 1; break; case 5: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); Need_Float(argv[2]); CHECK_MATRIX(argv[3]); CHECK_MATRIX(argv[4]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); alpha = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_matrix, B); C = gsl_matrix_calloc(A->size1, B->size2); beta = 0.0; flag = 1; break; case 6: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); Need_Float(argv[2]); CHECK_MATRIX(argv[3]); CHECK_MATRIX(argv[4]); Need_Float(argv[5]); CHECK_MATRIX(argv[6]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); alpha = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_matrix, B); beta = NUM2DBL(argv[5]); C = gsl_matrix_calloc(A->size1, B->size2); flag = 1; break; case 7: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); Need_Float(argv[2]); CHECK_MATRIX(argv[3]); CHECK_MATRIX(argv[4]); Need_Float(argv[5]); CHECK_MATRIX(argv[6]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); alpha = NUM2DBL(argv[2]); Data_Get_Struct(argv[3], gsl_matrix, A); Data_Get_Struct(argv[4], gsl_matrix, B); beta = NUM2DBL(argv[5]); Data_Get_Struct(argv[6], gsl_matrix, C); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 7)", argc); break; } gsl_blas_dsymm(Side, Uplo, alpha, A, B, beta, C); if (flag == 1) return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, C); else return argv[6]; } static VALUE rb_gsl_blas_zsymm(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL; gsl_complex alpha, beta, *pa = &alpha, *pb = β CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; int flag = 0; alpha = gsl_complex_rect(1.0, 0.0); beta = gsl_complex_rect(0.0, 0.0); switch (argc) { case 2: CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, A); Data_Get_Struct(argv[1], gsl_matrix_complex, B); C = gsl_matrix_complex_calloc(A->size1, B->size2); Side = CblasLeft; Uplo = CblasUpper; flag = 1; break; case 5: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); C = gsl_matrix_complex_calloc(A->size1, B->size2); flag = 1; break; case 6: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); CHECK_COMPLEX(argv[5]); CHECK_MATRIX_COMPLEX(argv[6]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); Data_Get_Struct(argv[5], gsl_complex, pb); C = gsl_matrix_complex_calloc(A->size1, B->size2); flag = 1; break; case 7: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); CHECK_COMPLEX(argv[5]); CHECK_MATRIX_COMPLEX(argv[6]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); Data_Get_Struct(argv[5], gsl_complex, pb); Data_Get_Struct(argv[6], gsl_matrix_complex, C); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 7)", argc); break; } gsl_blas_zsymm(Side, Uplo, alpha, A, B, beta, C); if (flag == 1) return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, C); else return argv[6]; } static VALUE rb_gsl_blas_zhemm(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL; gsl_complex alpha, beta, *pa = &alpha, *pb = β CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; int flag = 0; alpha = gsl_complex_rect(1.0, 0.0); beta = gsl_complex_rect(0.0, 0.0); switch (argc) { case 2: CHECK_MATRIX_COMPLEX(argv[0]); CHECK_MATRIX_COMPLEX(argv[1]); Data_Get_Struct(argv[0], gsl_matrix_complex, A); Data_Get_Struct(argv[1], gsl_matrix_complex, B); C = gsl_matrix_complex_calloc(A->size1, B->size2); Side = CblasLeft; Uplo = CblasUpper; flag = 1; break; case 5: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); C = gsl_matrix_complex_calloc(A->size1, B->size2); flag = 1; break; case 6: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); CHECK_COMPLEX(argv[5]); CHECK_MATRIX_COMPLEX(argv[6]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); Data_Get_Struct(argv[5], gsl_complex, pb); C = gsl_matrix_complex_calloc(A->size1, B->size2); flag = 1; break; case 7: CHECK_FIXNUM(argv[0]); CHECK_FIXNUM(argv[1]); CHECK_COMPLEX(argv[2]); CHECK_MATRIX_COMPLEX(argv[3]); CHECK_MATRIX_COMPLEX(argv[4]); CHECK_COMPLEX(argv[5]); CHECK_MATRIX_COMPLEX(argv[6]); Side = FIX2INT(argv[0]); Uplo = FIX2INT(argv[1]); Data_Get_Struct(argv[2], gsl_complex, pa); Data_Get_Struct(argv[3], gsl_matrix_complex, A); Data_Get_Struct(argv[4], gsl_matrix_complex, B); Data_Get_Struct(argv[5], gsl_complex, pb); Data_Get_Struct(argv[6], gsl_matrix_complex, C); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 7)", argc); break; } gsl_blas_zhemm(Side, Uplo, alpha, A, B, beta, C); if (flag == 1) return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, C); else return argv[6]; } static VALUE rb_gsl_blas_dtrmm(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix *A = NULL, *B = NULL; double alpha; CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); Need_Float(a); CHECK_MATRIX(aa); CHECK_MATRIX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); alpha = NUM2DBL(a); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(bb, gsl_matrix, B); gsl_blas_dtrmm(Side, Uplo, TransA, Diag, alpha, A, B); return bb; } static VALUE rb_gsl_blas_dtrmm2(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix *A = NULL, *B = NULL, *Bnew = NULL; double alpha; CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); Need_Float(a); CHECK_MATRIX(aa); CHECK_MATRIX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); alpha = NUM2DBL(a); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(bb, gsl_matrix, B); Bnew = gsl_matrix_alloc(B->size1, B->size2); gsl_matrix_memcpy(Bnew, B); gsl_blas_dtrmm(Side, Uplo, TransA, Diag, alpha, A, Bnew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Bnew); } static VALUE rb_gsl_blas_ztrmm(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix_complex *A = NULL, *B = NULL; gsl_complex alpha, *pa = α CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); CHECK_COMPLEX(a); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); gsl_blas_ztrmm(Side, Uplo, TransA, Diag, alpha, A, B); return bb; } static VALUE rb_gsl_blas_ztrmm2(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix_complex *A = NULL, *B = NULL, *Bnew = NULL; gsl_complex alpha, *pa = α CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); CHECK_COMPLEX(a); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); Bnew = gsl_matrix_complex_alloc(B->size1, B->size2); gsl_matrix_complex_memcpy(Bnew, B); gsl_blas_ztrmm(Side, Uplo, TransA, Diag, alpha, A, Bnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Bnew); } static VALUE rb_gsl_blas_dtrsm(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix *A = NULL, *B = NULL; double alpha; CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); Need_Float(a); CHECK_MATRIX(aa); CHECK_MATRIX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); alpha = NUM2DBL(a); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(bb, gsl_matrix, B); gsl_blas_dtrsm(Side, Uplo, TransA, Diag, alpha, A, B); return bb; } static VALUE rb_gsl_blas_dtrsm2(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix *A = NULL, *B = NULL, *Bnew = NULL; double alpha; CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); Need_Float(a); CHECK_MATRIX(aa); CHECK_MATRIX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); alpha = NUM2DBL(a); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(bb, gsl_matrix, B); Bnew = gsl_matrix_alloc(B->size1, B->size2); gsl_matrix_memcpy(Bnew, B); gsl_blas_dtrsm(Side, Uplo, TransA, Diag, alpha, A, Bnew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Bnew); } static VALUE rb_gsl_blas_ztrsm(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix_complex *A = NULL, *B = NULL; gsl_complex alpha, *pa = α CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); CHECK_COMPLEX(a); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); gsl_blas_ztrsm(Side, Uplo, TransA, Diag, alpha, A, B); return bb; } static VALUE rb_gsl_blas_ztrsm2(VALUE obj, VALUE s, VALUE u, VALUE ta, VALUE d, VALUE a, VALUE aa, VALUE bb) { gsl_matrix_complex *A = NULL, *B = NULL, *Bnew = NULL; gsl_complex alpha, *pa = α CBLAS_SIDE_t Side; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t TransA; CBLAS_DIAG_t Diag; CHECK_FIXNUM(s); CHECK_FIXNUM(u); CHECK_FIXNUM(ta); CHECK_FIXNUM(d); CHECK_COMPLEX(a); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); Side = FIX2INT(s); Uplo = FIX2INT(u); TransA = FIX2INT(ta); Diag = FIX2INT(d); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); Bnew = gsl_matrix_complex_alloc(B->size1, B->size2); gsl_matrix_complex_memcpy(Bnew, B); gsl_blas_ztrsm(Side, Uplo, TransA, Diag, alpha, A, Bnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Bnew); } static VALUE rb_gsl_blas_dsyrk(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE b, VALUE cc) { gsl_matrix *A = NULL, *C = NULL; double alpha, beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); Need_Float(a); Need_Float(b); CHECK_MATRIX(aa); CHECK_MATRIX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); alpha = NUM2DBL(a); beta = NUM2DBL(b); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(cc, gsl_matrix, C); gsl_blas_dsyrk(Uplo, Trans, alpha, A, beta, C); return cc; } static VALUE rb_gsl_blas_dsyrk2(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE b, VALUE cc) { gsl_matrix *A = NULL, *C = NULL, *Cnew = NULL; double alpha, beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); Need_Float(a); Need_Float(b); CHECK_MATRIX(aa); CHECK_MATRIX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); alpha = NUM2DBL(a); beta = NUM2DBL(b); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(cc, gsl_matrix, C); Cnew = gsl_matrix_alloc(C->size1, C->size2); gsl_matrix_memcpy(Cnew, C); gsl_blas_dsyrk(Uplo, Trans, alpha, A, beta, Cnew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Cnew); } static VALUE rb_gsl_blas_zsyrk(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *C = NULL; gsl_complex alpha, beta, *pa = &alpha, *pb = β CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); CHECK_COMPLEX(a); CHECK_COMPLEX(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(b, gsl_complex, pb); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(cc, gsl_matrix_complex, C); gsl_blas_zsyrk(Uplo, Trans, alpha, A, beta, C); return cc; } static VALUE rb_gsl_blas_zsyrk2(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *C = NULL, *Cnew = NULL; gsl_complex alpha, beta, *pa = &alpha, *pb = β CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); CHECK_COMPLEX(a); CHECK_COMPLEX(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(b, gsl_complex, pb); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(cc, gsl_matrix_complex, C); Cnew = gsl_matrix_complex_alloc(C->size1, C->size2); gsl_matrix_complex_memcpy(Cnew, C); gsl_blas_zsyrk(Uplo, Trans, alpha, A, beta, Cnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Cnew); } static VALUE rb_gsl_blas_zherk(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *C = NULL; double alpha, beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); Need_Float(a); Need_Float(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); alpha = NUM2DBL(a); beta = NUM2DBL(b); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(cc, gsl_matrix_complex, C); gsl_blas_zherk(Uplo, Trans, alpha, A, beta, C); return cc; } static VALUE rb_gsl_blas_zherk2(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *C = NULL, *Cnew = NULL; double alpha, beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); Need_Float(a); Need_Float(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); alpha = NUM2DBL(a); beta = NUM2DBL(b); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(cc, gsl_matrix_complex, C); Cnew = gsl_matrix_complex_alloc(C->size1, C->size2); gsl_matrix_complex_memcpy(Cnew, C); gsl_blas_zherk(Uplo, Trans, alpha, A, beta, Cnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Cnew); } static VALUE rb_gsl_blas_dsyr2k(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE bb, VALUE b, VALUE cc) { gsl_matrix *A = NULL, *B = NULL, *C = NULL; double alpha, beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); Need_Float(a); Need_Float(b); CHECK_MATRIX(aa); CHECK_MATRIX(bb); CHECK_MATRIX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); alpha = NUM2DBL(a); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(bb, gsl_matrix, B); beta = NUM2DBL(b); Data_Get_Struct(cc, gsl_matrix, C); gsl_blas_dsyr2k(Uplo, Trans, alpha, A, B, beta, C); return cc; } static VALUE rb_gsl_blas_dsyr2k2(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE bb, VALUE b, VALUE cc) { gsl_matrix *A = NULL, *B = NULL, *C = NULL, *Cnew = NULL; double alpha, beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); Need_Float(a); Need_Float(b); CHECK_MATRIX(aa); CHECK_MATRIX(bb); CHECK_MATRIX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); alpha = NUM2DBL(a); Data_Get_Struct(aa, gsl_matrix, A); Data_Get_Struct(bb, gsl_matrix, B); beta = NUM2DBL(b); Data_Get_Struct(cc, gsl_matrix, C); Cnew = gsl_matrix_alloc(C->size1, C->size2); gsl_matrix_memcpy(Cnew, C); gsl_blas_dsyr2k(Uplo, Trans, alpha, A, B, beta, Cnew); return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, Cnew); } static VALUE rb_gsl_blas_zsyr2k(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE bb, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL; gsl_complex alpha, beta, *pa = &alpha, *pb = β CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); CHECK_COMPLEX(a); CHECK_COMPLEX(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(b, gsl_complex, pb); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); Data_Get_Struct(cc, gsl_matrix_complex, C); gsl_blas_zsyr2k(Uplo, Trans, alpha, A, B, beta, C); return cc; } static VALUE rb_gsl_blas_zsyr2k2(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE bb, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL, *Cnew = NULL; gsl_complex alpha, beta, *pa = &alpha, *pb = β CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); CHECK_COMPLEX(a); CHECK_COMPLEX(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); Data_Get_Struct(a, gsl_complex, pa); Data_Get_Struct(b, gsl_complex, pb); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); Data_Get_Struct(cc, gsl_matrix_complex, C); Cnew = gsl_matrix_complex_alloc(C->size1, C->size2); gsl_matrix_complex_memcpy(Cnew, C); gsl_blas_zsyr2k(Uplo, Trans, alpha, A, B, beta, Cnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Cnew); } static VALUE rb_gsl_blas_zher2k(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE bb, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL; gsl_complex alpha, *pa = α double beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); CHECK_COMPLEX(a); Need_Float(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); Data_Get_Struct(a, gsl_complex, pa); beta = NUM2DBL(b); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); Data_Get_Struct(cc, gsl_matrix_complex, C); gsl_blas_zher2k(Uplo, Trans, alpha, A, B, beta, C); return cc; } static VALUE rb_gsl_blas_zher2k2(VALUE obj, VALUE u, VALUE t, VALUE a, VALUE aa, VALUE bb, VALUE b, VALUE cc) { gsl_matrix_complex *A = NULL, *B = NULL, *C = NULL, *Cnew = NULL; gsl_complex alpha, *pa = α double beta; CBLAS_UPLO_t Uplo; CBLAS_TRANSPOSE_t Trans; CHECK_FIXNUM(u); CHECK_FIXNUM(t); CHECK_COMPLEX(a); Need_Float(b); CHECK_MATRIX_COMPLEX(aa); CHECK_MATRIX_COMPLEX(bb); CHECK_MATRIX_COMPLEX(cc); Uplo = FIX2INT(u); Trans = FIX2INT(t); Data_Get_Struct(a, gsl_complex, pa); beta = NUM2DBL(b); Data_Get_Struct(aa, gsl_matrix_complex, A); Data_Get_Struct(bb, gsl_matrix_complex, B); Data_Get_Struct(cc, gsl_matrix_complex, C); Cnew = gsl_matrix_complex_alloc(C->size1, C->size2); gsl_matrix_complex_memcpy(Cnew, C); gsl_blas_zher2k(Uplo, Trans, alpha, A, B, beta, Cnew); return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, Cnew); } void Init_gsl_blas3(VALUE module) { rb_define_module_function(module, "dgemm", rb_gsl_blas_dgemm, -1); rb_define_module_function(module, "zgemm", rb_gsl_blas_zgemm, -1); rb_define_module_function(module, "dsymm", rb_gsl_blas_dsymm, -1); rb_define_module_function(module, "zsymm", rb_gsl_blas_zsymm, -1); rb_define_module_function(module, "zhemm", rb_gsl_blas_zhemm, -1); rb_define_module_function(module, "dtrmm!", rb_gsl_blas_dtrmm, 7); rb_define_module_function(module, "dtrmm", rb_gsl_blas_dtrmm2, 7); rb_define_module_function(module, "ztrmm!", rb_gsl_blas_ztrmm, 7); rb_define_module_function(module, "ztrmm", rb_gsl_blas_ztrmm2, 7); rb_define_module_function(module, "dtrsm!", rb_gsl_blas_dtrsm, 7); rb_define_module_function(module, "dtrsm", rb_gsl_blas_dtrsm2, 7); rb_define_module_function(module, "ztrsm!", rb_gsl_blas_ztrsm, 7); rb_define_module_function(module, "ztrsm", rb_gsl_blas_ztrsm2, 7); rb_define_module_function(module, "dsyrk!", rb_gsl_blas_dsyrk, 6); rb_define_module_function(module, "dsyrk", rb_gsl_blas_dsyrk2, 6); rb_define_module_function(module, "zsyrk!", rb_gsl_blas_zsyrk, 6); rb_define_module_function(module, "zsyrk", rb_gsl_blas_zsyrk2, 6); rb_define_module_function(module, "zherk!", rb_gsl_blas_zherk, 6); rb_define_module_function(module, "zherk", rb_gsl_blas_zherk2, 6); rb_define_module_function(module, "dsyr2k!", rb_gsl_blas_dsyr2k, 7); rb_define_module_function(module, "dsyr2k", rb_gsl_blas_dsyr2k2, 7); rb_define_module_function(module, "zsyr2k!", rb_gsl_blas_zsyr2k, 7); rb_define_module_function(module, "zsyr2k", rb_gsl_blas_zsyr2k2, 7); rb_define_module_function(module, "zher2k!", rb_gsl_blas_zher2k, 7); rb_define_module_function(module, "zher2k", rb_gsl_blas_zher2k2, 7); } gsl-1.15.3/ext/randist.c0000644000175000017500000015666612220252463014376 0ustar boutilboutil/* randist.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_common.h" #include "rb_gsl_rng.h" #include VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double)); VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa, double (*f)(double, double)); VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb, double (*f)(double, double, double)); VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa, double (*f)(unsigned int, double)); static VALUE rb_gsl_ran_eval0(int argc, VALUE *argv, VALUE obj, double (*f)(const gsl_rng*)) { gsl_rng *r; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); break; } break; default: switch (argc) { case 0: break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return rb_float_new((*f)(r)); } static VALUE rb_gsl_ran_eval1(int argc, VALUE *argv, VALUE obj, double (*f)(const gsl_rng*, double)) { gsl_rng *r; gsl_vector *v; size_t n, i; double a; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: n = NUM2INT(argv[2]); a = NUM2DBL(argv[1]); CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, (*f)(r, a)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 2: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); a = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); break; } break; default: switch (argc) { case 2: n = NUM2INT(argv[1]); a = NUM2DBL(argv[0]); Data_Get_Struct(obj, gsl_rng, r); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, (*f)(r, a)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 1: a = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return rb_float_new((*f)(r, a)); } static VALUE rb_gsl_ran_eval1_uint(int argc, VALUE *argv, VALUE obj, unsigned int (*f)(const gsl_rng*, double)) { gsl_rng *r; gsl_vector_int *v; size_t n, i; double a; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: n = NUM2INT(argv[2]); a = NUM2DBL(argv[1]); CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); v = gsl_vector_int_alloc(n); for (i = 0; i < n; i++) gsl_vector_int_set(v, i, (int) (*f)(r, a)); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v); break; case 2: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); a = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); break; } break; default: switch (argc) { case 2: n = NUM2INT(argv[1]); a = NUM2DBL(argv[0]); Data_Get_Struct(obj, gsl_rng, r); v = gsl_vector_int_alloc(n); for (i = 0; i < n; i++) gsl_vector_int_set(v, i, (*f)(r, a)); return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v); break; case 1: a = NUM2DBL(argv[0]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return INT2FIX((*f)(r, a)); } static VALUE rb_gsl_ran_eval2(int argc, VALUE *argv, VALUE obj, double (*f)(const gsl_rng*, double, double)) { gsl_rng *r; gsl_vector *v; size_t n, i; double a, b; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 4: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); n = NUM2INT(argv[3]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, (*f)(r, a, b)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 3: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } break; default: switch (argc) { case 3: Data_Get_Struct(obj, gsl_rng, r); a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); n = NUM2INT(argv[2]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, (*f)(r, a, b)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 2: a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return rb_float_new((*f)(r, a, b)); } static VALUE rb_gsl_ran_eval3(int argc, VALUE *argv, VALUE obj, double (*f)(const gsl_rng*, double, double, double)) { gsl_rng *r; gsl_vector *v; size_t n, i; double a, b, c; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 5: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); c = NUM2DBL(argv[3]); n = NUM2INT(argv[4]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, (*f)(r, a, b, c)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 4: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); c = NUM2DBL(argv[3]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); break; } break; default: switch (argc) { case 4: Data_Get_Struct(obj, gsl_rng, r); a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); c = NUM2DBL(argv[2]); n = NUM2INT(argv[3]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, (*f)(r, a, b, c)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 3: a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); c = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return rb_float_new((*f)(r, a, b, c)); } static VALUE rb_gsl_ran_gaussian(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v; size_t n, i; double sigma = 1.0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: n = NUM2INT(argv[2]); sigma = NUM2DBL(argv[1]); CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, gsl_ran_gaussian(r, sigma)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 2: sigma = NUM2DBL(argv[1]); /* no break */ case 1: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); return rb_float_new(gsl_ran_gaussian(r, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 1 or 2)", argc); return Qnil; break; } break; default: Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 2: n = NUM2INT(argv[1]); sigma = NUM2DBL(argv[0]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, gsl_ran_gaussian(r, sigma)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 1: sigma = NUM2DBL(argv[0]); /* no break */ case 0: return rb_float_new(gsl_ran_gaussian(r, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); return Qnil; break; } break; } return Qnil; } static VALUE rb_gsl_ran_gaussian_ratio_method(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; double sigma = 1.0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: sigma = NUM2DBL(argv[1]); /* no break */ case 1: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); return rb_float_new(gsl_ran_gaussian_ratio_method(r, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 1 or 2)", argc); break; } break; default: Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 1: sigma = NUM2DBL(argv[0]); /* no break */ case 0: return rb_float_new(gsl_ran_gaussian_ratio_method(r, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); break; } break; } return Qnil; } static VALUE rb_gsl_ran_gaussian_pdf(int argc, VALUE *argv, VALUE obj) { if (argc == 1) { return rb_gsl_eval_pdf_cdf(argv[0], gsl_ran_ugaussian_pdf); } else if (argc == 2) { return rb_gsl_eval_pdf_cdf2(argv[0], argv[1], gsl_ran_gaussian_pdf); } else { rb_raise(rb_eArgError, "wrong number of arguments (1 or 2)"); } } static VALUE rb_gsl_ran_gaussian_tail(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v; size_t n, i; double a, sigma = 1.0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 4: n = NUM2INT(argv[3]); sigma = NUM2DBL(argv[2]); a = NUM2DBL(argv[1]); CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, gsl_ran_gaussian_tail(r, a, sigma)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 3: sigma = NUM2DBL(argv[2]); /* no break */ case 2: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); a = NUM2DBL(argv[1]); return rb_float_new(gsl_ran_gaussian_tail(r, a, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 2 or 3)", argc); break; } break; default: Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 3: n = NUM2INT(argv[2]); sigma = NUM2DBL(argv[1]); a = NUM2DBL(argv[0]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, gsl_ran_gaussian_tail(r, a, sigma)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 2: sigma = NUM2DBL(argv[1]); /* no break */ case 1: a = NUM2DBL(argv[0]); return rb_float_new(gsl_ran_gaussian_tail(r, a, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 1 or 2)", argc); break; } break; } } static VALUE rb_gsl_ran_gaussian_tail_pdf(int argc, VALUE *argv, VALUE obj) { switch (argc) { case 2: return rb_gsl_eval_pdf_cdf2(argv[0], argv[1], gsl_ran_ugaussian_tail_pdf); break; case 3: return rb_gsl_eval_pdf_cdf3(argv[0], argv[1], argv[2], gsl_ran_gaussian_tail_pdf); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } } static VALUE rb_gsl_ran_bivariate_gaussian(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; double sigmax, sigmay, x, y, rho; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 4: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); sigmax = NUM2DBL(argv[1]); sigmay = NUM2DBL(argv[2]); rho = NUM2DBL(argv[3]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); break; } break; default: switch (argc) { case 3: Data_Get_Struct(obj, gsl_rng, r); sigmax = NUM2DBL(argv[0]); sigmay = NUM2DBL(argv[1]); rho = NUM2DBL(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } break; } gsl_ran_bivariate_gaussian(r, sigmax, sigmay, rho, &x, &y); return rb_ary_new3(2, rb_float_new(x), rb_float_new(y)); } static VALUE rb_gsl_ran_bivariate_gaussian_pdf(VALUE obj, VALUE x, VALUE y, VALUE sx, VALUE sy, VALUE rr) { Need_Float(x); Need_Float(y); Need_Float(sx); Need_Float(sy); Need_Float(rr); return rb_float_new(gsl_ran_bivariate_gaussian_pdf(NUM2DBL(x), NUM2DBL(y), NUM2DBL(sx), NUM2DBL(sy), NUM2DBL(rr))); } static VALUE rb_gsl_ran_exponential(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1(argc, argv, obj, gsl_ran_exponential); } static VALUE rb_gsl_ran_exponential_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_ran_exponential_pdf); } static VALUE rb_gsl_ran_laplace(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1(argc, argv, obj, gsl_ran_laplace); } static VALUE rb_gsl_ran_laplace_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_ran_laplace_pdf); } static VALUE rb_gsl_ran_exppow(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_exppow); } static VALUE rb_gsl_ran_exppow_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_exppow_pdf); } static VALUE rb_gsl_ran_cauchy(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1(argc, argv, obj, gsl_ran_cauchy); } static VALUE rb_gsl_ran_cauchy_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_ran_cauchy_pdf); } static VALUE rb_gsl_ran_rayleigh(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1(argc, argv, obj, gsl_ran_rayleigh); } static VALUE rb_gsl_ran_rayleigh_pdf(VALUE obj, VALUE x, VALUE a) { return rb_gsl_eval_pdf_cdf2(x, a, gsl_ran_rayleigh_pdf); } static VALUE rb_gsl_ran_rayleigh_tail(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_rayleigh_tail); } static VALUE rb_gsl_ran_rayleigh_tail_pdf(VALUE obj, VALUE x, VALUE a, VALUE s) { return rb_gsl_eval_pdf_cdf3(x, a, s, gsl_ran_rayleigh_tail_pdf); } static VALUE rb_gsl_ran_landau(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval0(argc, argv, obj, gsl_ran_landau); } static VALUE rb_gsl_ran_landau_pdf(VALUE obj, VALUE x) { return rb_gsl_eval_pdf_cdf(x, gsl_ran_landau_pdf); } static VALUE rb_gsl_ran_levy(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_levy); } static VALUE rb_gsl_ran_levy_skew(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval3(argc, argv, obj, gsl_ran_levy_skew); } static VALUE rb_gsl_ran_gamma(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_gamma); } static VALUE rb_gsl_ran_gamma_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_gamma_pdf); } static VALUE rb_gsl_ran_flat(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_flat); } static VALUE rb_gsl_ran_flat_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_flat_pdf); } static VALUE rb_gsl_ran_lognormal(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_lognormal); } static VALUE rb_gsl_ran_lognormal_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_lognormal_pdf); } static VALUE rb_gsl_ran_chisq(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1(argc, argv, obj, gsl_ran_chisq); } static VALUE rb_gsl_ran_chisq_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_ran_chisq_pdf); } static VALUE rb_gsl_ran_fdist(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_fdist); } static VALUE rb_gsl_ran_fdist_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_fdist_pdf); } static VALUE rb_gsl_ran_tdist(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1(argc, argv, obj, gsl_ran_tdist); } static VALUE rb_gsl_ran_tdist_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_ran_tdist_pdf); } static VALUE rb_gsl_ran_beta(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_beta); } static VALUE rb_gsl_ran_beta_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_beta_pdf); } static VALUE rb_gsl_ran_logistic(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1(argc, argv, obj, gsl_ran_logistic); } static VALUE rb_gsl_ran_logistic_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2(x, mu, gsl_ran_logistic_pdf); } static VALUE rb_gsl_ran_pareto(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_pareto); } static VALUE rb_gsl_ran_pareto_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_pareto_pdf); } static VALUE rb_gsl_ran_weibull(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_weibull); } static VALUE rb_gsl_ran_weibull_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_weibull_pdf); } static VALUE rb_gsl_ran_gumbel1(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_gumbel1); } static VALUE rb_gsl_ran_gumbel1_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_gumbel1_pdf); } static VALUE rb_gsl_ran_gumbel2(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_gumbel2); } static VALUE rb_gsl_ran_gumbel2_pdf(VALUE obj, VALUE x, VALUE a, VALUE b) { return rb_gsl_eval_pdf_cdf3(x, a, b, gsl_ran_gumbel2_pdf); } static VALUE rb_gsl_ran_poisson(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1_uint(argc, argv, obj, gsl_ran_poisson); } static VALUE rb_gsl_ran_poisson_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2_uint(x, mu, gsl_ran_poisson_pdf); } static VALUE rb_gsl_ran_bernoulli(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1_uint(argc, argv, obj, gsl_ran_bernoulli); } static VALUE rb_gsl_ran_bernoulli_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2_uint(x, mu, gsl_ran_bernoulli_pdf); } static VALUE rb_gsl_ran_binomial(int argc, VALUE *argv, VALUE obj) { gsl_rng *r; double p; unsigned int n; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); p = NUM2DBL(argv[1]); n = FIX2UINT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } break; default: switch (argc) { case 2: p = NUM2DBL(argv[0]); n = FIX2UINT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return UINT2NUM(gsl_ran_binomial(r, p, n)); } #ifdef GSL_1_4_LATER static VALUE rb_gsl_ran_binomial_tpe(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; double p; unsigned int n; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); p = NUM2DBL(argv[1]); n = FIX2UINT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } break; default: switch (argc) { case 2: p = NUM2DBL(argv[0]); n = FIX2UINT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return UINT2NUM(gsl_ran_binomial_tpe(r, p, n)); } #endif static VALUE rb_gsl_ran_binomial_pdf(VALUE obj, VALUE x, VALUE p, VALUE n) { return rb_float_new(gsl_ran_binomial_pdf(NUM2UINT(x), NUM2DBL(p), NUM2UINT(n))); } static VALUE rb_gsl_ran_negative_binomial(int argc, VALUE *argv, VALUE obj) { gsl_rng *r; double p; unsigned int n; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); p = NUM2DBL(argv[1]); n = FIX2UINT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } break; default: switch (argc) { case 2: p = NUM2DBL(argv[0]); n = FIX2UINT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return UINT2NUM(gsl_ran_negative_binomial(r, p, n)); } static VALUE rb_gsl_ran_negative_binomial_pdf(VALUE obj, VALUE x, VALUE p, VALUE n) { return rb_float_new(gsl_ran_negative_binomial_pdf(NUM2UINT(x), NUM2DBL(p), NUM2DBL(n))); } static VALUE rb_gsl_ran_pascal(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; double p; unsigned int n; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); p = NUM2DBL(argv[1]); n = FIX2UINT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } break; default: switch (argc) { case 2: p = NUM2DBL(argv[0]); n = FIX2UINT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return UINT2NUM(gsl_ran_pascal(r, p, n)); } static VALUE rb_gsl_ran_pascal_pdf(VALUE obj, VALUE x, VALUE p, VALUE n) { return rb_float_new(gsl_ran_pascal_pdf(NUM2UINT(x), NUM2DBL(p), NUM2UINT(n))); } static VALUE rb_gsl_ran_geometric(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1_uint(argc, argv, obj, gsl_ran_geometric); } static VALUE rb_gsl_ran_geometric_pdf(VALUE obj, VALUE x, VALUE p) { return rb_gsl_eval_pdf_cdf2_uint(x, p, gsl_ran_geometric_pdf); } static VALUE rb_gsl_ran_hypergeometric(int argc, VALUE *argv, VALUE obj) { gsl_rng *r; unsigned int n1, n2, t; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 4: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); n1 = FIX2UINT(argv[1]); n2 = FIX2UINT(argv[2]); t = FIX2UINT(argv[3]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 4)", argc); break; } break; default: switch (argc) { case 3: n1 = FIX2UINT(argv[0]); n2 = FIX2UINT(argv[1]); t = FIX2UINT(argv[2]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc); break; } Data_Get_Struct(obj, gsl_rng, r); break; } return UINT2NUM(gsl_ran_hypergeometric(r, n1, n2, t)); } static VALUE rb_gsl_ran_hypergeometric_pdf(VALUE obj, VALUE k, VALUE n1, VALUE n2, VALUE t) { return rb_float_new(gsl_ran_hypergeometric_pdf(NUM2UINT(k), NUM2UINT(n1), NUM2UINT(n2), NUM2UINT(t))); } static VALUE rb_gsl_ran_logarithmic(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval1_uint(argc, argv, obj, gsl_ran_logarithmic); } static VALUE rb_gsl_ran_logarithmic_pdf(VALUE obj, VALUE x, VALUE mu) { return rb_gsl_eval_pdf_cdf2_uint(x, mu, gsl_ran_logarithmic_pdf); } static VALUE rb_gsl_ran_dir_2d(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; double x, y; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); break; } break; default: switch (argc) { case 0: Data_Get_Struct(obj, gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); break; } } gsl_ran_dir_2d(r, &x, &y); return rb_ary_new3(2, rb_float_new(x), rb_float_new(y)); } static VALUE rb_gsl_ran_dir_2d_trig_method(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; double x, y; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); break; } break; default: switch (argc) { case 0: Data_Get_Struct(obj, gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); break; } } gsl_ran_dir_2d_trig_method(r, &x, &y); return rb_ary_new3(2, rb_float_new(x), rb_float_new(y)); } static VALUE rb_gsl_ran_dir_3d(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; double x, y, z; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 1: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); break; } break; default: switch (argc) { case 0: Data_Get_Struct(obj, gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); break; } } gsl_ran_dir_3d(r, &x, &y, &z); return rb_ary_new3(3, rb_float_new(x), rb_float_new(y), rb_float_new(z)); } static VALUE rb_gsl_ran_dir_nd(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; size_t n; gsl_vector *v; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: CHECK_RNG(argv[0]); CHECK_FIXNUM(argv[1]); Data_Get_Struct(argv[0], gsl_rng, r); n = FIX2INT(argv[1]); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); break; } break; default: switch (argc) { case 1: CHECK_FIXNUM(argv[0]); n = FIX2INT(argv[0]); Data_Get_Struct(obj, gsl_rng, r); break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); break; } } v = gsl_vector_alloc(n); gsl_ran_dir_nd(r, n, v->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); } static VALUE rb_gsl_ran_shuffle(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v = NULL; gsl_permutation *p = NULL; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 2: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[1], gsl_vector, v); gsl_ran_shuffle(r, v->data, v->size, sizeof(double)); } else if (PERMUTATION_P(argv[1])) { Data_Get_Struct(argv[1], gsl_permutation, p); gsl_ran_shuffle(r, p->data, p->size, sizeof(size_t)); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[1]))); } break; case 3: CHECK_RNG(argv[0]); CHECK_FIXNUM(argv[2]); Data_Get_Struct(argv[0], gsl_rng, r); if (VECTOR_P(argv[1])) { Data_Get_Struct(argv[1], gsl_vector, v); gsl_ran_shuffle(r, v->data, FIX2INT(argv[2]), sizeof(double)); } else if (PERMUTATION_P(argv[1])) { Data_Get_Struct(argv[1], gsl_permutation, p); gsl_ran_shuffle(r, p->data, FIX2INT(argv[2]), sizeof(size_t)); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[1]))); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } break; default: Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 1: if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, v); gsl_ran_shuffle(r, v->data, v->size, sizeof(double)); } else if (PERMUTATION_P(argv[0])) { Data_Get_Struct(argv[0], gsl_permutation, p); gsl_ran_shuffle(r, p->data, p->size, sizeof(size_t)); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[0]))); } break; case 2: CHECK_FIXNUM(argv[1]); if (VECTOR_P(argv[0])) { Data_Get_Struct(argv[0], gsl_vector, v); gsl_ran_shuffle(r, v->data, FIX2INT(argv[1]), sizeof(double)); } else if (PERMUTATION_P(argv[0])) { Data_Get_Struct(argv[0], gsl_permutation, p); gsl_ran_shuffle(r, p->data, FIX2INT(argv[1]), sizeof(size_t)); } else { rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[0]))); } default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } break; } return Qnil; } static VALUE rb_gsl_ran_choose(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v = NULL, *v2 = NULL; size_t k, n; Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 2: CHECK_VECTOR(argv[0]); CHECK_FIXNUM(argv[1]); Data_Get_Struct(argv[0], gsl_vector, v); n = v->size; k = FIX2INT(argv[1]); if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector."); v2 = gsl_vector_alloc(k); gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);; break; case 1: CHECK_VECTOR(argv[0]); Data_Get_Struct(argv[0], gsl_vector, v); n = v->size; k = v->size; if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector."); v2 = gsl_vector_alloc(k); gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } } static VALUE rb_gsl_ran_choose_singleton(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v = NULL, *v2 = NULL; size_t k, n; switch (argc) { case 3: CHECK_RNG(argv[0]); CHECK_VECTOR(argv[1]); CHECK_FIXNUM(argv[2]); Data_Get_Struct(argv[0], gsl_rng, r); Data_Get_Struct(argv[1], gsl_vector, v); n = v->size; k = FIX2INT(argv[2]); if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector."); v2 = gsl_vector_alloc(k); gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);; break; case 2: CHECK_RNG(argv[0]); CHECK_VECTOR(argv[1]); Data_Get_Struct(argv[0], gsl_rng, r); Data_Get_Struct(argv[1], gsl_vector, v); n = v->size; k = v->size; if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector."); v2 = gsl_vector_alloc(k); gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc); break; } } static VALUE rb_gsl_ran_sample(VALUE obj, VALUE vv, VALUE kk) { gsl_rng *r = NULL; gsl_vector *v = NULL, *v2 = NULL; size_t k, n; Data_Get_Struct(obj, gsl_rng, r); Data_Get_Struct(vv, gsl_vector, v); n = v->size; k = FIX2INT(kk); v2 = gsl_vector_alloc(k); gsl_ran_sample(r, v2->data, k, v->data, n, sizeof(double)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);; } #ifdef GSL_1_3_LATER static VALUE rb_gsl_ran_dirichlet(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v = NULL, *v2 = NULL; Data_Get_Struct(obj, gsl_rng, r); if (argc == 1) { Data_Get_Struct(argv[0], gsl_vector, v); v2 = gsl_vector_alloc(v->size); gsl_ran_dirichlet(r, v->size, v->data, v2->data); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2); } else if (argc == 2) { Data_Get_Struct(argv[0], gsl_vector, v); Data_Get_Struct(argv[1], gsl_vector, v2); gsl_ran_dirichlet(r, v->size, v->data, v2->data); return obj; } else { rb_raise(rb_eArgError, "wrong number of arguments (1 or 2 GSL_Vectors)"); } } static VALUE rb_gsl_ran_dirichlet_pdf(VALUE obj, VALUE a, VALUE t) { gsl_vector *alpha = NULL, *theta = NULL; Data_Get_Struct(a, gsl_vector, alpha); Data_Get_Struct(t, gsl_vector, theta); return rb_float_new(gsl_ran_dirichlet_pdf(alpha->size, alpha->data, theta->data)); } static VALUE rb_gsl_ran_dirichlet_lnpdf(VALUE obj, VALUE a, VALUE t) { gsl_vector *alpha = NULL, *theta = NULL; Data_Get_Struct(a, gsl_vector, alpha); Data_Get_Struct(t, gsl_vector, theta); return rb_float_new(gsl_ran_dirichlet_lnpdf(alpha->size, alpha->data, theta->data)); } #endif static VALUE rb_gsl_ran_discrete_new(VALUE klass, VALUE vv) { gsl_vector *v = NULL; gsl_ran_discrete_t *g = NULL; Data_Get_Struct(vv, gsl_vector, v); g = gsl_ran_discrete_preproc(v->size, v->data); return Data_Wrap_Struct(klass, 0, gsl_ran_discrete_free, g); } static VALUE rb_gsl_ran_discrete(VALUE obj, VALUE gg) { gsl_rng *r = NULL; gsl_ran_discrete_t *g = NULL; Data_Get_Struct(obj, gsl_rng, r); Data_Get_Struct(gg, gsl_ran_discrete_t, g); return INT2FIX(gsl_ran_discrete(r, g)); } static VALUE rb_gsl_ran_discrete_pdf(VALUE obj, VALUE k, VALUE gg) { gsl_ran_discrete_t *g = NULL; Data_Get_Struct(gg, gsl_ran_discrete_t, g); return rb_float_new(gsl_ran_discrete_pdf(FIX2INT(k), g)); } #ifdef HAVE_NARRAY_H #include "narray.h" #endif /*****/ VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double)) { VALUE x, ary; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; size_t i, j, n; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch(TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*f)(NUM2DBL(xx))); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); rb_ary_store(ary, i, rb_float_new((*f)(NUM2DBL(x)))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { xx = na_change_type(xx, NA_DFLOAT); GetNArray(xx, na); ptr1 = (double *) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*f)(ptr1[i]); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i))); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j))); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } /* never reach here */ return Qnil; } VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa, double (*f)(double, double)) { VALUE x, ary; double a; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; size_t i, j, n; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif Need_Float(aa); a = NUM2DBL(aa); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch(TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*f)(NUM2DBL(xx), a)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); rb_ary_store(ary, i, rb_float_new((*f)(NUM2DBL(x), a))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { xx = na_change_type(xx, NA_DFLOAT); GetNArray(xx, na); ptr1 = (double *) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*f)(ptr1[i], a); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i), a)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j), a)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } /* never reach here */ return Qnil; } VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb, double (*f)(double, double, double)) { VALUE x, ary; double a, b; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; size_t i, j, n; #ifdef HAVE_NARRAY_H struct NARRAY *na; double *ptr1, *ptr2; #endif Need_Float(aa); Need_Float(bb); a = NUM2DBL(aa); b = NUM2DBL(bb); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch(TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*f)(NUM2DBL(xx), a, b)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); Need_Float(x); rb_ary_store(ary, i, rb_float_new((*f)(NUM2DBL(x), a, b))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { xx = na_change_type(xx, NA_DFLOAT); GetNArray(xx, na); ptr1 = (double *) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) ptr2[i] = (*f)(ptr1[i], a, b); return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i), a, b)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j), a, b)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } /* never reach here */ return Qnil; } VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa, double (*f)(unsigned int, double)) { VALUE x, ary; double a; gsl_vector *v = NULL, *vnew = NULL; gsl_vector_int *vi = NULL; gsl_matrix *m = NULL, *mnew = NULL; gsl_matrix_int *mi = NULL; size_t i, j, n; #ifdef HAVE_NARRAY_H struct NARRAY *na; char *ptr1, *ptr2; #endif Need_Float(aa); a = NUM2DBL(aa); if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx); switch(TYPE(xx)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: return rb_float_new((*f)(NUM2UINT(xx), a)); break; case T_ARRAY: // n = RARRAY(xx)->len; n = RARRAY_LEN(xx); ary = rb_ary_new2(n); for (i = 0; i < n; i++) { x = rb_ary_entry(xx, i); rb_ary_store(ary, i, rb_float_new((*f)(NUM2UINT(x), a))); } return ary; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(xx)) { GetNArray(xx, na); n = na->total; ary = na_make_object(na->type, na->rank, na->shape, CLASS_OF(xx)); ptr1 = (char *)na->ptr; ptr2 = (char *)NA_STRUCT(ary)->ptr; switch (na->type) { case NA_LINT: for (i = 0; i < n; i++) ((int*)ptr2)[i] = (*f)((unsigned int) ((int*)ptr1)[i], a); break; default: for (i = 0; i < n; i++) ((double*)ptr2)[i] = (*f)((unsigned int) ((double*)ptr1)[i], a); break; } return ary; } #endif if (VECTOR_P(xx)) { Data_Get_Struct(xx, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { gsl_vector_set(vnew, i, (*f)((unsigned int) gsl_vector_get(v, i), a)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (VECTOR_INT_P(xx)) { Data_Get_Struct(xx, gsl_vector_int, vi); vnew = gsl_vector_alloc(vi->size); for (i = 0; i < vi->size; i++) { gsl_vector_set(vnew, i, (*f)((unsigned int) gsl_vector_int_get(vi, i), a)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(xx)) { Data_Get_Struct(xx, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { gsl_matrix_set(mnew, i, j, (*f)((unsigned int) gsl_matrix_get(m, i, j), a)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else if (MATRIX_INT_P(xx)) { Data_Get_Struct(xx, gsl_matrix_int, mi); mnew = gsl_matrix_alloc(mi->size1, mi->size2); for (i = 0; i < mi->size1; i++) { for (j = 0; j < mi->size2; j++) { gsl_matrix_set(mnew, i, j, (*f)((unsigned int) gsl_matrix_int_get(mi, i, j), a)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } /* never reach here */ return Qnil; } /* static VALUE rb_gsl_ran_erlang(VALUE obj, VALUE a, VALUE n) { gsl_rng *r = NULL; Data_Get_Struct(obj, gsl_rng, r); return rb_float_new(gsl_ran_erlang(r, NUM2DBL(a), NUM2DBL(n))); } static VALUE rb_gsl_ran_erlang_pdf(VALUE obj, VALUE x, VALUE a, VALUE n) { return rb_float_new(gsl_ran_erlang_pdf(NUM2DBL(x), NUM2DBL(a), NUM2DBL(n))); } */ #ifdef GSL_1_8_LATER static VALUE rb_gsl_ran_gaussian_ziggurat(int argc, VALUE *argv, VALUE obj) { gsl_rng *r = NULL; gsl_vector *v; size_t n, i; double sigma = 1.0; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: switch (argc) { case 3: n = NUM2INT(argv[2]); sigma = NUM2DBL(argv[1]); CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, gsl_ran_gaussian_ziggurat(r, sigma)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 2: sigma = NUM2DBL(argv[1]); /* no break */ case 1: CHECK_RNG(argv[0]); Data_Get_Struct(argv[0], gsl_rng, r); return rb_float_new(gsl_ran_gaussian_ziggurat(r, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 1 or 2)", argc); return Qnil; break; } break; default: Data_Get_Struct(obj, gsl_rng, r); switch (argc) { case 2: n = NUM2INT(argv[1]); sigma = NUM2DBL(argv[0]); v = gsl_vector_alloc(n); for (i = 0; i < n; i++) gsl_vector_set(v, i, gsl_ran_gaussian_ziggurat(r, sigma)); return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v); break; case 1: sigma = NUM2DBL(argv[0]); /* no break */ case 0: return rb_float_new(gsl_ran_gaussian_ziggurat(r, sigma)); break; default: rb_raise(rb_eArgError, "too many arguments (%d for 0 or 1)", argc); return Qnil; break; } break; } return Qnil; } static VALUE rb_gsl_ran_gamma_mt(int argc, VALUE *argv, VALUE obj) { return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_gamma_mt); } #endif void Init_gsl_ran(VALUE module) { VALUE mgsl_ran; VALUE cgsl_ran_discrete; mgsl_ran = rb_define_module_under(module, "Ran"); rb_define_module_function(mgsl_ran, "gaussian", rb_gsl_ran_gaussian, -1); rb_define_module_function(mgsl_ran, "ugaussian", rb_gsl_ran_gaussian, -1); rb_define_method(cgsl_rng, "gaussian", rb_gsl_ran_gaussian, -1); rb_define_alias(cgsl_rng, "ugaussian", "gaussian"); rb_define_module_function(mgsl_ran, "gaussian_ratio_method", rb_gsl_ran_gaussian_ratio_method, -1); rb_define_module_function(mgsl_ran, "ugaussian_ratio_method", rb_gsl_ran_gaussian_ratio_method, -1); rb_define_method(cgsl_rng, "gaussian_ratio_method", rb_gsl_ran_gaussian_ratio_method, -1); rb_define_alias(cgsl_rng, "ugaussian_ratio_method", "gaussian_ratio_method"); rb_define_module_function(mgsl_ran, "gaussian_pdf", rb_gsl_ran_gaussian_pdf, -1); rb_define_module_function(mgsl_ran, "ugaussian_pdf", rb_gsl_ran_gaussian_pdf, -1); rb_define_module_function(mgsl_ran, "gaussian_tail", rb_gsl_ran_gaussian_tail, -1); rb_define_module_function(mgsl_ran, "ugaussian_tail", rb_gsl_ran_gaussian_tail, -1); rb_define_method(cgsl_rng, "gaussian_tail", rb_gsl_ran_gaussian_tail, -1); rb_define_alias(cgsl_rng, "ugaussian_tail", "gaussian_tail"); rb_define_module_function(mgsl_ran, "gaussian_tail_pdf", rb_gsl_ran_gaussian_tail_pdf, -1); rb_define_module_function(mgsl_ran, "ugaussian_tail_pdf", rb_gsl_ran_gaussian_tail_pdf, -1); rb_define_module_function(mgsl_ran, "bivariate_gaussian", rb_gsl_ran_bivariate_gaussian, -1); rb_define_method(cgsl_rng, "bivariate_gaussian", rb_gsl_ran_bivariate_gaussian, -1); rb_define_module_function(mgsl_ran, "bivariate_gaussian_pdf", rb_gsl_ran_bivariate_gaussian_pdf, 5); rb_define_module_function(mgsl_ran, "exponential", rb_gsl_ran_exponential, -1); rb_define_method(cgsl_rng, "exponential", rb_gsl_ran_exponential, -1); rb_define_module_function(mgsl_ran, "exponential_pdf", rb_gsl_ran_exponential_pdf, 2); rb_define_module_function(mgsl_ran, "laplace", rb_gsl_ran_laplace, -1); rb_define_method(cgsl_rng, "laplace", rb_gsl_ran_laplace, -1); rb_define_module_function(mgsl_ran, "laplace_pdf", rb_gsl_ran_laplace_pdf, 2); rb_define_module_function(mgsl_ran, "exppow", rb_gsl_ran_exppow, -1); rb_define_method(cgsl_rng, "exppow", rb_gsl_ran_exppow, -1); rb_define_module_function(mgsl_ran, "exppow_pdf", rb_gsl_ran_exppow_pdf, 3); rb_define_module_function(mgsl_ran, "cauchy", rb_gsl_ran_cauchy, -1); rb_define_method(cgsl_rng, "cauchy", rb_gsl_ran_cauchy, -1); rb_define_module_function(mgsl_ran, "cauchy_pdf", rb_gsl_ran_cauchy_pdf, 2); rb_define_module_function(mgsl_ran, "rayleigh", rb_gsl_ran_rayleigh, -1); rb_define_method(cgsl_rng, "rayleigh", rb_gsl_ran_rayleigh, -1); rb_define_module_function(mgsl_ran, "rayleigh_pdf", rb_gsl_ran_rayleigh_pdf, 2); rb_define_module_function(mgsl_ran, "rayleigh_tail", rb_gsl_ran_rayleigh_tail, -1); rb_define_method(cgsl_rng, "rayleigh_tail", rb_gsl_ran_rayleigh_tail, -1); rb_define_module_function(mgsl_ran, "rayleigh_tail_pdf", rb_gsl_ran_rayleigh_tail_pdf, 3); rb_define_module_function(mgsl_ran, "landau", rb_gsl_ran_landau, -1); rb_define_method(cgsl_rng, "landau", rb_gsl_ran_landau, -1); rb_define_module_function(mgsl_ran, "landau_pdf", rb_gsl_ran_landau_pdf, 1); rb_define_method(cgsl_rng, "levy", rb_gsl_ran_levy, -1); rb_define_method(cgsl_rng, "levy_skew", rb_gsl_ran_levy_skew, -1); rb_define_module_function(mgsl_ran, "levy", rb_gsl_ran_levy, -1); rb_define_module_function(mgsl_ran, "levy_skew", rb_gsl_ran_levy_skew, -1); rb_define_module_function(mgsl_ran, "gamma", rb_gsl_ran_gamma, -1); rb_define_method(cgsl_rng, "gamma", rb_gsl_ran_gamma, -1); rb_define_module_function(mgsl_ran, "gamma_pdf", rb_gsl_ran_gamma_pdf, 3); rb_define_module_function(mgsl_ran, "flat", rb_gsl_ran_flat, -1); rb_define_method(cgsl_rng, "flat", rb_gsl_ran_flat, -1); rb_define_module_function(mgsl_ran, "flat_pdf", rb_gsl_ran_flat_pdf, 3); rb_define_module_function(mgsl_ran, "lognormal", rb_gsl_ran_lognormal, -1); rb_define_method(cgsl_rng, "lognormal", rb_gsl_ran_lognormal, -1); rb_define_module_function(mgsl_ran, "lognormal_pdf", rb_gsl_ran_lognormal_pdf, 3); rb_define_module_function(mgsl_ran, "chisq", rb_gsl_ran_chisq, -1); rb_define_method(cgsl_rng, "chisq", rb_gsl_ran_chisq, -1); rb_define_module_function(mgsl_ran, "chisq_pdf", rb_gsl_ran_chisq_pdf, 2); rb_define_module_function(mgsl_ran, "fdist", rb_gsl_ran_fdist, -1); rb_define_method(cgsl_rng, "fdist", rb_gsl_ran_fdist, -1); rb_define_module_function(mgsl_ran, "fdist_pdf", rb_gsl_ran_fdist_pdf, 3); rb_define_module_function(mgsl_ran, "tdist", rb_gsl_ran_tdist, -1); rb_define_method(cgsl_rng, "tdist", rb_gsl_ran_tdist, -1); rb_define_module_function(mgsl_ran, "tdist_pdf", rb_gsl_ran_tdist_pdf, 2); rb_define_module_function(mgsl_ran, "beta", rb_gsl_ran_beta, -1); rb_define_method(cgsl_rng, "beta", rb_gsl_ran_beta, -1); rb_define_module_function(mgsl_ran, "beta_pdf", rb_gsl_ran_beta_pdf, 3); rb_define_module_function(mgsl_ran, "logistic", rb_gsl_ran_logistic, -1); rb_define_method(cgsl_rng, "logistic", rb_gsl_ran_logistic, -1); rb_define_module_function(mgsl_ran, "logistic_pdf", rb_gsl_ran_logistic_pdf, 2); rb_define_module_function(mgsl_ran, "pareto", rb_gsl_ran_pareto, -1); rb_define_method(cgsl_rng, "pareto", rb_gsl_ran_pareto, -1); rb_define_module_function(mgsl_ran, "pareto_pdf", rb_gsl_ran_pareto_pdf, 3); rb_define_module_function(mgsl_ran, "weibull", rb_gsl_ran_weibull, -1); rb_define_method(cgsl_rng, "weibull", rb_gsl_ran_weibull, -1); rb_define_module_function(mgsl_ran, "weibull_pdf", rb_gsl_ran_weibull_pdf, 3); rb_define_module_function(mgsl_ran, "gumbel1", rb_gsl_ran_gumbel1, -1); rb_define_method(cgsl_rng, "gumbel1", rb_gsl_ran_gumbel1, -1); rb_define_module_function(mgsl_ran, "gumbel1_pdf", rb_gsl_ran_gumbel1_pdf, 3); rb_define_module_function(mgsl_ran, "gumbel2", rb_gsl_ran_gumbel2, -1); rb_define_method(cgsl_rng, "gumbel2", rb_gsl_ran_gumbel2, -1); rb_define_module_function(mgsl_ran, "gumbel2_pdf", rb_gsl_ran_gumbel2_pdf, 3); rb_define_module_function(mgsl_ran, "poisson", rb_gsl_ran_poisson, -1); rb_define_method(cgsl_rng, "poisson", rb_gsl_ran_poisson, -1); rb_define_module_function(mgsl_ran, "poisson_pdf", rb_gsl_ran_poisson_pdf, 2); rb_define_module_function(mgsl_ran, "bernoulli", rb_gsl_ran_bernoulli, -1); rb_define_method(cgsl_rng, "bernoulli", rb_gsl_ran_bernoulli, -1); rb_define_module_function(mgsl_ran, "bernoulli_pdf", rb_gsl_ran_bernoulli_pdf, 2); rb_define_module_function(mgsl_ran, "binomial", rb_gsl_ran_binomial, -1); rb_define_method(cgsl_rng, "binomial", rb_gsl_ran_binomial, -1); #ifdef GSL_1_4_LATER rb_define_module_function(mgsl_ran, "binomial_tpe", rb_gsl_ran_binomial_tpe, -1); rb_define_method(cgsl_rng, "binomial_tpe", rb_gsl_ran_binomial_tpe, -1); #endif rb_define_module_function(mgsl_ran, "binomial_pdf", rb_gsl_ran_binomial_pdf, 3); rb_define_module_function(mgsl_ran, "negative_binomial", rb_gsl_ran_negative_binomial, -1); rb_define_method(cgsl_rng, "negative_binomial", rb_gsl_ran_negative_binomial, -1); rb_define_module_function(mgsl_ran, "negative_binomial_pdf", rb_gsl_ran_negative_binomial_pdf, 3); rb_define_module_function(mgsl_ran, "pascal", rb_gsl_ran_pascal, -1); rb_define_method(cgsl_rng, "pascal", rb_gsl_ran_pascal, -1); rb_define_module_function(mgsl_ran, "pascal_pdf", rb_gsl_ran_pascal_pdf, 3); rb_define_module_function(mgsl_ran, "geometric", rb_gsl_ran_geometric, -1); rb_define_method(cgsl_rng, "geometric", rb_gsl_ran_geometric, -1); rb_define_module_function(mgsl_ran, "geometric_pdf", rb_gsl_ran_geometric_pdf, 2); rb_define_module_function(mgsl_ran, "hypergeometric", rb_gsl_ran_hypergeometric, -1); rb_define_method(cgsl_rng, "hypergeometric", rb_gsl_ran_hypergeometric, -1); rb_define_module_function(mgsl_ran, "hypergeometric_pdf", rb_gsl_ran_hypergeometric_pdf, 4); rb_define_module_function(mgsl_ran, "logarithmic", rb_gsl_ran_logarithmic, -1); rb_define_method(cgsl_rng, "logarithmic", rb_gsl_ran_logarithmic, -1); rb_define_module_function(mgsl_ran, "logarithmic_pdf", rb_gsl_ran_logarithmic_pdf, 2); rb_define_module_function(mgsl_ran, "dir_2d", rb_gsl_ran_dir_2d, -1); rb_define_module_function(mgsl_ran, "dir_2d_trig_method", rb_gsl_ran_dir_2d_trig_method, -1); rb_define_module_function(mgsl_ran, "dir_3d", rb_gsl_ran_dir_3d, -1); rb_define_module_function(mgsl_ran, "dir_nd", rb_gsl_ran_dir_nd, -1); rb_define_method(cgsl_rng, "dir_2d", rb_gsl_ran_dir_2d, -1); rb_define_method(cgsl_rng, "dir_2d_trig_method", rb_gsl_ran_dir_2d_trig_method, -1); rb_define_method(cgsl_rng, "dir_3d", rb_gsl_ran_dir_3d, -1); rb_define_method(cgsl_rng, "dir_nd", rb_gsl_ran_dir_nd, -1); rb_define_method(cgsl_rng, "shuffle", rb_gsl_ran_shuffle, -1); rb_define_module_function(mgsl_ran, "shuffle", rb_gsl_ran_shuffle, -1); rb_define_method(cgsl_rng, "choose", rb_gsl_ran_choose, -1); rb_define_singleton_method(mgsl_ran, "choose", rb_gsl_ran_choose_singleton, -1); rb_define_method(cgsl_rng, "sample", rb_gsl_ran_sample, 2); /*****/ cgsl_ran_discrete = rb_define_class_under(mgsl_ran, "Discrete", cGSL_Object); rb_define_singleton_method(cgsl_ran_discrete, "alloc", rb_gsl_ran_discrete_new, 1); rb_define_singleton_method(cgsl_ran_discrete, "preproc", rb_gsl_ran_discrete_new, 1); rb_define_method(cgsl_rng, "discrete", rb_gsl_ran_discrete, 1); rb_define_module_function(mgsl_ran, "discrete_pdf", rb_gsl_ran_discrete_pdf, 2); #ifdef GSL_1_3_LATER rb_define_method(cgsl_rng, "dirichlet", rb_gsl_ran_dirichlet, -1); rb_define_module_function(mgsl_ran, "dirichlet_pdf", rb_gsl_ran_dirichlet_pdf, 2); rb_define_module_function(mgsl_ran, "dirichlet_lnpdf", rb_gsl_ran_dirichlet_lnpdf, 2); #endif /* rb_define_method(cgsl_rng, "erlang", rb_gsl_ran_erlang, 2); rb_define_method(module, "ran_erlang_pdf", rb_gsl_ran_erlang_pdf, 3); rb_define_method(mgsl_ran, "erlang_pdf", rb_gsl_ran_erlang_pdf, 3);*/ #ifdef GSL_1_8_LATER rb_define_module_function(mgsl_ran, "gaussian_ziggurat", rb_gsl_ran_gaussian_ziggurat, -1); rb_define_method(cgsl_rng, "gaussian_ziggurat", rb_gsl_ran_gaussian_ziggurat, -1); rb_define_module_function(mgsl_ran, "gamma_mt", rb_gsl_ran_gamma_mt, -1); rb_define_method(cgsl_rng, "gamma_mt", rb_gsl_ran_gamma_mt, -1); #endif } gsl-1.15.3/ext/matrix.c0000644000175000017500000000174312220252463014217 0ustar boutilboutil/* matrix.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ /* This code uses "templates_on.h" and "templates_off.h", which are provided by the GSL source. */ #include "rb_gsl_config.h" #include "rb_gsl_array.h" #include "rb_gsl_histogram.h" #include "rb_gsl_complex.h" #include "rb_gsl_poly.h" #ifdef HAVE_NARRAY_H #include "rb_gsl_with_narray.h" #endif int gsl_linalg_matmult_int(const gsl_matrix_int *A, const gsl_matrix_int *B, gsl_matrix_int *C); #define BASE_DOUBLE #include "templates_on.h" #include "matrix_source.c" #include "templates_off.h" #undef BASE_DOUBLE #define BASE_INT #include "templates_on.h" #include "matrix_source.c" #include "templates_off.h" #undef BASE_INT gsl-1.15.3/ext/sf_exp.c0000644000175000017500000001265712220252463014205 0ustar boutilboutil/* sf_exp.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "rb_gsl_sf.h" static VALUE rb_gsl_sf_exp(VALUE obj, VALUE x) { if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) { return rb_gsl_math_complex_eval(gsl_complex_exp, x); } else { return rb_gsl_sf_eval1(gsl_sf_exp, x); } } static VALUE rb_gsl_sf_exp_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_exp_e, x); } static VALUE rb_gsl_sf_exp_e10_e(VALUE obj, VALUE x) { gsl_sf_result_e10 *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); v = Data_Make_Struct(cgsl_sf_result_e10, gsl_sf_result_e10, 0, free, rslt); /*status =*/ gsl_sf_exp_e10_e(NUM2DBL(x), rslt); return v; } static VALUE rb_gsl_sf_exp_mult(VALUE obj, VALUE x, VALUE y) { Need_Float(x); Need_Float(y); return rb_float_new(gsl_sf_exp_mult(NUM2DBL(x), NUM2DBL(y))); } static VALUE rb_gsl_sf_exp_mult_e(VALUE obj, VALUE x, VALUE y) { return rb_gsl_sf_eval_e_double2(gsl_sf_exp_mult_e, x, y); } static VALUE rb_gsl_sf_exp_mult_e10_e(VALUE obj, VALUE x, VALUE y) { gsl_sf_result_e10 *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(y); v = Data_Make_Struct(cgsl_sf_result_e10, gsl_sf_result_e10, 0, free, rslt); /*status =*/ gsl_sf_exp_mult_e10_e(NUM2DBL(x), NUM2DBL(y), rslt); return v; } static VALUE rb_gsl_sf_expm1(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_expm1, x); } static VALUE rb_gsl_sf_expm1_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_expm1_e, x); } static VALUE rb_gsl_sf_exprel(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_exprel, x); } static VALUE rb_gsl_sf_exprel_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_exprel_e, x); } static VALUE rb_gsl_sf_exprel_2(VALUE obj, VALUE x) { return rb_gsl_sf_eval1(gsl_sf_exprel_2, x); } static VALUE rb_gsl_sf_exprel_2_e(VALUE obj, VALUE x) { return rb_gsl_sf_eval_e(gsl_sf_exprel_2_e, x); } static VALUE rb_gsl_sf_exprel_n(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_int_double(gsl_sf_exprel_n, n, x); } static VALUE rb_gsl_sf_exprel_n_e(VALUE obj, VALUE n, VALUE x) { return rb_gsl_sf_eval_e_int_double(gsl_sf_exprel_n_e, n, x); } static VALUE rb_gsl_sf_exp_err_e(VALUE obj, VALUE x, VALUE dx) { return rb_gsl_sf_eval_e_double2(gsl_sf_exp_err_e, x, dx); } static VALUE rb_gsl_sf_exp_err_e10_e(VALUE obj, VALUE x, VALUE dx) { gsl_sf_result_e10 *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(dx); v = Data_Make_Struct(cgsl_sf_result_e10, gsl_sf_result_e10, 0, free, rslt); /*status =*/ gsl_sf_exp_err_e10_e(NUM2DBL(x), NUM2DBL(dx), rslt); return v; } static VALUE rb_gsl_sf_exp_mult_err_e(VALUE obj, VALUE x, VALUE dx, VALUE y, VALUE dy) { gsl_sf_result *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(y); Need_Float(dx); Need_Float(dy); v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt); /*status =*/ gsl_sf_exp_mult_err_e(NUM2DBL(x), NUM2DBL(dx), NUM2DBL(y), NUM2DBL(dy), rslt); return v; } static VALUE rb_gsl_sf_exp_mult_err_e10_e(VALUE obj, VALUE x, VALUE dx, VALUE y, VALUE dy) { gsl_sf_result_e10 *rslt = NULL; VALUE v; // local variable "status" declared and set, but never used //int status; Need_Float(x); Need_Float(y); Need_Float(dx); Need_Float(dy); v = Data_Make_Struct(cgsl_sf_result_e10, gsl_sf_result_e10, 0, free, rslt); /*status =*/ gsl_sf_exp_mult_err_e10_e(NUM2DBL(x), NUM2DBL(dx), NUM2DBL(y), NUM2DBL(dy), rslt); return v; } void Init_gsl_sf_exp(VALUE module) { rb_define_module_function(module, "exp", rb_gsl_sf_exp, 1); rb_define_module_function(module, "exp_e", rb_gsl_sf_exp_e, 1); rb_define_module_function(module, "exp_e10_e", rb_gsl_sf_exp_e10_e, 1); rb_define_module_function(module, "exp_mult", rb_gsl_sf_exp_mult, 2); rb_define_module_function(module, "exp_mult_e", rb_gsl_sf_exp_mult_e, 2); rb_define_module_function(module, "exp_mult_e10_e", rb_gsl_sf_exp_mult_e10_e, 2); rb_define_module_function(module, "expm1", rb_gsl_sf_expm1, 1); rb_define_module_function(module, "expm1_e", rb_gsl_sf_expm1_e, 1); rb_define_module_function(module, "exprel", rb_gsl_sf_exprel, 1); rb_define_module_function(module, "exprel_e", rb_gsl_sf_exprel_e, 1); rb_define_module_function(module, "exprel_2", rb_gsl_sf_exprel_2, 1); rb_define_module_function(module, "exprel_2_e", rb_gsl_sf_exprel_2_e, 1); rb_define_module_function(module, "exprel_n", rb_gsl_sf_exprel_n, 2); rb_define_module_function(module, "exprel_n_e", rb_gsl_sf_exprel_n_e, 2); rb_define_module_function(module, "exp_err_e", rb_gsl_sf_exp_err_e, 2); rb_define_module_function(module, "exp_err_e10_e", rb_gsl_sf_exp_err_e10_e, 2); rb_define_module_function(module, "exp_mult_err_e", rb_gsl_sf_exp_mult_err_e, 4); rb_define_module_function(module, "exp_mult_err_e10_e", rb_gsl_sf_exp_mult_err_e10_e, 4); } gsl-1.15.3/ext/poly.c0000644000175000017500000000174412220252463013677 0ustar boutilboutil/* poly.c Ruby/GSL: Ruby extension library for GSL (GNU Scientific Library) (C) Copyright 2001-2006 by Yoshiki Tsunesada Ruby/GSL is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. */ #include "rb_gsl_config.h" #include "rb_gsl_poly.h" #include "rb_gsl_array.h" #include "rb_gsl_common.h" #ifdef HAVE_NARARY_H #include "narray.h" #endif void Init_gsl_poly_init(VALUE module); void Init_gsl_poly_int_init(VALUE module); void Init_gsl_poly2(VALUE module); #define BASE_DOUBLE #include "templates_on.h" #include "poly_source.c" #include "templates_off.h" void Init_gsl_poly(VALUE module) { Init_gsl_poly_init(module); } #undef BASE_DOUBLE #define BASE_INT #include "templates_on.h" #include "poly_source.c" #include "templates_off.h" void Init_gsl_poly_int(VALUE module) { Init_gsl_poly_int_init(module); } #undef BASE_INT gsl-1.15.3/VERSION0000644000175000017500000000000712220252463013007 0ustar boutilboutil1.15.3 gsl-1.15.3/Rakefile0000644000175000017500000000470712220252463013417 0ustar boutilboutilrequire 'rubygems' require 'rubygems/package_task' require 'rake/rdoctask' RB_GSL_VERSION = File.readlines('VERSION')[0].chomp spec = Gem::Specification.new do |s| # Basics s.name = 'gsl' s.version = RB_GSL_VERSION s.summary = 'Ruby interface to GNU Scientific Library' s.description = 'Ruby/GSL is a Ruby interface to the GNU Scientific Library, for numerical computing with Ruby' #s.platform = Gem::Platform::Ruby s.required_ruby_version = '>= 1.8.1' s.requirements << 'GSL (http://www.gnu.org/software/gsl/)' # plotlib? s.add_dependency('narray', '>= 0.5.9') # About s.authors = ['Yoshiki Tsunesada', 'David MacMahon'] s.email = 'y-tsunesada@mm.em-net.ne.jp' s.homepage = 'http://rb-gsl.rubyforge.org/' s.rubyforge_project = 'rb-gsl' # Files, Libraries, and Extensions s.files = FileList[ 'AUTHORS', 'COPYING', 'ChangeLog', 'README', 'Rakefile', 'setup.rb', 'THANKS', 'VERSION', 'examples/**/*', 'ext/extconf.rb', 'ext/*.c', 'lib/**/*', 'include/*', 'rdoc/*', 'tests/**/*' ].to_a s.require_paths = ['lib', 'lib/gsl', 'lib/ool', 'ext'] #s.autorequire = nil #s.bindir = 'bin' #s.executables = [] #s.default_executable = nil # C compilation s.extensions = %w[ ext/extconf.rb ] # Documentation s.has_rdoc = true s.rdoc_options = [ '--title', 'Ruby/GSL', '--main', 'rdoc/index.rdoc', '--exclude', 'ext/', '--exclude', 'include/', '--exclude', 'lib/', ] s.extra_rdoc_files = FileList['rdoc/*'].to_a # Testing TODO #s.test_files = [] end Rake::PackageTask.new('rb-gsl', RB_GSL_VERSION) do |pkg| pkg.need_zip = true pkg.need_tar = true pkg.package_files = spec.files end Gem::PackageTask.new(spec) do |pkg| pkg.need_zip = false pkg.need_tar = false end task :default => [:package, :gem] # -------------------------------------------------------------------- # Create a task to build the RDOC documentation tree. desc "Create the RDoc html files" Rake::RDocTask.new("rdoc") { |rdoc| rdoc.rdoc_dir = 'html' rdoc.title = 'Ruby/GSL' rdoc.main = 'rdoc/index.rdoc' rdoc.options << '--exclude' << 'ext/' rdoc.options << '--exclude' << 'include/' rdoc.options << '--exclude' << 'lib/' rdoc.rdoc_files.include('rdoc/*.rdoc') } desc "Publish the RDoc files on RubyForge" task :pub_rdoc => ["html/index.html"] do mkdir_p "emptydir" sh "scp -rq html/* www.rubyforge.org:/var/www/gforge-projects/rb-gsl/." rm_r "emptydir" end gsl-1.15.3/tests/0000755000175000017500000000000012220252463013104 5ustar boutilboutilgsl-1.15.3/tests/err.rb0000755000175000017500000000317612220252463014233 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "sum/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test MAX_ERRS = 64 class ErrCode attr_accessor :number attr_accessor :name def initialize(number, name) @number = number @name = name end end errors = ["GSL::SUCCESS", "GSL::FAILURE", "GSL::CONTINUE", "GSL::EDOM", "GSL::ERANGE", "GSL::EFAULT", "GSL::EINVAL", "GSL::EFAILED", "GSL::EFACTOR", "GSL::ESANITY", "GSL::ENOMEM", "GSL::EBADFUNC", "GSL::ERUNAWAY", "GSL::EMAXITER", "GSL::EZERODIV", "GSL::EBADTOL", "GSL::ETOL", "GSL::EUNDRFLW", "GSL::EOVRFLW", "GSL::ELOSS", "GSL::EROUND", "GSL::EBADLEN", "GSL::ENOTSQR", "GSL::ESING", "GSL::EDIVERGE", "GSL::EUNSUP", "GSL::EUNIMPL", "GSL::ECACHE", "GSL::ETABLE", "GSL::ENOPROG", "GSL::ENOPROGJ", "GSL::ETOLF", "GSL::ETOLX", "GSL::ETOLG", "GSL::EOF"] Errors = Array.new(errors.size) errors.each_index do |i| Errors[i] = ErrCode.new(eval("#{errors[i]}"), errors[i]) end for i in 0...Errors.size printf("%s = %d\n", Errors[i].name, Errors[i].number) end for i in 0...Errors.size status = 0 for j in 0...Errors.size if j != i status |= (Errors[i].number == Errors[j].number) ? 1 : 0 end GSL::Test::test(status, "#{Errors[i].name} is distinct from other error values") end end for i in 0...Errors.size status = 0 e1 = Errors[i].number for j in 0...Errors.size if j != i e2 = Errors[j].number status |= (GSL::strerror(e1) == GSL::strerror(e2)) ? 1 : 0 end end GSL::Test::test(status, "#{Errors[i].name} has a distinct error message") end gsl-1.15.3/tests/run-test.sh0000755000175000017500000000065312220252463015230 0ustar boutilboutil#!/bin/sh topdir=".." for f in `find . -name '*.rb'`; do if test "$f" = "./sf/make_test.rb"; then continue; fi if test "$f" = "./speed/bench.rb"; then continue; fi if test "$f" = "./tensor.rb"; then continue; fi pushd `dirname $f` > /dev/null # ruby -w -I $topdir/lib -I $topdir/ext `basename $f` ruby -w `basename $f` result=$? popd > /dev/null if test "$result" != "0"; then echo $f failed exit $result fi done gsl-1.15.3/tests/fit.rb0000755000175000017500000001113112220252463014213 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "fit/test.c" require("gsl") require("./gsl_test.rb") include GSL::Test include Math GSL::IEEE::env_setup() norris_n = 36 norris_x = GSL::Vector.alloc(0.2, 337.4, 118.2, 884.6, 10.1, 226.5, 666.3, 996.3, 448.6, 777.0, 558.2, 0.4, 0.6, 775.5, 666.9, 338.0, 447.5, 11.6, 556.0, 228.1, 995.8, 887.6, 120.2, 0.3, 0.3, 556.8, 339.1, 887.2, 999.0, 779.0, 11.1, 118.3, 229.2, 669.1, 448.9, 0.5) norris_y = GSL::Vector.alloc(0.1, 338.8, 118.1, 888.0, 9.2, 228.1, 668.5, 998.5, 449.1, 778.9, 559.2, 0.3, 0.1, 778.1, 668.8, 339.3, 448.9, 10.8, 557.7, 228.3, 998.0, 888.8, 119.6, 0.3, 0.6, 557.6, 339.3, 888.0, 998.5, 778.9, 10.2, 117.6, 228.9, 668.4, 449.2, 0.2) noint1_n = 11 noint1_x = GSL::Vector.alloc(60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70) noint1_y = GSL::Vector.alloc(130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140) noint2_n = 3 noint2_x = GSL::Vector.alloc(4, 5, 6) noint2_y = GSL::Vector.alloc(3, 4, 4) x = GSL::Vector.alloc(1000) y = GSL::Vector.alloc(1000) w = GSL::Vector.alloc(1000) xstride = 2 wstride = 3 ystride = 5 x.stride = xstride w.stride = wstride y.stride = ystride for i in 0...norris_n x.set(i, norris_x[i]) w.set(i, 1.0) y.set(i, norris_y[i]) end expected_c0 = -0.262323073774029 expected_c1 = 1.00211681802045 expected_cov00 = pow(0.232818234301152, 2.0) expected_cov01 = -7.74327536339570e-05 expected_cov11 = pow(0.429796848199937E-03, 2.0) expected_sumsq = 26.6173985294224 c0, c1, cov00, cov01, cov11, sumsq = GSL::Fit.linear(x, y, norris_n) GSL::Test::test_rel(c0, expected_c0, 1e-10, "norris gsl_fit_linear c0") GSL::Test::test_rel(c1, expected_c1, 1e-10, "norris gsl_fit_linear c1") GSL::Test::test_rel(cov00, expected_cov00, 1e-10, "norris gsl_fit_linear cov00") GSL::Test::test_rel(cov01, expected_cov01, 1e-10, "norris gsl_fit_linear cov01") GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "norris gsl_fit_linear cov11") GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "norris gsl_fit_linear sumsq") expected_c0 = -0.262323073774029 expected_c1 = 1.00211681802045 expected_cov00 = 6.92384428759429e-02 expected_cov01 = -9.89095016390515e-05 expected_cov11 = 2.35960747164148e-07 expected_sumsq = 26.6173985294224 c0, c1, cov00, cov01, cov11, sumsq = GSL::Fit.wlinear(x, w, y, norris_n) GSL::Test::test_rel(c0, expected_c0, 1e-10, "norris gsl_fit_wlinear c0") GSL::Test::test_rel(c1, expected_c1, 1e-10, "norris gsl_fit_wlinear c1") GSL::Test::test_rel(cov00, expected_cov00, 1e-10, "norris gsl_fit_wlinear cov00") GSL::Test::test_rel(cov01, expected_cov01, 1e-10, "norris gsl_fit_wlinear cov01") GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "norris gsl_fit_wlinear cov11") GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "norris gsl_fit_wlinear sumsq") for i in 0...noint1_n x.set(i, noint1_x[i]) w.set(i, 1.0) y.set(i, noint1_y[i]) end expected_c1 = 2.07438016528926 expected_cov11 = pow(0.165289256198347E-01, 2.0) expected_sumsq = 127.272727272727 c1, cov11, sumsq = GSL::Fit.mul(x, y, noint1_n) GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint1 gsl_fit_mul c1") GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint1 gsl_fit_mul cov11") GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint1 gsl_fit_mul sumsq") expected_c1 = 2.07438016528926 expected_cov11 = 2.14661371686165e-05 expected_sumsq = 127.272727272727 c1, cov11, sumsq = GSL::Fit.wmul(x, w, y, noint1_n) GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint1 gsl_fit_wmul c1") GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint1 gsl_fit_wmul cov11") GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint1 gsl_fit_wmul sumsq") for i in 0...noint2_n x.set(i, noint2_x[i]) w.set(i, 1.0) y.set(i, noint2_y[i]) end expected_c1 = 0.727272727272727 expected_cov11 = pow(0.420827318078432E-01, 2.0) expected_sumsq = 0.272727272727273 c1, cov11, sumsq = GSL::Fit.mul(x, y, noint2_n) GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint2 gsl_fit_mul c1") GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint2 gsl_fit_mul cov11") GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint2 gsl_fit_mul sumsq") expected_c1 = 0.727272727272727 expected_cov11 = 1.29870129870130e-02 expected_sumsq = 0.272727272727273 c1, cov11, sumsq = GSL::Fit.wmul(x, w, y, noint2_n) GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint2 gsl_fit_wmul c1") GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint2 gsl_fit_wmul cov11") GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint2 gsl_fit_wmul sumsq") gsl-1.15.3/tests/matrix/0000755000175000017500000000000012220252463014410 5ustar boutilboutilgsl-1.15.3/tests/matrix/matrix_test.rb0000755000175000017500000000217612220252463017311 0ustar boutilboutil#!/usr/bin/enm ruby require("gsl") require("test/unit") class MatrixTest < Test::Unit::TestCase def test_matrix_ispos_neg m = GSL::Matrix::Int.alloc([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3) assert_equal(m.ispos, 0) assert_equal(m.ispos?, false) assert_equal(m.isneg, 0) assert_equal(m.isneg?, false) m += 1 assert_equal(m.ispos, 1) assert_equal(m.ispos?, true) assert_equal(m.isneg, 0) assert_equal(m.isneg?, false) m -= 100 assert_equal(m.ispos, 0) assert_equal(m.ispos?, false) assert_equal(m.isneg, 1) assert_equal(m.isneg?, true) end def test_matrix_isnonneg m = GSL::Matrix::Int.alloc([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3) assert_equal(m.isnonneg, 1) assert_equal(m.isnonneg?, true) assert_equal(m.isneg, 0) assert_equal(m.isneg?, false) m -= 100 assert_equal(m.isnonneg, 0) assert_equal(m.isnonneg?, false) assert_equal(m.isneg, 1) assert_equal(m.isneg?, true) m += 200 assert_equal(m.isnonneg, 1) assert_equal(m.isnonneg?, true) assert_equal(m.ispos, 1) assert_equal(m.ispos?, true) end end gsl-1.15.3/tests/matrix/matrix_nmf_test.rb0000755000175000017500000000215312220252463020144 0ustar boutilboutil#!/usr/bin/env ruby # Written by Roman Shterenzon # #$:.unshift(*['lib','ext'].collect{|d| File.join(File.dirname(__FILE__),'..','..',d)}) require 'rubygems' require 'test/unit' require 'gsl' class MatrixNmfTest < Test::Unit::TestCase def setup @m1 = GSL::Matrix.alloc([6, 7, 8], [2, 3, 4], [3, 4, 5]) @m2 = GSL::Matrix.alloc([6, 7, 8], [2, 3, 4], [3, 4, 7]) end def test_difcost assert_equal(0, GSL::Matrix::NMF.difcost(@m1, @m1)) assert_equal(4, GSL::Matrix::NMF.difcost(@m1, @m2)) end def test_nmf [2, 3, 4, 5].each do |cols| res = GSL::Matrix::NMF.nmf(@m1, cols) assert_equal([3,cols], res[0].size) assert_equal([cols,3], res[1].size) cost = GSL::Matrix::NMF.difcost(@m1, res[0]*res[1]) assert(cost <= 0.000001, "Cols: #{cols}, Delta: #{cost}") end end def test_matrix_nmf [2, 3, 4, 5].each do |cols| res = @m1.nmf(cols) assert_equal([3,cols], res[0].size) assert_equal([cols,3], res[1].size) cost = GSL::Matrix::NMF.difcost(@m1, res[0]*res[1]) assert(cost <= 0.000001, "Cols: #{cols}, Delta: #{cost}") end end end gsl-1.15.3/tests/matrix/matrix_complex_test.rb0000644000175000017500000000134512220252463021032 0ustar boutilboutilrequire 'minitest/autorun' require 'minitest/unit' require 'gsl' class MatrixComplex < MiniTest::Unit::TestCase def test_eye z = GSL::Complex[1,0] m = GSL::Matrix::Complex.eye(2, z) assert_equal(z, m[0,0]) assert_equal(GSL::Complex[0,0], m[0,1]) assert_equal(GSL::Complex[0,0], m[1,0]) assert_equal(z, m[1,1]) end def test_set_row z0 = GSL::Complex[1,0] z1 = GSL::Complex[2,0] m = GSL::Matrix::Complex[2,2] m.set_row(0,z0,z1) assert_equal(z0, m[0,0]) assert_equal(z1, m[0,1]) end def test_set_col z0 = GSL::Complex[1,0] z1 = GSL::Complex[2,0] m = GSL::Matrix::Complex[2,2] m.set_col(0,z0,z1) assert_equal(z0, m[0,0]) assert_equal(z1, m[1,0]) end end gsl-1.15.3/tests/integration/0000755000175000017500000000000012220252463015427 5ustar boutilboutilgsl-1.15.3/tests/integration/integration2.rb0000755000175000017500000000516412220252463020372 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math f = GSL::Function::alloc{ |x| sin(x)/x } xmin = 0.0 xmax = 2.0*PI limit = 1000 puts("QNG") p f.integration_qng(xmin, xmax, 0.0, 1.0e-7) p f.integration_qng(xmin, xmax) p f.integration_qng([xmin, xmax]) p f.integration_qng([xmin, xmax], [0.0, 1.0e-7]) p f.integration_qng([xmin, xmax], 0.0, 1.0e-7) p f.integration_qng(xmin, xmax, [0.0, 1.0e-7]) puts("QAG") p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], GSL::Integration::GAUSS15) w = GSL::Integration::Workspace.alloc(2000) p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) puts("QAGS") p f.integration_qags(xmin, xmax) p f.integration_qags([xmin, xmax]) p f.integration_qags(xmin, xmax, 0.0, 1e-7) p f.integration_qags(xmin, xmax, [0.0, 1e-7]) p f.integration_qags([xmin, xmax], [0.0, 1e-7]) p f.integration_qags([xmin, xmax], 0.0, 1e-7) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qags([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qags(xmin, xmax, [0.0, 1e-7], limit) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], limit) p f.integration_qags(xmin, xmax, limit) p f.integration_qags([xmin, xmax], w) p f.integration_qags(xmin, xmax, w) p f.integration_qags(xmin, xmax, limit, w) p f.integration_qags([xmin, xmax], limit, w) puts("QAGP") p f.integration_qagp([xmin, xmax]) p f.integration_qagp([xmin, xmax], [0.0, 1e-7]) p f.integration_qagp([xmin, xmax], 0.0, 1e-7) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], w) p f.integration_qagp([xmin, xmax], limit) p f.integration_qagp([xmin, xmax], w) p f.integration_qagp([xmin, xmax], limit, w) __END__ gsl-1.15.3/tests/integration/integration1.rb0000755000175000017500000000522512220252463020367 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math f = GSL::Function::alloc{ |x| exp(x)*cos(x) } xmin = 0.0 xmax = 1.0 limit = 1000 puts("QNG") p f.integration_qng(xmin, xmax, 0.0, 1.0e-7) p f.integration_qng(xmin, xmax) p f.integration_qng([xmin, xmax]) p f.integration_qng([xmin, xmax], [0.0, 1.0e-7]) p f.integration_qng([xmin, xmax], 0.0, 1.0e-7) p f.integration_qng(xmin, xmax, [0.0, 1.0e-7]) puts("QAG") p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], GSL::Integration::GAUSS15) w = GSL::Integration::Workspace.alloc p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], w) puts("QAGS") p f.integration_qags(xmin, xmax) p f.integration_qags([xmin, xmax]) p f.integration_qags(xmin, xmax, 0.0, 1e-7) p f.integration_qags(xmin, xmax, [0.0, 1e-7]) p f.integration_qags([xmin, xmax], [0.0, 1e-7]) p f.integration_qags([xmin, xmax], 0.0, 1e-7) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qags([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qags(xmin, xmax, [0.0, 1e-7], limit) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], limit) p f.integration_qags(xmin, xmax, limit) p f.integration_qags([xmin, xmax], w) p f.integration_qags(xmin, xmax, w) p f.integration_qags(xmin, xmax, limit, w) p f.integration_qags([xmin, xmax], limit, w) puts("QAGP") p f.integration_qagp([xmin, xmax]) p f.integration_qagp([xmin, xmax], [0.0, 1e-7]) p f.integration_qagp([xmin, xmax], 0.0, 1e-7) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], w) p f.integration_qagp([xmin, xmax], limit) p f.integration_qagp([xmin, xmax], w) p f.integration_qagp([xmin, xmax], limit, w) __END__ gsl-1.15.3/tests/integration/integration3.rb0000755000175000017500000000517312220252463020373 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math f = GSL::Function::alloc{ |x| exp(-x)/sqrt(x) } xmin = 0.0 xmax = 1.0 limit = 1000 =begin puts("QNG") p f.integration_qng(xmin, xmax, 0.0, 1.0e-7) p f.integration_qng(xmin, xmax) p f.integration_qng([xmin, xmax]) p f.integration_qng([xmin, xmax], [0.0, 1.0e-7]) p f.integration_qng([xmin, xmax], 0.0, 1.0e-7) p f.integration_qng(xmin, xmax, [0.0, 1.0e-7]) =end puts("QAG") p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], GSL::Integration::GAUSS15) w = GSL::Integration::Workspace.alloc(2000) p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) puts("QAGS") p f.integration_qags(xmin, xmax) p f.integration_qags([xmin, xmax]) p f.integration_qags(xmin, xmax, 0.0, 1e-7) p f.integration_qags(xmin, xmax, [0.0, 1e-7]) p f.integration_qags([xmin, xmax], [0.0, 1e-7]) p f.integration_qags([xmin, xmax], 0.0, 1e-7) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qags([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qags(xmin, xmax, [0.0, 1e-7], limit) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], limit) p f.integration_qags(xmin, xmax, limit) p f.integration_qags([xmin, xmax], w) p f.integration_qags(xmin, xmax, w) p f.integration_qags(xmin, xmax, limit, w) p f.integration_qags([xmin, xmax], limit, w) puts("QAGP") p f.integration_qagp([xmin, xmax]) p f.integration_qagp([xmin, xmax], [0.0, 1e-7]) p f.integration_qagp([xmin, xmax], 0.0, 1e-7) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], w) p f.integration_qagp([xmin, xmax], limit) p f.integration_qagp([xmin, xmax], w) p f.integration_qagp([xmin, xmax], limit, w) gsl-1.15.3/tests/integration/integration4.rb0000755000175000017500000000520312220252463020366 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include Math f = GSL::Function::alloc{ |x| (1.0 - exp(-x))/sqrt(x) } xmin = 0.0 xmax = 0.2 limit = 1000 =begin puts("QNG") p f.integration_qng(xmin, xmax, 0.0, 1.0e-7) p f.integration_qng(xmin, xmax) p f.integration_qng([xmin, xmax]) p f.integration_qng([xmin, xmax], [0.0, 1.0e-7]) p f.integration_qng([xmin, xmax], 0.0, 1.0e-7) p f.integration_qng(xmin, xmax, [0.0, 1.0e-7]) =end puts("QAG") p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, limit, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15) p f.integration_qag(xmin, xmax, GSL::Integration::GAUSS15) p f.integration_qag([xmin, xmax], GSL::Integration::GAUSS15) w = GSL::Integration::Workspace.alloc(2000) p f.integration_qag(xmin, xmax, [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) p f.integration_qag(xmin, xmax, 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], 0.0, 1.0e-7, GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], GSL::Integration::GAUSS15, w) p f.integration_qag([xmin, xmax], [0.0, 1.0e-7], limit, GSL::Integration::GAUSS15, w) puts("QAGS") p f.integration_qags(xmin, xmax) p f.integration_qags([xmin, xmax]) p f.integration_qags(xmin, xmax, 0.0, 1e-7) p f.integration_qags(xmin, xmax, [0.0, 1e-7]) p f.integration_qags([xmin, xmax], [0.0, 1e-7]) p f.integration_qags([xmin, xmax], 0.0, 1e-7) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qags([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qags(xmin, xmax, [0.0, 1e-7], limit) p f.integration_qags([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, 0.0, 1e-7, limit, w) p f.integration_qags(xmin, xmax, [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], [0.0, 1e-7], w) p f.integration_qags([xmin, xmax], limit) p f.integration_qags(xmin, xmax, limit) p f.integration_qags([xmin, xmax], w) p f.integration_qags(xmin, xmax, w) p f.integration_qags(xmin, xmax, limit, w) p f.integration_qags([xmin, xmax], limit, w) puts("QAGP") p f.integration_qagp([xmin, xmax]) p f.integration_qagp([xmin, xmax], [0.0, 1e-7]) p f.integration_qagp([xmin, xmax], 0.0, 1e-7) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], limit) p f.integration_qagp([xmin, xmax], 0.0, 1e-7, limit, w) p f.integration_qagp([xmin, xmax], [0.0, 1e-7], w) p f.integration_qagp([xmin, xmax], limit) p f.integration_qagp([xmin, xmax], w) p f.integration_qagp([xmin, xmax], limit, w) gsl-1.15.3/tests/sys.rb0000755000175000017500000002221612220252463014255 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "sum/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test GSL::IEEE::env_setup() y = GSL::expm1(0.0); y_expected = 0.0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::expm1(0.0)"); y = GSL::expm1(1e-10); y_expected = 1.000000000050000000002e-10; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::expm1(1e-10)"); y = GSL::expm1(-1e-10); y_expected = -9.999999999500000000017e-11; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::expm1(-1e-10)"); y = GSL::expm1(0.1); y_expected = 0.1051709180756476248117078264902; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::expm1(0.1)"); y = GSL::expm1(-0.1); y_expected = -0.09516258196404042683575094055356; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::expm1(-0.1)"); y = GSL::expm1(10.0); y_expected = 22025.465794806716516957900645284; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::expm1(10.0)"); y = GSL::expm1(-10.0); y_expected = -0.99995460007023751514846440848444; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::expm1(-10.0)"); # Test for log1p y = GSL::log1p(0.0); y_expected = 0.0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::log1p(0.0)"); y = GSL::log1p(1e-10); y_expected = 9.9999999995000000000333333333308e-11; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::log1p(1e-10)"); y = GSL::log1p(0.1); y_expected = 0.095310179804324860043952123280765; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::log1p(0.1)"); y = GSL::log1p(10.0); y_expected = 2.3978952727983705440619435779651; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::log1p(10.0)"); # Test for GSL::hypot y = GSL::hypot(0.0, 0.0); y_expected = 0.0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(0.0, 0.0)"); y = GSL::hypot(1e-10, 1e-10); y_expected = 1.414213562373095048801688e-10; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(1e-10, 1e-10)"); y = GSL::hypot(1e-38, 1e-38); y_expected = 1.414213562373095048801688e-38; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(1e-38, 1e-38)"); y = GSL::hypot(1e-10, -1.0); y_expected = 1.000000000000000000005; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(1e-10, -1)"); y = GSL::hypot(-1.0, 1e-10); y_expected = 1.000000000000000000005; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(-1, 1e-10)"); #y = GSL::hypot(1e307, 1e301); #y_expected = 1.000000000000499999999999e307; #GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(1e307, 1e301)"); #y = GSL::hypot(1e301, 1e307); #y_expected = 1.000000000000499999999999e307; #GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(1e301, 1e307)"); #y = GSL::hypot(1e307, 1e307); #y_expected = 1.414213562373095048801688e307; #GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::hypot(1e307, 1e307)"); y = GSL::acosh(1.0); y_expected = 0.0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::acosh(1.0)"); y = GSL::acosh(1.1); y_expected = 4.435682543851151891329110663525e-1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::acosh(1.1)"); y = GSL::acosh(10.0); y_expected = 2.9932228461263808979126677137742e0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::acosh(10.0)"); y = GSL::acosh(1e10); y_expected = 2.3718998110500402149594646668302e1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::acosh(1e10)"); # Test for asinh y = GSL::asinh(0.0); y_expected = 0.0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(0.0)"); y = GSL::asinh(1e-10); y_expected = 9.9999999999999999999833333333346e-11; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(1e-10)"); y = GSL::asinh(-1e-10); y_expected = -9.9999999999999999999833333333346e-11; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(1e-10)"); y = GSL::asinh(0.1); y_expected = 9.983407889920756332730312470477e-2; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(0.1)"); y = GSL::asinh(-0.1); y_expected = -9.983407889920756332730312470477e-2; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(-0.1)"); y = GSL::asinh(1.0); y_expected = 8.8137358701954302523260932497979e-1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(1.0)"); y = GSL::asinh(-1.0); y_expected = -8.8137358701954302523260932497979e-1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(-1.0)"); y = GSL::asinh(10.0); y_expected = 2.9982229502979697388465955375965e0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(10)"); y = GSL::asinh(-10.0); y_expected = -2.9982229502979697388465955375965e0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(-10)"); y = GSL::asinh(1e10); y_expected = 2.3718998110500402149599646668302e1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(1e10)"); y = GSL::asinh(-1e10); y_expected = -2.3718998110500402149599646668302e1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::asinh(-1e10)"); y = GSL::atanh(0.0); y_expected = 0.0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::atanh(0.0)"); y = GSL::atanh(1e-20); y_expected = 1e-20; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::atanh(1e-20)"); y = GSL::atanh(-1e-20); y_expected = -1e-20; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::atanh(-1e-20)"); y = GSL::atanh(0.1); y_expected = 1.0033534773107558063572655206004e-1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::atanh(0.1)"); y = GSL::atanh(-0.1); y_expected = -1.0033534773107558063572655206004e-1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::atanh(-0.1)"); y = GSL::atanh(0.9); y_expected = 1.4722194895832202300045137159439e0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::atanh(0.9)"); y = GSL::atanh(-0.9); y_expected = -1.4722194895832202300045137159439e0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::atanh(0.9)"); # Test for pow_int y = GSL::pow_2(-3.14); y_expected = pow(-3.14, 2.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_2(-3.14)"); y = GSL::pow_3(-3.14); y_expected = pow(-3.14, 3.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_3(-3.14)"); y = GSL::pow_4(-3.14); y_expected = pow(-3.14, 4.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_4(-3.14)"); y = GSL::pow_5(-3.14); y_expected = pow(-3.14, 5.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_5(-3.14)"); y = GSL::pow_6(-3.14); y_expected = pow(-3.14, 6.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_6(-3.14)"); y = GSL::pow_7(-3.14); y_expected = pow(-3.14, 7.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_7(-3.14)"); y = GSL::pow_8(-3.14); y_expected = pow(-3.14, 8.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_8(-3.14)"); y = GSL::pow_9(-3.14); y_expected = pow(-3.14, 9.0); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_9(-3.14)"); for n in -9...10 y = GSL::pow_int(-3.14, n); y_expected = pow(-3.14, n); GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::pow_n(-3.14,#{n})") end # Test for ldexp y = GSL::ldexp(M_PI, -2); y_expected = M_PI_4; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::ldexp(pi,-2)"); y = GSL::ldexp(1.0, 2); y_expected = 4.000000; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::ldexp(1.0,2)"); y = GSL::ldexp(0.0, 2); y_expected = 0.0; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::ldexp(0.0,2)"); # Test for frexp y, e = GSL::frexp(M_PI); y_expected = M_PI_4; e_expected = 2; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::frexp(pi) fraction"); GSL::Test::test_int(e, e_expected, "GSL::frexp(pi) exponent"); y, e = GSL::frexp(2.0); y_expected = 0.5; e_expected = 2; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::frexp(2.0) fraction"); GSL::Test::test_int(e, e_expected, "GSL::frexp(2.0) exponent"); y, e = GSL::frexp(1.0 / 4.0); y_expected = 0.5; e_expected = -1; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::frexp(0.25) fraction"); GSL::Test::test_int(e, e_expected, "GSL::frexp(0.25) exponent"); y, e = GSL::frexp(1.0 / 4.0 - 4.0 * GSL::DBL_EPSILON); y_expected = 0.999999999999996447; e_expected = -2; GSL::Test::test_rel(y, y_expected, 1e-15, "GSL::frexp(0.25-eps) fraction"); GSL::Test::test_int(e, e_expected, "GSL::frexp(0.25-eps) exponent"); x = M_PI; y = 22.0 / 7.0; # test the basic function for i in 0...10 tol = pow(10, -i); res = GSL::fcmp(x, y, tol); GSL::Test::test_int(res, -((i >= 4) ? 1 : 0), "GSL::fcmp(#{x},#{y},#{tol})") end for i in 0...10 tol = pow(10, -i); res = GSL::fcmp(y, x, tol); GSL::Test::test_int(res,(i >= 4) ? 1 : 0, "GSL::fcmp(#{y},#{x},#{tol})") end zero = 0.0; one = 1.0; inf = Math::exp(1.0e10) nan = inf / inf; s = GSL::isinf(zero); GSL::Test::test_int(s, 0, "GSL::isinf(0)"); s = GSL::isinf(one); GSL::Test::test_int(s, 0, "GSL::isinf(1)"); s = GSL::isinf(inf); GSL::Test::test_int(s, 1, "GSL::isinf(inf)"); # Commented out 2008/Oct/17 by YT # This test fails in (Darwin 9.5.0, gcc4.0.1): # gsl_isinf() returns 1 for -inf #s = GSL::isinf(-inf); #GSL::Test::test_int(s, -1, "GSL::isinf(-inf)"); s = GSL::isinf(nan); GSL::Test::test_int(s, 0, "GSL::isinf(nan)"); s = GSL::isnan(zero); GSL::Test::test_int(s, 0, "GSL::isnan(0)"); s = GSL::isnan(one); GSL::Test::test_int(s, 0, "GSL::isnan(1)"); s = GSL::isnan(inf); GSL::Test::test_int(s, 0, "GSL::isnan(inf)"); s = GSL::isnan(nan); GSL::Test::test_int(s, 1, "GSL::isnan(nan)"); s = GSL::finite(zero); GSL::Test::test_int(s, 1, "GSL::finite(0)"); s = GSL::finite(one); GSL::Test::test_int(s, 1, "GSL::finite(1)"); s = GSL::finite(inf); GSL::Test::test_int(s, 0, "GSL::finite(inf)"); s = GSL::finite(nan); GSL::Test::test_int(s, 0, "GSL::finite(nan)"); gsl-1.15.3/tests/cheb.rb0000755000175000017500000000552112220252463014340 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "cheb/test.c" require("gsl") require("./gsl_test.rb") include GSL::Test include Math f_T0 = GSL::Function.alloc { |x| 1.0 } f_T1 = GSL::Function.alloc { |x| x } f_T2 = GSL::Function.alloc { |x| 2.0*x*x - 1.0 } f_sin = GSL::Function.alloc { |x| sin(x) } tol = 100.0*GSL::DBL_EPSILON order = 40 cs = GSL::Cheb.alloc(order) csd = GSL::Cheb.alloc(order) csi = GSL::Cheb.alloc(order) GSL::ieee_env_setup() cs.init(f_T0, -1.0, 1.0) for i in 0...order do c_exp = i == 0 ? 2.0 : 0.0 desc = sprintf("c[%d] for T_0(x)", i) GSL::Test.test_abs(cs.c[i], c_exp, tol, desc) end cs.init(f_T1, -1.0, 1.0) for i in 0...order do c_exp = i == 1 ? 1.0 : 0.0 desc = sprintf("c[%d] for T_1(x)", i) GSL::Test.test_abs(cs.c[i], c_exp, tol, desc) end cs.init(f_T2, -1.0, 1.0) for i in 0...order do c_exp = i == 2 ? 1.0 : 0.0 desc = sprintf("c[%d] for T_2(x)", i) GSL::Test.test_abs(cs.c[i], c_exp, tol, desc) end cs.init(f_sin, -M_PI, M_PI) GSL::Test.test_abs(cs.c[0], 0.0, tol, "c[0] for F_sin(x)") GSL::Test.test_abs(cs.c[1], 5.69230686359506e-01, tol, "c[1] for F_sin(x)") GSL::Test.test_abs(cs.c[2], 0.0, tol, "c[2] for F_sin(x)") GSL::Test.test_abs(cs.c[3], -6.66916672405979e-01, tol, "c[3] for F_sin(x)") GSL::Test.test_abs(cs.c[4], 0.0, tol, "c[4] for F_sin(x)") GSL::Test.test_abs(cs.c[5], 1.04282368734237e-01, tol, "c[5] for F_sin(x)") x = -M_PI while x < M_PI r = cs.eval(x) desc = sprintf("GSL::Cheb#eval, sin\(%.3g\)", x) GSL::Test.test_abs(r, sin(x), tol, desc) x += M_PI/100.0 end x = -M_PI while x < M_PI r, e = cs.eval_err(x) desc = sprintf("GSL::Cheb#eval_err, sin\(%.3g\)", x) GSL::Test.test_abs(r, sin(x), tol, desc) desc = sprintf("GSL::Cheb#eval_err, error sin\(%.3g\)", x) GSL::Test.test_factor((r-sin(x)).abs + GSL::DBL_EPSILON, e, 10.0, desc) x += M_PI/100.0 end x = -M_PI while x < M_PI r = cs.eval_n(25, x) desc = sprintf("GSL::Cheb#eval_n, sin\(%.3g\)", x) GSL::Test.test_abs(r, sin(x), tol, desc) x += M_PI/100.0 end x = -M_PI while x < M_PI r, e = cs.eval_n_err(25, x) desc = sprintf("GSL::Cheb#eval_n_err, sin\(%.3g\)", x) GSL::Test.test_abs(r, sin(x), tol, desc) desc = sprintf("GSL::Cheb#eval_n_err, error sin\(%.3g\)", x) GSL::Test.test_factor((r-sin(x)).abs + GSL::DBL_EPSILON, e, 10.0, desc) x += M_PI/100.0 end csd = cs.calc_deriv #cs.calc_deriv(csd) #csd = GSL::Cheb.calc_deriv(cs) #GSL::Cheb.calc_deriv(csd, cs) x = -M_PI while x < M_PI r = csd.eval(x) desc = sprintf("GSL::Cheb#eval, deriv sin\(%.3g\)", x) GSL::Test.test_abs(r, cos(x), 1600*tol, desc) x += M_PI/100.0 end csi = cs.calc_integ #cs.calc_integ(csi) #csi = GSL::Cheb.calc_integ(cs) #GSL::Cheb.calc_integ(csi, cs) x = -M_PI while x < M_PI r = csi.eval(x) desc = sprintf("GSL::Cheb#eval, integ sin\(%.3g\)", x) GSL::Test.test_abs(r, -(1+cos(x)), tol, desc) x += M_PI/100.0 end gsl-1.15.3/tests/eigen/0000755000175000017500000000000012220252463014173 5ustar boutilboutilgsl-1.15.3/tests/eigen/eigen.rb0000755000175000017500000001304512220252463015615 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "eigen/test.c" require("gsl") require("../gsl_test.rb") include GSL::Test def create_random_symm_matrix(size1, size2, rng, lower, upper) m = GSL::Matrix.alloc(size1, size2) for i in 0...size1 do for j in i...size2 do x = rng.uniform()*(upper-lower) + lower m[i,j] = x m[j,i] = x end end m end def create_random_herm_matrix(size1, size2, rng, lower, upper) m = GSL::Matrix::Complex.alloc(size1, size2) for i in 0...size1 do for j in i...size2 do re = rng.uniform()* (upper - lower) + lower if i == j im = 0.0 else im = rng.uniform()* (upper - lower) + lower end z = GSL::Complex.alloc(re, im) m[i,j] = z m[j,i] = z.conjugate end end m end def create_random_posdef_matrix(size1, size2, rng) m = GSL::Matrix.alloc(size1, size2) x = rng.uniform() for i in 0...size1 do for j in i...size2 do a = pow(x, (j - i).to_f) m[i,j] = a m[j,i] = a end end m end def create_random_complex_posdef_matrix(size1, size2, rng) m = GSL::Matrix::Complex.calloc(size1, size2) n = size1 for i in 0...n do x = rng.uniform() z = GSL::Complex.alloc(x, 0.0) m[i,i] = z end work = GSL::Vector::Complex.alloc(n) for i in 0...n do for j in 0...n do x = 2.0*rng.uniform() - 1.0 y = 2.0*rng.uniform() - 1.0 z = GSL::Complex.alloc(x, y) work[j] end tau = GSL::Linalg::Complex::householder_transform(work) GSL::Linalg::Complex::householder_hm(tau, work, m) GSL::Linalg::Complex::householder_mh(tau.conjugate, work, m) end m end def create_random_nonsymm_matrix(size1, size2, rng, lower, upper) m = GSL::Matrix.alloc(size1, size2) for i in 0...size1 do for j in 0...size2 do m[i,j] = rng.uniform()*(upper - lower) + lower end end m end def test_eigen_results(n, m, eval, evec, desc, desc2) x = GSL::Vector.alloc(n) y = GSL::Vector.alloc(n) # check eigenvalues for i in 0...n ei = eval[i] vi = evec.col(i) GSL::Vector.memcpy(x, vi) y = GSL::Blas.dgemv(GSL::Blas::NoTrans, 1.0, m, x, 0.0, y) # y = GSL::Blas.dgemv(GSL::Blas::NoTrans, 1.0, m, x) for j in 0...n xj = x[j] yj = y[j] desc3 = sprintf("%s, eigenvalue(%d,%d), %s", desc, i, j, desc2) GSL::Test::test_rel(yj, ei*xj, 1e8*DBL_EPSILON, desc3) end end # check eigenvectors are orthonormal for i in 0...n vi = evec.col(i) nrm_v = GSL::Blas.dnrm2(vi) desc3 = sprintf("%s, normalized(%d), %s", desc, i, desc2) GSL::Test::test_rel(nrm_v, 1.0, n*DBL_EPSILON, desc3) end for i in 0...n vi = evec.col(i) for j in (i+1)...n vj = evec.col(j) vivj = GSL::Blas.ddot(vi, vj) desc3 = sprintf("%s, orthogonal(%d,%d), %s", desc, i, j, desc2) GSL::Test::test_abs(vivj, 0.0, n*DBL_EPSILON, desc3) end end end def test_eigen_complex_results(n, m, eval, evec, desc, desc2) x = GSL::Vector::Complex.alloc(n) y = GSL::Vector::Complex.alloc(n) # check eigenvalues for i in 0...n ei = eval[i] vi = evec.col(i) GSL::Vector::Complex.memcpy(x, vi) c1 = GSL::Complex.alloc(1.0, 0.0) c0 = GSL::Complex.alloc(0.0, 0.0) y = GSL::Blas.zgemv(GSL::Blas::NoTrans, c1, m, x, c0, y) for j in 0...n xj = x[j] yj = y[j] desc3 = sprintf("%s, eigenvalue(%d,%d), real, %s", desc, i, j, desc2) GSL::Test::test_rel(yj.re, ei*xj.re, 1e8*DBL_EPSILON, desc3) desc3 = sprintf("%s, eigenvalue(%d,%d), imag, %s", desc, i, j, desc2) GSL::Test::test_rel(yj.im, ei*xj.im, 1e8*DBL_EPSILON, desc3) end end # check eigenvectors are orthonormal for i in 0...n vi = evec.col(i) nrm_v = GSL::Blas.dznrm2(vi) desc3 = sprintf("%s, normalized(%d), %s", desc, i, desc2) GSL::Test::test_rel(nrm_v, 1.0, n*DBL_EPSILON, desc3) end for i in 0...n vi = evec.col(i) for j in (i+1)...n vj = evec.col(j) vivj = GSL::Blas.zdotc(vi, vj) desc3 = sprintf("%s, orthogonal(%d,%d), %s", desc, i, j, desc2) GSL::Test::test_abs(vivj.abs, 0.0, n*DBL_EPSILON, desc3) end end end def test_eigenvalues(n, eval, eval2, desc, desc2) for i in 0...n ei = eval[i] e2i = eval2[i] desc3 = sprintf("%s, direct eigenvalue(%d), %s", desc, i, desc2) GSL::Test::test_rel(ei, e2i, GSL::DBL_EPSILON, desc3) end end def chop_subnormals(x) # Chop any subnormal values */ return x.abs < GSL::DBL_MIN ? 0 : x end def test_eigenvalues_real(eval, eval2, desc, desc2) n = eval.size emax = 0 # check eigenvalues for i in 0...n do ei = eval[i] if ei.abs > emax emax = ei.abs end end for i in 0...n do ei = eval[i] e2i = chop_subnormals(eval2[i]) GSL::Test::test_abs(ei, e2i, emax * 1e8 * GSL::DBL_EPSILON, "#{desc}, direct eigenvalue(#{i}), #{desc2}") end end def test_eigenvalues_complex(eval, eval2, desc, desc2) n = eval.size for i in 0...n do ei = eval[i] e2i = eval2[i] GSL::Test::test_rel(ei.real, e2i.real, 10*n*GSL::DBL_EPSILON, "#{desc}, direct eigenvalue(#{i}) real, #{desc2}") GSL::Test::test_rel(ei.imag, e2i.imag, 10*n*GSL::DBL_EPSILON, "#{desc}, direct eigenvalue(#{i}) imag, #{desc2}") end end def test_eigen_schur(a, s, q, z, count, desc, desc2) n = a.size1 t1 = a*z t2 = q*s for i in 0...n do for j in 0...n do x = t1[i,j] y = t2[i,j] GSL::test_abs(x, y, 1.0e8 * GSL::DBL_EPSILON, "#{desc}(N=#{n},cnt=#{count}), #{desc2}, schur(#{i},#{j})") end end end gsl-1.15.3/tests/eigen/gen.rb0000755000175000017500000000610312220252463015274 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") require("eigen.rb") include GSL::Test def test_eigen_gen_results(a, b, alpha, beta, evec, count, desc, desc2) n = a.size1 ma = a.to_complex mb = b.to_complex for i in 0...n do vi = evec.column(i) ai = alpha[i] bi = beta[i] x = mb*vi x *= ai y = ma*vi y *= bi for j in 0...n do GSL::Test::test_abs(y[j].real, x[j].real, 1e8*GSL::DBL_EPSILON, "gen(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), real, #{desc2}") GSL::Test::test_abs(y[j].imag, x[j].imag, 1e8*GSL::DBL_EPSILON, "gen(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), imag, #{desc2}") end end end def test_eigen_gen_pencil(a, b, count, desc, test_schur, w, wv) n = a.size1 aa = a.clone bb = b.clone if test_schur == 1 alphav, betav, evec, q, z = GSL::Eigen::genv_QZ(aa, bb, wv) test_eigen_schur(a, aa, q, z, count, "genv/A", desc) test_eigen_schur(b, bb, q, z, count, "genv/B", desc) else alphav, betav, evec = GSL::Eigen::genv(aa, bb, wv) end test_eigen_gen_results(a, b, alphav, betav, evec, count, desc, "unsorted") aa = a.clone bb = b.clone if test_schur == 1 GSL::Eigen::gen_params(1, 1, 0, w) alpha, beta, q, z = GSL::Eigen::gen_QZ(aa, bb, w) test_eigen_schur(a, aa, q, z, count, "gen/A", desc) test_eigen_schur(b, bb, q, z, count, "gen/B", desc) else GSL::Eigen::gen_params(0, 0, 0, w) alpha, beta = GSL::Eigen::gen(aa, bb, w) end eval = GSL::Vector::Complex.alloc(n) evalv = GSL::Vector::Complex.alloc(n) for i in 0...n do ai = alpha[i] bi = beta[i] z = GSL::Complex.alloc(ai.real/bi, ai.imag/bi) eval[i] = z ai = alphav[i] bi = betav[i] z = GSL::Complex.alloc(ai.real/bi, ai.imag/bi) evalv[i] = z end GSL::Eigen::nonsymmv_sort(eval, nil, GSL::EIGEN_SORT_ABS_ASC) GSL::Eigen::nonsymmv_sort(evalv, nil, GSL::EIGEN_SORT_ABS_ASC) test_eigenvalues_complex(evalv, eval, "gen", desc) GSL::Eigen::genv_sort(alphav, betav, evec, GSL::EIGEN_SORT_ABS_ASC) test_eigen_gen_results(a, b, alphav, betav, evec, count, desc, "abs/asc") GSL::Eigen::genv_sort(alphav, betav, evec, GSL::EIGEN_SORT_ABS_DESC) test_eigen_gen_results(a, b, alphav, betav, evec, count, desc, "abs/desc") end def test_eigen_gen() n_max = 20 rng = GSL::Rng.alloc() for n in 1..n_max do w = GSL::Eigen::Gen.alloc(n) wv = GSL::Eigen::Genv.alloc(n) for i in 0...5 do a = create_random_nonsymm_matrix(n, n, rng, -10, 10) b = create_random_nonsymm_matrix(n, n, rng, -10, 10) test_eigen_gen_pencil(a, b, i, "random", 0, w, wv); test_eigen_gen_pencil(a, b, i, "random", 1, w, wv); end end ma = GSL::Matrix.alloc([1, 1, 0, 0, 0, -1, 1, 0, 0], 3, 3) mb = GSL::Matrix.alloc([-1, 0, -1, 0, -1, 0, 0, 0, -1], 3, 3) w = GSL::Eigen::Gen.alloc(3) wv = GSL::Eigen::Genv.alloc(3) test_eigen_gen_pencil(ma, mb, 0, "integer", 0, w, wv); test_eigen_gen_pencil(ma, mb, 0, "integer", 1, w, wv); end test_eigen_gen() gsl-1.15.3/tests/eigen/genherm.rb0000755000175000017500000000410412220252463016147 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") require("eigen.rb") include GSL::Test def test_eigen_genherm_results(a, b, eval, evec, count, desc, desc2) n = a.size1 # check A v = lambda B v for i in 0...n do ei = eval[i] vi = evec.column(i) norm = vi.nrm2 # check that eigenvector is normalized GSL::Test::test_rel(norm, 1.0, n * GSL::DBL_EPSILON, "genherm(N=#{n},cnt=#{count}), #{desc}, normalized(#{i}), #{desc2}") y = a*vi x = b*vi x *= ei for j in 0...n do GSL::Test::test_rel(y[j].real, x[j].real, 1e9 * GSL::DBL_EPSILON, "genherm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), real, #{desc2}") GSL::Test::test_rel(y[j].imag, x[j].imag, 1e9 * GSL::DBL_EPSILON, "genherm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), imag, #{desc2}") end end end def test_eigen_genherm() n_max = 20 rng = GSL::Rng.alloc() for n in 1..n_max do w = GSL::Eigen::Genherm.alloc(n) wv = GSL::Eigen::Genhermv.alloc(n) for i in 0...5 do a = create_random_herm_matrix(n, n, rng, -10, 10) b = create_random_complex_posdef_matrix(n, n, rng) evalv, evec = GSL::Eigen::genhermv(a, b, wv) test_eigen_genherm_results(a, b, evalv, evec, i, "random", "unsorted") eval = GSL::Eigen::genherm(a, b, w) x = eval.sort y = evalv.sort test_eigenvalues_real(y, x, "genherm, random", "unsorted") GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_VAL_ASC); test_eigen_genherm_results(a, b, evalv, evec, i, "random", "val/asc"); GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_VAL_DESC); test_eigen_genherm_results(a, b, evalv, evec, i, "random", "val/desc"); GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_ABS_ASC); test_eigen_genherm_results(a, b, evalv, evec, i, "random", "abs/asc"); GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_ABS_DESC); test_eigen_genherm_results(a, b, evalv, evec, i, "random", "abs/desc"); end end end test_eigen_genherm() gsl-1.15.3/tests/eigen/nonsymm.rb0000755000175000017500000000355012220252463016226 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") include GSL::Test m = GSL::Matrix[[1, 2], [3, 2]] p m eval = m.eigen_nonsymm.real.sort GSL::Test::test_abs(eval[0], -1, 0, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[1], 4, 0, "GSL::Matrix::eigen_nonsymm") m = GSL::Matrix[[1, 4, 2, 3], 2, 2] p m eval = m.eigen_nonsymm.real.sort GSL::Test::test_abs(eval[0], -1, 0, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[1], 5, 0, "GSL::Matrix::eigen_nonsymm") m = GSL::Matrix[[2, 4], [3, 1]] p m eval = m.eigen_nonsymm.real.sort GSL::Test::test_abs(eval[0], -2, 0, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[1], 5, 0, "GSL::Matrix::eigen_nonsymm") m = GSL::Matrix[[5, 6, 3, 2], 2, 2] p m eval = m.eigen_nonsymm.real.sort GSL::Test::test_abs(eval[0], -1, 0, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[1], 8, 0, "GSL::Matrix::eigen_nonsymm") m = GSL::Matrix[[4, 1, -1, 2, 5, -2, 1, 1, 2], 3, 3] p m eval = m.eigen_nonsymm.real.sort GSL::Test::test_abs(eval[0], 3, 1e-10, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[1], 3, 0, "GSL::Matrix::eigen_nonsymm") # 2008/Oct/17 YT # This test fails in Darwin9.5.0-gcc4.0.1 # expected: 5 # obtained: 4.99999999999999911 GSL::Test::test_abs(eval[2], 5, 0, "GSL::Matrix::eigen_nonsymm") m = GSL::Matrix[[-3, 1, -1], [-7, 5, -1], [-6, 6, -2]] p m eval = m.eigen_nonsymm.real.sort GSL::Test::test_abs(eval[0], -2, 1e-6, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[1], -2, 1e-6, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[2], 4, 1e-10, "GSL::Matrix::eigen_nonsymm") m = GSL::Matrix[[11, -8, 4, -8, -1, -2, 4, -2, -4], 3, 3] p m eval = m.eigen_nonsymm.real.sort GSL::Test::test_abs(eval[0], -5, 1e-10, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[1], -5, 1e-10, "GSL::Matrix::eigen_nonsymm") GSL::Test::test_abs(eval[2], 16, 1e-10, "GSL::Matrix::eigen_nonsymm") gsl-1.15.3/tests/eigen/nonsymmv.rb0000755000175000017500000000334312220252463016414 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") include GSL::Test def test_nonsymmv2(m, eps) p m m2 = m.clone eval, evec = m2.eigen_nonsymmv evalre = eval.real evecre = evec.real a = evecre.inv*m*evecre GSL::Test::test_abs(a[0,0], evalre[0], eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[1,1], evalre[1], eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[0,1], 0, eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[1,0], 0, eps, "GSL::Matrix::eigen_nonsymmv") end def test_nonsymmv3(m, eps) p m m2 = m.clone eval, evec = m2.eigen_nonsymmv evalre = eval.real evecre = evec.real a = evecre.inv*m*evecre GSL::Test::test_abs(a[0,0], evalre[0], eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[1,1], evalre[1], eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[2,2], evalre[2], eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[0,1], 0, eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[0,2], 0, eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[1,0], 0, eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[1,2], 0, eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[2,0], 0, eps, "GSL::Matrix::eigen_nonsymmv") GSL::Test::test_abs(a[2,1], 0, eps, "GSL::Matrix::eigen_nonsymmv") end m = GSL::Matrix[[1, 2], [3, 2]] test_nonsymmv2(m, 1e-10) m = GSL::Matrix[[4, 2, 3, -1], 2, 2] test_nonsymmv2(m, 1e-10) m = GSL::Matrix[[2, 2, -5], [3, 7, -15], [1, 2, -4]] test_nonsymmv3(m, 1e-10) m = GSL::Matrix[[4, 1, -1], [2, 5, -2], [1, 1, 2]] test_nonsymmv3(m, 1e-10) m = GSL::Matrix[[-3, 1, -1], [-7, 5, -1], [-6, 6, -2]] test_nonsymmv3(m, 1e-6) m = GSL::Matrix[[11, -8, 4], [-8, -1, -2], [4, -2, -4]] test_nonsymmv3(m, 1e-10) gsl-1.15.3/tests/eigen/symm-herm.rb0000755000175000017500000000435212220252463016445 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "eigen/test.c" require("gsl") require("../gsl_test.rb") require("eigen.rb") include GSL::Test def test_eigen_symm(desc, m) n = m.size1 a = GSL::Matrix.alloc(n, n) w1 = GSL::Eigen::Symm::Workspace.alloc(n) w2 = GSL::Eigen::Symmv::Workspace.alloc(n) GSL::Matrix.memcpy(a, m) eval, evec = a.eigen_symmv(w2) test_eigen_results(n, m, eval, evec, desc, "unsorted") GSL::Matrix.memcpy(a, m) eval2 = a.eigen_symm(w1) test_eigenvalues(n, eval, eval2, desc, "unsorted") GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_VAL_ASC) test_eigen_results(n, m, eval, evec, desc, "val/asc") GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_VAL_DESC) test_eigen_results(n, m, eval, evec, desc, "val/desc") GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_ABS_ASC) test_eigen_results(n, m, eval, evec, desc, "abs/asc") GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_ABS_DESC) test_eigen_results(n, m, eval, evec, desc, "abs/desc") end def test_eigen_herm(desc, m) n = m.size1 a = GSL::Matrix::Complex.alloc(n, n) w1 = GSL::Eigen::Herm::Workspace.alloc(n) w2 = GSL::Eigen::Hermv::Workspace.alloc(n) GSL::Matrix::Complex.memcpy(a, m) eval, evec = a.eigen_hermv(w2) test_eigen_complex_results(n, m, eval, evec, desc, "unsorted") GSL::Matrix::Complex.memcpy(a, m) eval2 = a.eigen_herm(w1) test_eigenvalues(n, eval, eval2, desc, "unsorted") GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_VAL_ASC) test_eigen_complex_results(n, m, eval, evec, desc, "val/asc") GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_VAL_DESC) test_eigen_complex_results(n, m, eval, evec, desc, "val/desc") GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_ABS_ASC) test_eigen_complex_results(n, m, eval, evec, desc, "abs/asc") GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_ABS_DESC) test_eigen_complex_results(n, m, eval, evec, desc, "abs/desc") end r = GSL::Matrix.alloc([0, 0, -1, 0], [0, 1, 0, 1], [-1, 0, 0, 0], [0, 1, 0, 0]) test_eigen_symm("symm(4)", r) c = r.to_complex test_eigen_herm("herm(4)", c) r = GSL::Matrix.alloc(4, 4) r.set_diagonal([1, 2, 3, 4]) test_eigen_symm("symm(4) diag", r) c = r.to_complex test_eigen_herm("herm(4) diag", c) gsl-1.15.3/tests/eigen/gensymm.rb0000755000175000017500000000406312220252463016205 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") require("eigen.rb") include GSL::Test def test_eigen_gensymm_results(a, b, eval, evec, count, desc, desc2) n = a.size1 # check A v = lambda B v for i in 0...n do ei = eval[i] vi = evec.column(i) norm = vi.dnrm2 # check that eigenvector is normalized GSL::Test::test_rel(norm, 1.0, n * GSL::DBL_EPSILON, "gensymm(N=#{n},cnt=#{count}), #{desc}, normalized(#{i}), #{desc2}") y = a*vi x = b*vi x *= ei for j in 0...n do GSL::Test::test_rel(y[j], x[j], 1e9 * GSL::DBL_EPSILON, "gensymm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), #{desc2}") end end end def test_eigen_gensymm() n_max = 20 rng = GSL::Rng.alloc() for n in 1..n_max do w = GSL::Eigen::Gensymm::Workspace.alloc(n) wv = GSL::Eigen::Gensymmv::Workspace.alloc(n) for i in 0...5 do a = create_random_symm_matrix(n, n, rng, -10, 10) b = create_random_posdef_matrix(n, n, rng) aa = a.clone bb = b.clone evalv, evec = GSL::Eigen::gensymmv(aa, bb, wv) test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "unsorted") aa = a.clone bb = b.clone eval = GSL::Eigen::gensymm(aa, bb, w) x = eval.sort y = evalv.sort test_eigenvalues_real(y, x, "gensymm, random", "unsorted"); GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_VAL_ASC); test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "val/asc"); GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_VAL_DESC); test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "val/desc"); GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_ABS_ASC); test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "abs/asc"); GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_ABS_DESC); test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "abs/desc"); end end end test_eigen_gensymm() gsl-1.15.3/tests/wavelet.rb0000755000175000017500000000641412220252463015110 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("./gsl_test2.rb") include GSL::Test include Math N_BS = 11 def urand() x = 1 x = (1103515245 * x + 12345) & 0x7fffffff return x / 2147483648.0 end def test_1d(n, stride, type, member) nn = n*stride data = GSL::Vector.alloc(nn) for i in 0...nn data[i] = 12345.0 + i end v1 = data.view_with_stride(0, stride, n) for i in 0...n v1[i] = urand() end v2 = GSL::Vector.alloc(n) GSL::Vector.memcpy(v2, v1) vdelta = GSL::Vector.alloc(n) work = GSL::Wavelet::Workspace.alloc(n) w = GSL::Wavelet.alloc(type, member) w.transform_forward(v2, work) w.transform_inverse(v2, work) for i in 0...n x1 = v1[i] x2 = v2[i] vdelta[i] = (x1 - x2).abs end i = vdelta.max_index x1 = v1[i] x2 = v2[i] GSL::Test::test((x2 - x1).abs > n*1e-15 ? 1 : 0, "#{w.name}(#{member}), n = #{n}, stride = #{stride}, maxerr = #{(x2 - x1).abs}") if stride > 1 status = 0 for i in 0...nn next if i%stride == 0 status |= (data[i] != 12345.0 + i) ? 1 : 0 end GSL::Test::test(status, "#{w.name}(#{member}) other data untouched, n = #{n}, stride = #{stride}") end end def test_2d(n, tda, t, member, type) nn = n*tda data = GSL::Vector.alloc(nn) typename = (type == 1) ? "standard" : "nonstd" for i in 0...nn data[i] = 12345.0 + i end m1 = data.matrix_view_with_tda(n, n, tda) for i in 0...n for j in 0...n m1.set(i, j, urand()) end end m2 = GSL::Matrix.alloc(n, n) GSL::Matrix.memcpy(m2, m1) mdelta = GSL::Matrix.alloc(n, n) work = GSL::Wavelet::Workspace.alloc(n) w = GSL::Wavelet.alloc(t, member) case type when 1 GSL::Wavelet2d::transform_matrix_forward(w, m2, work) GSL::Wavelet2d::transform_matrix_inverse(w, m2, work) when 2 GSL::Wavelet2d::nstransform_matrix_forward(w, m2, work) GSL::Wavelet2d::nstransform_matrix_inverse(w, m2, work) end for i in 0...n for j in 0...n x1 = m1[i,j] x2 = m2[i,j] mdelta.set(i, j, (x1 - x2).abs) end end i, j = mdelta.max_index x1 = m1[i,j] x2 = m1[i,j] GSL::Test::test((x2 - x1).abs > n*1e-15 ? 1 : 0, "#{w.name}(#{member})-2d #{typename}, n = #{n}, tda = #{tda}, maxerr = #{(x2 - x1).abs}") if tda > n status = 0 for i in 0...n for j in n...tda status |= (data[i*tda+j] != (12345.0 + (i*tda+j))) ? 1 : 0 end end GSL::Test::test(status, "#{w.name}(#{member})-2d #{typename} other data untouched, n = #{n}, tda = #{tda}") end end Member = [309, 307, 305, 303, 301, 208, 206, 204, 202, 105, 103] S = 1 NS = 2 n = 1 while n <= 16384 for stride in 1..1 for i in 0...N_BS test_1d(n, stride, "bspline", Member[i]); test_1d(n, stride, "bspline_centered", Member[i]); end i = 4 while i <= 20 test_1d(n, stride, "daubechies", i) test_1d(n, stride, "daubechies_centered", i) i += 2 end test_1d(n, stride, "haar", 2) test_1d(n, stride, "haar_centered", 2) end n *= 2 end n = 1 while n <= 64 for tda in n..n for i in 0...N_BS test_2d(n, tda, "bspline", Member[i], S); test_2d(n, tda, "bspline_centered", Member[i], S); test_2d(n, tda, "bspline", Member[i], NS); test_2d(n, tda, "bspline_centered", Member[i], NS); end end n *= 2 end gsl-1.15.3/tests/monte/0000755000175000017500000000000012220252463014226 5ustar boutilboutilgsl-1.15.3/tests/monte/vegas.rb0000755000175000017500000000235312220252463015666 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test exit unless GSL::Monte::Vegas.method_defined?("params_get") dim = 1 vegas = GSL::Monte::Vegas.alloc(dim) params = vegas.params_get params.alpha = 1 vegas.params_set(params) test_abs(vegas.alpha, 1, 1e-5, "vegas_alpha") params.iterations = 4 vegas.params_set(params) test_int(vegas.iterations, 4, "vegas_iterations") params.stage = 3 vegas.params_set(params) test_int(vegas.stage, 3, "vegas_stage") params.mode = GSL::Monte::Vegas::MODE_IMPORTANCE vegas.params_set(params) test_int(vegas.mode, GSL::Monte::Vegas::MODE_IMPORTANCE, "vegas_mode MODE_IMPORTANCE") params.mode = GSL::Monte::Vegas::MODE_IMPORTANCE_ONLY vegas.params_set(params) test_int(vegas.mode, GSL::Monte::Vegas::MODE_IMPORTANCE_ONLY, "vegas_mode MODE_IMPORTANCE_ONLY") params.mode = GSL::Monte::Vegas::MODE_STRATIFIED vegas.params_set(params) test_int(vegas.mode, GSL::Monte::Vegas::MODE_STRATIFIED, "vegas_mode MODE_STRATIFIED") params.verbose = 0 vegas.params_set(params) test_int(vegas.verbose, 0, "vegas_verbose 0") params.verbose = 1 vegas.params_set(params) test_int(vegas.verbose, 1, "vegas_verbose 1") params.verbose = -1 vegas.params_set(params) test_int(vegas.verbose, -1, "vegas_verbose -1") gsl-1.15.3/tests/monte/miser.rb0000755000175000017500000000134612220252463015701 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test exit unless GSL::Monte::Miser.method_defined?("params_get") dim = 1 miser = GSL::Monte::Miser.alloc(dim) params = miser.params_get params.estimate_frac = 99 miser.params_set(params) test_abs(miser.estimate_frac, 99, 1e-5, "miser_estimate_frac") params.min_calls = 9 miser.params_set(params) test_int(miser.min_calls, 9, "miser_min_calls") params.min_calls_per_bisection = 7 miser.params_set(params) test_int(miser.min_calls_per_bisection, 7, "miser_min_calls_per_bisection") params.alpha = 3 miser.params_set(params) test_abs(miser.alpha, 3, 1e-5, "miser_alpha") params.dither = 4 miser.params_set(params) test_abs(miser.dither, 4, 1e-5, "miser_dither") gsl-1.15.3/tests/multiroot.rb0000755000175000017500000000564712220252463015506 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "multiroot/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math GC.disable def test_fdf(desc, fdf, initpt, factor, type) n = fdf.n x = eval("#{initpt}") if factor != 1.0 x = x.scale(factor) end s = GSL::MultiRoot::FdfSolver.alloc(type, n) s.set(fdf, x) iter = 0 begin iter += 1 status = s.iterate status = GSL::MultiRoot.test_residual(s.f, 0.0000001) end while status == GSL::CONTINUE and iter < 1000 jac, stat = GSL::MultiRoot.fdjacobian(fdf, s.x, s.f, GSL::SQRT_DBL_EPSILON) r = 0.0 sum = 0.0 for i in 0...n for j in 0...n u = jac[i,j] su = s.jac[i,j] r = (u - su).abs/(1e-6 + 1e-6 * u.abs) sum += r if (u - su).abs > (1e-6 + 1e-6 * u.abs) printf("broken jacobian %g\n", r) end end printf("avg r = %g\n", sum/(n*n)) end residual = 0.0 for i in 0...n residual += s.f[i].abs end GSL::Test::test(status, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}") end def test_f(desc, fdf, initpt, factor, type) n = fdf.n x = eval("#{initpt}") x = x.scale(factor) function = GSL::MultiRoot::Function.alloc(fdf.f, fdf.n) s = GSL::MultiRoot::FSolver.alloc(type, n) s.set(function, x) iter = 0 begin iter += 1 status = s.iterate status = GSL::MultiRoot.test_residual(s.f, 0.0000001) end while status == GSL::CONTINUE and iter < 1000 residual = 0.0 for i in 0...n residual += s.f[i].abs end GSL::Test::test(status, "#{type} on #{desc} (#{factor}), #{iter} iterations, residual = #{residual}") end def roth_initpt return GSL::Vector.alloc(4.5, 3.5) end def wood_initpt return GSL::Vector.alloc(-3.0, -1.0, -3.0, -1.0) end def rosenbrock_initpt GSL::Vector.alloc(-1.2, 1.0) end roth_f = Proc.new { |x, f| u = x[0] v = x[1] f[0] = -13.0 + u + ((5.0 - v)*v - 2.0)*v; f[1] = -29.0 + u + ((v + 1.0)*v - 14.0)*v; } roth_df = Proc.new { |x, df| x1 = x[1] df.set(0, 0, 1.0) df.set(0, 1, -3 * x1 * x1 + 10 * x1 - 2) df.set(1, 0, 1.0) df.set(1, 1, 3 * x1 * x1 + 2 * x1 - 14) } rosenbrock_f = Proc.new { |x, f| x0 = x[0]; x1 = x[1] y0 = 1.0 - x0 y1 = 10*(x1 - x0*x0) f[0] = y0 f[1] = y1 GSL::SUCCESS } rosenbrock_df = Proc.new { |x, df| x0 = x[0] df00 = -1.0 df01 = 0.0 df10 = -20*x0 df11 = 10 df.set(0, 0, df00) df.set(0, 1, df01) df.set(1, 0, df10) df.set(1, 1, df11) GSL::SUCCESS } roth = GSL::MultiRoot::Function_fdf.alloc(roth_f, roth_df, 2) rosenbrock = GSL::MultiRoot::Function_fdf.alloc(rosenbrock_f, rosenbrock_df, 2) fsolvers = ["dnewton", "broyden", "hybrid", "hybrids"] fsolvers.each do |type| test_f("Roth", roth, "roth_initpt", 1.0, type) test_f("Rosenbrock", rosenbrock, "rosenbrock_initpt", 1.0, type) end exit f = 1.0 fdfsolvers = ["newton", "gnewton", "hybridj", "hybridsj"] fdfsolvers.each do |type| test_fdf("Roth", roth, "roth_initpt", f, type) end gsl-1.15.3/tests/odeiv.rb0000755000175000017500000002202112220252463014537 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "odeiv-initval/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math rhs_linear = Proc.new { |t, y, f| f[0] = 0.0 f[1] = y[0] GSL::SUCCESS } jac_linear = Proc.new { |t, y, dfdy, dfdt| dfdy.set(0, 0, 0.0) dfdy.set(0, 1, 0.0) dfdy.set(1, 0, 1.0) dfdy.set(1, 1, 0.0) dfdt[0] = 0.0 dfdt[1] = 0.0 GSL::SUCCESS } Rhs_func_lin = GSL::Odeiv::System.alloc(rhs_linear, jac_linear, 2) rhs_sin = Proc.new { |t, y, f| f[0] = -y[1] f[1] = y[0] GSL::SUCCESS } jac_sin = Proc.new { |t, y, dfdy, dfdt| dfdy.set(0, 0, 0.0) dfdy.set(0, 1, -1.0) dfdy.set(1, 0, 1.0) dfdy.set(1, 1, 0.0) dfdt[0] = 0.0 dfdt[1] = 0.0 GSL::SUCCESS } Rhs_func_sin = GSL::Odeiv::System.alloc(rhs_sin, jac_sin, 2) rhs_exp = Proc.new { |t, y, f| f[0] = y[1] f[1] = y[0] GSL::SUCCESS } jac_exp = Proc.new { |t, y, dfdy, dfdt| dfdy.set(0, 0, 0.0) dfdy.set(0, 1, 1.0) dfdy.set(1, 0, 1.0) dfdy.set(1, 1, 0.0) dfdt[0] = 0.0 dfdt[1] = 0.0 GSL::SUCCESS } Rhs_func_exp = GSL::Odeiv::System.alloc(rhs_exp, jac_exp, 2) rhs_stiff = Proc.new { |t, y, f| f[0] = 998.0 * y[0] + 1998.0 * y[1] f[1] = -999.0 * y[0] - 1999.0 * y[1] GSL::SUCCESS } jac_stiff = Proc.new { |t, y, dfdy, dfdt| dfdy.set(0, 0, 998.0); dfdy.set(0, 1, 1998.0); dfdy.set(1, 0, -999.0); dfdy.set(1, 1, -1999.0); dfdt[0] = 0.0; dfdt[1] = 0.0; GSL::SUCCESS; } Rhs_func_stiff = GSL::Odeiv::System.alloc(rhs_stiff, jac_stiff, 2) def test_stepper_linear(type, hstart, base_prec) h = hstart*1.0 delmax = 0.0 count = 0 stepper = GSL::Odeiv::Step.alloc(type, 2) y = GSL::Vector.alloc(1.0, 0.0) yerr = GSL::Vector.alloc(2) t = 0.0 s = 0 while t < 4.0 status = stepper.apply(t, h, y, yerr, Rhs_func_lin) del = ((y[1] - (t + h))/y[1]).abs delmax = MAX_DBL(del, delmax) if del > (count + 1.0)*base_prec printf(" LINEAR(%20.17g) %20.17g %20.17g %8.4g\n", t + h, y[1], t + h, del); s += 1 end count += 1 t += h end GSL::Test::test(s, "#{stepper.name}, linear [0,4], max relative error = #{delmax}") end def test_stepper_sin(type, hstart, base_prec) h = hstart*1.0 delmax = 0.0 count = 0 stepper = GSL::Odeiv::Step.alloc(type, 2) y = GSL::Vector.alloc(1.0, 0.0) yerr = GSL::Vector.alloc(2) t = 0.0 s = 0 while t < M_PI sin_th = sin(t + h) status = stepper.apply(t, h, y, yerr, Rhs_func_sin) del = ((y[1] - sin_th)/sin_th).abs delmax = GSL::MAX_DBL(del, delmax) if t < 0.5*M_PI stat = (del > (count+1.0)*base_prec) ? 1 : 0 elsif t < 0.7*M_PI stat = (del > 1.0e+04*base_prec) ? 1 : 0 elsif t < 0.9*M_PI stat = (del > 1.0e+06*base_prec) ? 1 : 0 else stat = (del > 1.0e+09*base_prec) ? 1 : 0 end if stat != 0 printf(" SIN(%22.18g) %22.18g %22.18g %10.6g\n", t + h, y[1], sin_th, del); end s += stat count += 1 t += h end if delmax > 1.0e+09*base_prec s += 1 printf(" SIN(0 .. M_PI) delmax = %g\n", delmax) end GSL::Test::test(s, "#{stepper.name}, sine [0,pi], max relative error = #{delmax}") delmax = 0.0 while t < 3*M_PI status = stepper.apply(t, h, y, yerr, Rhs_func_sin) del = (y[1] - sin(t)).abs delmax = GSL::MAX_DBL(del, delmax) count += 1 t += h end if del > count * 2.0 * base_prec s += 1 printf(" SIN(%22.18g) %22.18g %22.18g %10.6g\n", t + h, y[1], sin(t), del) end test(s, "#{stepper.name}, sin [pi,3*pi], max absolute error = #{delmax}") end def test_stepper_exp(type, hstart, base_prec) s = 0 y = GSL::Vector.alloc(1.0, 1.0) yerr = GSL::Vector.alloc(2) delmax = 0.0 count = 0 h = hstart*1.0 stepper = GSL::Odeiv::Step.alloc(type, 2) t = 0.0 while t < 5.0 ex = exp(t + h) status = stepper.apply(t, h, y, yerr, Rhs_func_exp) del = ((y[1] - ex)/y[1]).abs delmax = GSL::MAX_DBL(del, delmax) if del > (count+1.0)*2.0*base_prec printf(" EXP(%20.17g) %20.17g %20.17g %8.4g\n", t + h, y[1], ex, del); s += 1 end count += 1 t += h end GSL::Test::test(s, "#{stepper.name}, exponential [0,5], max relative error = #{delmax}") end def test_stepper_stiff(type, hstart, base_prec) h = hstart*1.0 s = 0 delmax = 0.0 count = 0 stepper = GSL::Odeiv::Step.alloc(type, 2) y = GSL::Vector.alloc(1.0, 0.0) yerr = GSL::Vector.alloc(2) t = 0.0 while t < 5.0 status = stepper.apply(t, h, y, yerr, Rhs_func_stiff) if t > 0.04 arg = t + h e1 = exp(-arg) e2 = exp(-1000.0*arg) u = 2.0*e1 - e2 del = ((y[0] - u)/y[0]).abs delmax = GSL::MAX_DBL(del, delmax) if del > (count + 1.0)*100.0*base_prec printf(" STIFF(%20.17g) %20.17g %20.17g %8.4g\n", arg, y[0], u, del) s += 1 end end count += 1 t += h end GSL::Test::test(s, "#{stepper.name}, stiff [0,5], max relative error = #{delmax}") end def test_stepper_err(type, hstart, base_prec) h = hstart*1.0 y = GSL::Vector.alloc(1.0, 0.0) yerr = GSL::Vector.alloc(2) delmax = 0.0 errmax = 0.0 count = 0 s = 0 stepper = GSL::Odeiv::Step.alloc(type, 2) t = 0.0 while t < M_PI y1_t = y[1] dy_exp = cos(t)*sin(h)-2*sin(t)*pow(sin(h/2),2.0); status = stepper.apply(t, h, y, yerr, Rhs_func_sin) dy_t = y[1] - y1_t; del = (dy_t - dy_exp).abs if t > 0.1 and t < 0.2 stat = (del > 10.0*yerr[1].abs + GSL::DBL_EPSILON*y[1].abs) ? 1 : 0 if stat != 0 delmax = del errmax = yerr[1].abs printf("SIN(%.18e) %.5e %.5e %e %e %e\n", t + h, y[1], dy_t, dy_exp, del, yerr[1]); s += stat; break; end end count += 1 t += h end test(s, "#{stepper.name}, sine [0,pi], accurary of estimate error = #{delmax} vs #{errmax}") end def test_evolve_system_flat(step, sys, t0, t1, hstart, y, yfin, err_target, desc) s = 0 h = hstart*1.0 t = t0*1.0 e = GSL::Odeiv::Evolve.alloc(sys.dimension) while t < t1 t, h, status = e.apply(nil, step, sys, t, t1, h, y) end frac = ((y[1] - yfin[1])/yfin[1]).abs + ((y[0] - yfin[0])/yfin[0]).abs if frac > 2.0*e.count*err_target printf("FLAT t = %.5e y0 = %g y1= %g\n", t, y[0], y[1]); s += 1 end GSL::Test::test(s, "#{step.name}, #{desc}, evolve, no control, max relative error = #{frac}") end def test_evolve_system(type, sys, t0, t1, hstart, y, yfin, err_target, desc) s = 0 t = t0*1.0 h = hstart*1.0 step = GSL::Odeiv::Step.alloc(type, sys.dimension) c = GSL::Odeiv::Control.standard_alloc(0.0, err_target, 1.0, 1.0) e = GSL::Odeiv::Evolve.alloc(sys.dimension) while t < t1 t, h, status = e.apply(c, step, sys, t, t1, h, y) end frac = ((y[1] - yfin[1])/yfin[1]).abs + ((y[0] - yfin[0])/yfin[0]).abs if frac > 2.0*e.count*err_target printf("SYS t = %.5e h = %g y0 = %g y1= %g\n", t, h, y[0], y[1]); s += 1 end GSL::Test::test(s, "#{step.name}, #{desc}, evolve, standard control, relative error = #{frac}") end def test_evolve_exp(type, hstart, err) h = hstart*1.0 y = GSL::Vector.alloc(1.0, 1.0) eee = exp(5.0) yfin = GSL::Vector.alloc(eee, eee) test_evolve_system(type, Rhs_func_exp, 0.0, 5.0, h, y, yfin, err, "exp [0,5]") end def test_evolve_sin(type, hstart, err) h = hstart*1.0 y = GSL::Vector.alloc(1.0, 0.0) yfin = GSL::Vector.alloc(cos(2.0), sin(2.0)) test_evolve_system(type, Rhs_func_sin, 0.0, 2.0, h, y, yfin, err, "sin [0,2]") end def test_evolve_stiff1(type, hstart, err) h = hstart*1.0 y = GSL::Vector.alloc(1.0, 0.0) arg = 1.0 e1 = exp(-arg) e2 = exp(-1000.0*arg) yfin = GSL::Vector.alloc(2.0*e1 - e2, -e1 + e2) test_evolve_system(type, Rhs_func_stiff, 0.0, 1.0, h, y, yfin, err, "stiff [0,1]") end def test_evolve_stiff5(type, hstart, err) h = hstart*1.0 y = GSL::Vector.alloc(1.0, 0.0) arg = 5.0 e1 = exp(-arg) e2 = exp(-1000.0*arg) yfin = GSL::Vector.alloc(2.0*e1 - e2, -e1 + e2) less test_evolve_system(type, Rhs_func_stiff, 0.0, 5.0, h, y, yfin, err, "stiff [0,5]") end ptypes = [ {"type" => "rk2", "h" => 1e-3}, {"type" => "rk2imp", "h" => 1e-3}, {"type" => "rk4", "h" => 1e-3}, {"type" => "rk4imp", "h" => 1e-3}, {"type" => "rkf45", "h" => 1e-3}, {"type" => "rk8pd", "h" => 1e-3}, {"type" => "rkck", "h" => 1e-3}, {"type" => "bsimp", "h" => 1e-3}, {"type" => "gear1", "h" => 1e-3}, # {"type" => "gear2", # "h" => 1e-3} ] GSL::IEEE::env_setup() ptypes.each do |hash| test_stepper_err(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) end ptypes.each do |hash| # test_stepper_linear(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) # test_stepper_sin(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) test_stepper_sin(hash["type"], hash["h"]/10, 1e-8) # test_stepper_exp(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) # test_stepper_stiff(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) end ptypes.each do |hash| # test_evolve_exp(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) test_evolve_sin(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) # test_evolve_stiff1(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) # test_evolve_stiff5(hash["type"], hash["h"], GSL::SQRT_DBL_EPSILON) end gsl-1.15.3/tests/linalg/0000755000175000017500000000000012220252463014352 5ustar boutilboutilgsl-1.15.3/tests/linalg/SV.rb0000755000175000017500000000111012220252463015223 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Linalg A = GSL::Matrix.alloc([1, 2, 3, 4], 2, 2) I = GSL::Matrix.identity(2) Ainv = A.inv u, v, s = A.SV_decomp sm = s.to_m_diagonal sinv = s.collect { |elm| 1.0/elm }.to_m_diagonal a = u*sm*v.trans ainv = v*sinv*u.trans test2(a == A, "#{A.class}#SV_decomp") test2(ainv == Ainv, "#{A.class}#SV_decomp") test2((u.trans*u) == I, "#{A.class}#SV_decomp") test2((v.trans*v) == I, "#{A.class}#SV_decomp") test2(A*v == u*sm, "#{A.class}#SV_decomp") test2(A.trans*u == v*sm, "#{A.class}#SV_decomp") gsl-1.15.3/tests/linalg/cholesky.rb0000755000175000017500000000074212220252463016526 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Linalg m = GSL::Matrix.pascal(6) p m c_exp = GSL::Matrix[[1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0], [1, 2, 1, 0, 0, 0], [1, 3, 3, 1, 0, 0], [1, 4, 6, 4, 1, 0], [1, 5, 10, 10, 5, 1]] c = m.cholesky_decomp a = c.lower test2(a == c_exp, "#{m.class}#cholesky_decomp") test2((a*a.trans) == m, "#{m.class}#cholesky_decomp") gsl-1.15.3/tests/linalg/QR.rb0000755000175000017500000000404212220252463015224 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Linalg m = GSL::Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) A = m.clone x_exp = GSL::Vector[-4.05205022957397, -12.6056113959069, 1.66091162670884, 8.69376692879523] B = GSL::Vector[1, 2, 3, 4] qr, tau = m.QR_decomp test2(m == A, "#{m.class}#QR_decomp: matrix not destroyed") x = m.QR_solve(B) test2(x == x_exp, "#{m.class}#QR_solve(b)") x = QR::solve(m, B) test2(x == x_exp, "GSL::Linalg::QR::solve(b)") tau = m.QR_decomp! test2(m != A, "#{m.class}#QR_decomp: matrix destroyed") x = m.QR_solve(tau, B) test2(x == x_exp, "#{m.class}#QR_solve(tau, b)") x = qr.solve(tau, B) test2(x == x_exp, "#{qr.class}#solve(tau, b)") begin x = m.QR_solve(B) rescue puts("PASS: #{m.class}#QR_solve; tau vector must be given if m is decomped") end begin x = m.solve(B) rescue puts("PASS: #{m.class}#solve; tau vector must be given if m is decomped") end x = m.solve(tau, B) test2(x == x_exp, "#{m.class}#solve(tau, b)") m = A.clone bb = B.clone m.QR_svx(bb) test2(bb == x_exp, "#{m.class}#QR_svx(b)") tau = QR::decomp!(m) bb = B.clone m.QR_svx(tau, bb) test2(bb == x_exp, "#{m.class}#QR_svx(tau, b)") begin x = m.QR_svx(bb) rescue puts("PASS: #{m.class}#QR_solve; tau vector must be given if m is decomped") end m = A.clone qr, tau = m.QR_decomp test2(m == A, "#{m.class}#QR_decomp: matrix not destroyed") x, r = m.QR_lssolve(B) test2(x == x_exp, "#{m.class}#QR_lssolve(b)") r = m.QR_lssolve(B, x) test2(x == x_exp, "#{qr.class}#QR_lssolve(b, x)") m.QR_lssolve(B, x, r) test2(x == x_exp, "#{qr.class}#QR_lssolve(b, x, r)") x, r = qr.QR_lssolve(tau, B) test2(x == x_exp, "#{qr.class}#QR_lssolve(tau, b)") r = qr.QR_lssolve(tau, B, x) test2(x == x_exp, "#{qr.class}#QR_lssolve(tau, b, x)") qr.QR_lssolve(tau, B, x, r) test2(x == x_exp, "#{qr.class}#QR_lssolve(tau, b, x, r)") begin x, r = qr.QR_lssolve(bb) rescue puts("PASS: #{qr.class}#QR_solve; tau vector must be given if m is decomped") end gsl-1.15.3/tests/linalg/bidiag.rb0000755000175000017500000000307712220252463016130 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./linalg.rb") include GSL::Test def test_bidiag_decomp_dim(m, eps) s = 0 mm = m.size1 nn = m.size2 a = m.duplicate b = GSL::Matrix.calloc(nn, nn) aa, tau1, tau2 = GSL::Linalg::Bidiag::decomp(a) u, v, d, sd = GSL::Linalg::Bidiag::unpack(aa, tau1, tau2) b.set_diagonal(d) for i in 0...(nn-1) do b[i,i+1] = sd[i] end a = u*b*v.trans for i in 0...mm do for j in 0...nn do aij = a[i,j] mij = m[i,j] foo = check(aij, mij, eps); if foo > 0 printf("(%3lu,%3lu)[%lu,%lu]: %22.18g %22.18g\n", M, N, i,j, aij, mij); end s += foo; end end return s end def test_bidiag_decomp() s = 0 m53 = create_general_matrix(5,3) m97 = create_general_matrix(9,7) f = test_bidiag_decomp_dim(m53, 2 * 64.0 * GSL::DBL_EPSILON); GSL::test(f, " bidiag_decomp m(5,3)"); s += f; f = test_bidiag_decomp_dim(m97, 2 * 64.0 * GSL::DBL_EPSILON); GSL::test(f, " bidiag_decomp m(9,7)"); s += f; f = test_bidiag_decomp_dim(Hilb2, 2 * 8.0 * GSL::DBL_EPSILON); GSL::test(f, " bidiag_decomp hilbert(2)"); s += f; f = test_bidiag_decomp_dim(Hilb3, 2 * 64.0 * GSL::DBL_EPSILON); GSL::test(f, " bidiag_decomp hilbert(3)"); s += f; f = test_bidiag_decomp_dim(Hilb4, 2 * 1024.0 * GSL::DBL_EPSILON); GSL::test(f, " bidiag_decomp hilbert(4)"); s += f; f = test_bidiag_decomp_dim(Hilb12, 2 * 1024.0 * GSL::DBL_EPSILON); GSL::test(f, " bidiag_decomp hilbert(12)"); s += f; return s; end test_bidiag_decomp() gsl-1.15.3/tests/linalg/TDS.rb0000755000175000017500000000551712220252463015344 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./linalg.rb") include GSL::Test def test_TDS_solve_dim(dim, d, od, actual, eps) s = 0 diag = GSL::Vector.alloc(dim) diag.set_all(d) rhs = GSL::Vector.indgen(dim) + 1 offdiag = GSL::Vector.alloc(dim-1) offdiag.set_all(od) x = GSL::Linalg::solve_symm_tridiag(diag, offdiag, rhs) p x p actual for i in 0...dim do si = x[i] ai = actual[i] foo = check(si, ai, eps); if foo > 0 printf("%3lu[%lu]: %22.18g %22.18g\n", dim, i,s[i], actual[i]); end s += foo; end return s end def test_TDS_solve() s = 0 actual = GSL::Vector[0.0, 2.0] f = test_TDS_solve_dim(2, 1.0, 0.5, actual, 8.0 * GSL::DBL_EPSILON) GSL::test(f, " solve_TDS dim=2 A"); s += f; actual = GSL::Vector[3.0/8.0, 15.0/8.0] f = test_TDS_solve_dim(2, 1.0, 1.0/3.0, actual, 8.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDS dim=2 B"); s += f actual = GSL::Vector[5.0/8.0, 9.0/8.0, 2.0, 15.0/8.0, 35.0/8.0] f = test_TDS_solve_dim(5, 1.0, 1.0/3.0, actual, 8.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDS dim=5"); end def test_TDS_cyc_solve_one(dim, d, od, r, actual, eps) s = 0 diag = d.duplicate() offdiag = od.duplicate() rhs = r.duplicate() x = GSL::Linalg::solve_symm_cyc_tridiag(diag, offdiag, rhs) p x p actual for i in 0...dim do si = x[i] ai = actual[i] foo = check(si, ai, eps); if foo > 0 printf("%3lu[%lu]: %22.18g %22.18g\n", dim, i, si, actual[i]); end s += foo; end return s; end def test_TDS_cyc_solve() s = 0 =begin dim = 1 diag = GSL::Vector.alloc(1) diag[0] = 2 offdiag = GSL::Vector.alloc(1) offdiag[0] = 3 rhs = GSL::Vector.alloc(1) rhs[0] = 7 actual = GSL::Vector.alloc(1) actual[0] = 3.5 f = test_TDS_cyc_solve_one(dim, diag, offdiag, rhs, actual, 28.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDS_cyc dim=%lu A", dim); s += f; dim = 2 diag = GSL::Vector[1, 2] offdiag = GSL::Vector[3, 4] rhs = GSL::Vector[7, -7] actual = GSL::Vector[-5, 4] f = test_TDS_cyc_solve_one(dim, diag, offdiag, rhs, actual, 28.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDS_cyc dim=%lu A", dim); s += f; =end dim = 3 diag = GSL::Vector[1, 1, 1] offdiag = GSL::Vector[3, 3, 3] rhs = GSL::Vector[7, -7, 7] actual = GSL::Vector[-2, 5, -2] f = test_TDS_cyc_solve_one(dim, diag, offdiag, rhs, actual, 28.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDS_cyc dim=#{dim} A"); s += f; dim = 5 diag = GSL::Vector[4, 2, 1, 2, 4] offdiag = GSL::Vector[1, 1, 1, 1, 1] rhs = GSL::Vector[30, -24, 3, 21, -30] actual = GSL::Vector[ 12, 3, -42, 42, -21 ] f = test_TDS_cyc_solve_one(dim, diag, offdiag, rhs, actual, 35.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDS_cyc dim=#{dim} B"); s += f; return s end test_TDS_solve() test_TDS_cyc_solve() gsl-1.15.3/tests/linalg/linalg.rb0000755000175000017500000001036112220252463016151 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test def check(x, actual, eps) if x == actual return 0 elsif actual.zero? return x.abs > eps ? 1 : 0 else return ((x - actual).abs/actual.abs > eps) ? 1 : 0 end end def create_hilbert_matrix(size) m = GSL::Matrix.alloc(size, size) for i in 0...size for j in 0...size m.set(i, j, 1.0/(i+j+1.0)) end end return m end def create_general_matrix(size1, size2) m = GSL::Matrix.alloc(size1, size2) for i in 0...size1 for j in 0...size2 m.set(i, j, 1.0/(i+j+1.0)) end end return m end def create_singular_matrix(size1, size2) m = create_general_matrix(size1, size2) for j in 0...m.size2 m.set(0, j, 0.0) end return m end def create_vandermonde_matrix(size) m = GSL::Matrix.alloc(size, size) for i in 0...size for j in 0...size m.set(i, j, pow(i + 1.0, size - j - 1.0)) end end return m end def create_moler_matrix(size) m = GSL::Matrix.alloc(size, size) for i in 0...size for j in 0...size m.set(i, j, GSL::MIN(i+1, j+1) - 2.0) end end return m end def create_complex_matrix(size) m = GSL::Matrix::Complex.alloc(size, size) for i in 0...size for j in 0...size z = GSL::Complex.alloc(1.0/(i+j+1.0), 1/(i*i+j*j+0.5)) m.set(i, j, z) end end return m end def create_row_matrix(size1, size2) m = GSL::Matrix.alloc(size1, size2) for i in 0...size1 m.set(i, 0, 1.0/(i + 1.0)) end return m end def create_2x2_matrix(a11, a12, a21, a22) return GSL::Matrix.alloc(a11, a12, a21, a22) end def create_diagonal_matrix(a, size) m = GSL::Matrix.alloc(size, size) for i in 0...size m.set(i, i, a[i]) end return m end Hilb2 = create_hilbert_matrix(2) Hilb3 = create_hilbert_matrix(3) Hilb4 = create_hilbert_matrix(4) Hilb12 = create_hilbert_matrix(12) Vander2 = create_vandermonde_matrix(2) Vander3 = create_vandermonde_matrix(3) Vander4 = create_vandermonde_matrix(4) Vander12 = create_vandermonde_matrix(12) inf5_data = GSL::Vector.alloc(1.0, 0.0, -3.0, 0.0, -5.0) m53_lssolution = GSL::Vector.alloc(52.5992295702070, -337.7263113752073, 351.8823436427604) Hilb2_solution = GSL::Vector.alloc(-8.0, 18.0) Hilb3_solution = GSL::Vector.alloc(27.0, -192.0, 210.0) Hilb4_solution = GSL::Vector.alloc(-64.0, 900.0, -2520.0, 1820.0) Hilb12_solution = GSL::Vector.alloc(-1728.0, 245388.0, -8528520.0, 127026900.0, -1009008000.0, 4768571808.0, -14202796608.0, 27336497760.0, -33921201600.0, 26189163000.0, -11437874448.0, 2157916488.0) c7_solution = GSL::Vector.alloc(2.40717272023734e+01, -9.84612797621247e+00, -2.69338853034031e+02, 8.75455232472528e+01, 2.96661356736296e+03, -1.02624473923993e+03, -1.82073812124749e+04, 5.67384473042410e+03, 5.57693879019068e+04, -1.61540963210502e+04, -7.88941207561151e+04, 1.95053812987858e+04, 3.95548551241728e+04, -7.76593696255317e+03) Vander2_solution = GSL::Vector.alloc(1.0, 0.0) Vander3_solution = GSL::Vector.alloc(0.0, 1.0, 0.0) Vander4_solution = GSL::Vector.alloc(0.0, 0.0, 1.0, 0.0) Vander12_solution = GSL::Vector.alloc(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) def test_matmult() s = 0 a = GSL::Matrix.alloc([10.0, 5.0, 1.0, 20.0], 2, 2) b = GSL::Matrix.alloc([10.0, 5.0, 2.0, 1.0, 3.0, 2.0], 2, 3) c = a**b s += ((c[0,0] - 105.0).abs > GSL::DBL_EPSILON) ? 1 : 0 s += ((c[0,1] - 65.0).abs > GSL::DBL_EPSILON) ? 1 : 0 s += ((c[0,2] - 30.0).abs > GSL::DBL_EPSILON) ? 1 : 0 s += ((c[1,0] - 30.0).abs > GSL::DBL_EPSILON) ? 1 : 0 s += ((c[1,1] - 65.0).abs > GSL::DBL_EPSILON) ? 1 : 0 s += ((c[1,2] - 42.0).abs > GSL::DBL_EPSILON) ? 1 : 0 return s end def test_matmult_mod() s = 0 a = GSL::Matrix[[10.0, 5.0, 1.0], [1.0, 20.0, 5.0], [1.0, 3.0, 7.0]] b = GSL::Matrix[[10.0, 5.0, 2.0], [1, 3, 2], [1, 3, 2]] d = GSL::Matrix[[10, 5, 1], [1, 20, 5]] end def test_LU_solve_dim(m, actual, eps) dim = m.size1 s = 0 perm = Permutation.alloc(dim) rhs = GSL::Vector[1..dim] lu = m.clone end gsl-1.15.3/tests/linalg/TDN.rb0000755000175000017500000000506112220252463015331 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./linalg.rb") include GSL::Test def test_TDN_solve_dim(dim, d, a, b, actual, eps) s = 0 abovediag = GSL::Vector.alloc(dim-1) belowdiag = GSL::Vector.alloc(dim-1) diag = GSL::Vector.alloc(dim) diag.set_all(d) rhs = GSL::Vector.indgen(dim) + 1 abovediag.set_all(a) belowdiag.set_all(b) x = GSL::Linalg::solve_tridiag(diag, abovediag, belowdiag, rhs) p x p actual for i in 0...dim do si = x[i] ai = actual[i] foo = check(si, ai, eps); if foo > 0 printf("%3lu[%lu]: %22.18g %22.18g\n", dim, i, x[i], actual[i]); s += foo; end end return s end def test_TDN_solve() s = 0 actual = GSL::Vector.alloc(5) actual[0] = -7.0/3.0; actual[1] = 5.0/3.0; actual[2] = 4.0/3.0; f = test_TDN_solve_dim(3, 1.0, 2.0, 1.0, actual, 2.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDN dim=2 A"); s += f; actual[0] = 0.75; actual[1] = 0.75; actual[2] = 2.625; f = test_TDN_solve_dim(3, 1.0, 1.0/3.0, 1.0/2.0, actual, 2.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDN dim=2 B"); s += f; actual[0] = 99.0/140.0; actual[1] = 41.0/35.0; actual[2] = 19.0/10.0; actual[3] = 72.0/35.0; actual[4] = 139.0/35.0; f = test_TDN_solve_dim(5, 1.0, 1.0/4.0, 1.0/2.0, actual, 35.0/8.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDN dim=5"); s += f; return s; end def test_TDN_cyc_solve_dim(dim, d, a, b, actual, eps) s = 0 abovediag = GSL::Vector.alloc(dim) belowdiag = GSL::Vector.alloc(dim) diag = GSL::Vector.alloc(dim) rhs = GSL::Vector.indgen(dim) + 1 abovediag.set_all(a) belowdiag.set_all(b) diag.set_all(d) x = GSL::Linalg::solve_cyc_tridiag(diag, abovediag, belowdiag, rhs); p x p actual for i in 0...dim do si = x[i] ai = actual[i] foo = check(si, ai, eps); if foo > 0 printf("%3lu[%lu]: %22.18g %22.18g\n", dim, i, x[i], actual[i]); end s += foo; end return s end def test_TDN_cyc_solve() s = 0 actual = GSL::Vector.alloc(5) actual[0] = 3.0/2.0; actual[1] = -1.0/2.0; actual[2] = 1.0/2.0; f = test_TDN_cyc_solve_dim(3, 1.0, 2.0, 1.0, actual, 32.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDN_cyc dim=2 A"); s += f; actual[0] = -5.0/22.0; qactual[1] = -3.0/22.0; actual[2] = 29.0/22.0; actual[3] = -9.0/22.0; actual[4] = 43.0/22.0; f = test_TDN_cyc_solve_dim(5, 3.0, 2.0, 1.0, actual, 66.0 * GSL::DBL_EPSILON); GSL::test(f, " solve_TDN_cyc dim=5"); s += f; return s; end test_TDN_solve() test_TDN_cyc_solve() gsl-1.15.3/tests/linalg/LU.rb0000755000175000017500000000312612220252463015224 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Linalg m = GSL::Matrix::alloc([0.18, 0.60, 0.57, 0.96], [0.41, 0.24, 0.99, 0.58], [0.14, 0.30, 0.97, 0.66], [0.51, 0.13, 0.19, 0.85]) A = m.clone lu_exp = GSL::Matrix.alloc([0.51, 0.13, 0.19, 0.85], [0.352941176470588, 0.554117647058823, 0.502941176470588, 0.66], [0.803921568627451, 0.244515215852796, 0.71427813163482, -0.264713375796178], [0.274509803921569, 0.476999292285916, 0.949126848480345, 0.363093705877982]) x_exp = GSL::Vector[-4.05205022957397, -12.6056113959069, 1.66091162670884, 8.69376692879523] lu, perm, signum = m.LU_decomp test2(m == A, "#{A.class}#LU_decomp: matrix not destroyed") test2(lu == lu_exp, "#{A.class}#LU_decomp") b = GSL::Vector[1, 2, 3, 4] x = LU.solve(lu, perm, b) test2(x == x_exp, "#{A.class}.LU_solve") x = lu.solve(perm, b) test2(x == x_exp, "#{lu.class}#solve") perm, signum = m.LU_decomp! test2(m == lu_exp, "#{A.class}#LU_decomp!") m = A.clone x = LU.solve(m, perm, b) test2(x == x_exp, "#{A.class}.LU_solve") x = m.LU_solve(perm, b) test2(x == x_exp, "#{A.class}#LU_solve") test2(m == A, "#{A.class}#LU_solve: matrix not destroyed") h = GSL::Matrix.hilbert(5) invh = GSL::Matrix.invhilbert(5) lu, perm, sign = h.LU_decomp a = Linalg::LU::invert(lu, perm) test2(a.equal?(invh, 1e-6), "#{h.class}#LU_invert, Hilbert matrix of order 5") a =lu.invert(perm) test2(a.equal?(invh, 1e-6), "#{h.class}#LU_invert, Hilbert matrix of order 5") a = h.inv test2(a.equal?(invh, 1e-6), "#{h.class}#LU_invert, Hilbert matrix of order 5") gsl-1.15.3/tests/linalg/HH.rb0000755000175000017500000000276512220252463015213 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./linalg.rb") include GSL::Test def test_HH_solve_dim(m, actual, eps) dim = m.size1 s = 0 perm = GSL::Permutation.alloc(dim) x = GSL::Vector.indgen(dim) + 1 hh = m.duplicate GSL::Linalg::HH.svx(hh, x) for i in 0...dim do foo = check(x[i],actual[i],eps) if foo > 0 printf("%3lu[%lu]: %22.18g %22.18g\n", dim, i, x[i], actual[i]) end s += foo; end return s end def test_HH_solve() s = 0 f = test_HH_solve_dim(Hilb2, Hilb2_solution, 8.0 * GSL::DBL_EPSILON); GSL::test(f, " HH_solve Hilbert(2)"); s += f; f = test_HH_solve_dim(Hilb3, Hilb3_solution, 128.0 * GSL::DBL_EPSILON); GSL::test(f, " HH_solve Hilbert(3)"); s += f; f = test_HH_solve_dim(Hilb4, Hilb4_solution, 2.0 * 1024.0 * GSL::DBL_EPSILON); GSL::test(f, " HH_solve Hilbert(4)"); s += f; f = test_HH_solve_dim(Hilb12, Hilb12_solution, 0.5); GSL::test(f, " HH_solve Hilbert(12)"); s += f; f = test_HH_solve_dim(Vander2, Vander2_solution, 8.0 * GSL::DBL_EPSILON); GSL::test(f, " HH_solve Vander(2)"); s += f; f = test_HH_solve_dim(Vander3, Vander3_solution, 64.0 * GSL::DBL_EPSILON); GSL::test(f, " HH_solve Vander(3)"); s += f; f = test_HH_solve_dim(Vander4, Vander4_solution, 1024.0 * GSL::DBL_EPSILON); GSL::test(f, " HH_solve Vander(4)"); s += f; f = test_HH_solve_dim(Vander12, Vander12_solution, 0.05); GSL::test(f, " HH_solve Vander(12)"); s += f; return s; end test_HH_solve() gsl-1.15.3/tests/roots.rb0000755000175000017500000000437312220252463014611 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "roots/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math EPSREL = 10.0*GSL::DBL_EPSILON EPSABS = 10.0*GSL::DBL_EPSILON MAX_ITERATIONS = 150 def WITHIN_TOL(a, b, epsrel, epsabs) (a - b).abs < epsrel*GSL::MIN(a.abs, b.abs) + epsabs end def test_f(type, desc, f, lower, upper, correct) s = GSL::Root::FSolver.alloc(type) s.set(f, lower, upper) iter = 0 begin iter += 1 s.iterate r = s.root a = s.x_lower b = s.x_upper if a > b GSL::Test::test(GSL::FAILURE, "interval is invalid (#{a},#{b})") end if r < a or r > b GSL::Test::test(GSL::FAILURE, "r lies outside interval #{r} (#{a},#{b})") end status = GSL::Root::test_interval(a, b, EPSABS, EPSREL) end while status == GSL::CONTINUE and iter < MAX_ITERATIONS GSL::Test::test(status, "#{s.name}, #{desc} (#{s.root} obs vs #{correct} expected)") if iter == MAX_ITERATIONS GSL::Test::test(GSL::FAILURE, "exceeded maximum number of iterations") end if !WITHIN_TOL(r, correct, EPSREL, EPSABS) GSL::Test::test(GSL::FAILURE, "incorrect precision (#{r} obs vs #{correct} expected)") end end def test_fdf(type, desc, fdf, root, correct) s = GSL::Root::FdfSolver.alloc(type) s.set(fdf, root) iter = 0 begin iter += 1 prev = s.root s.iterate status = GSL::Root::test_delta(s.root, prev, EPSABS, EPSREL) end while status == GSL::CONTINUE and iter < MAX_ITERATIONS GSL::Test::test(status, "#{s.name} #{desc} (#{s.root} obs vs #{correct} expected)") if iter == MAX_ITERATIONS GSL::Test::test(GSL::FAILURE, "exceeded maximum number of iterations") end if !WITHIN_TOL(s.root, correct, EPSREL, EPSABS) GSL::Test::test(GSL::FAILURE, "incorrect precision (#{r} obs vs #{correct} expected)") end end func1 = GSL::Function.alloc { |x| pow(x, 20.0) - 1 } func1_fdf = Proc.new { |x| 20.0*pow(x, 19.0) } fdf1 = GSL::Function_fdf.alloc(func1.f, func1_fdf) fsolvers = ["bisection", "brent", "falsepos"] fsolvers.each do |type| test_f(type, "x^20 - 1 [0.1, 2]", func1, 0.1, 2.0, 1.0) end fdfsolvers = ["newton", "secant", "steffenson"] fdfsolvers = ["newton", "steffenson"] fdfsolvers.each do |type| test_fdf(type, "x^{20} - 1 {0.9}", fdf1, 0.9, 1.0) end gsl-1.15.3/tests/vector/0000755000175000017500000000000012220252463014406 5ustar boutilboutilgsl-1.15.3/tests/vector/vector_test.rb0000755000175000017500000001061112220252463017276 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("test/unit") class VectorTest < Test::Unit::TestCase def test_vector_get v = GSL::Vector::Int.indgen(5) assert_equal(GSL::Vector::Int[3, 1, 2], v.get([3, 1, 2])) end def test_vector_addsub a = GSL::Vector::Int[2, 5, 4] b = GSL::Vector::Int[10, 30, 20] c = GSL::Vector::Int[12, 35, 24] d = GSL::Vector::Int[8, 25, 16] assert_equal(c, a+b) assert_equal(d, b-a) end def test_vector_collect v = GSL::Vector::Int.indgen(5) u = GSL::Vector::Int[0, 1, 4, 9, 16] w = v.collect { |val| val*val } assert_equal(u, w) end def test_vector_ispos_neg v = GSL::Vector::Int.indgen(5) assert_equal(v.ispos, 0) assert_equal(v.ispos?, false) assert_equal(v.isneg, 0) assert_equal(v.isneg?, false) v += 1 assert_equal(v.ispos, 1) assert_equal(v.ispos?, true) assert_equal(v.isneg, 0) assert_equal(v.isneg?, false) v -= 100 assert_equal(v.ispos, 0) assert_equal(v.ispos?, false) assert_equal(v.isneg, 1) assert_equal(v.isneg?, true) end def test_vector_isnonneg v = GSL::Vector::Int.indgen(5) assert_equal(v.isnonneg, 1) assert_equal(v.isnonneg?, true) assert_equal(v.isneg, 0) assert_equal(v.isneg?, false) v -= 100 assert_equal(v.isnonneg, 0) assert_equal(v.isnonneg?, false) assert_equal(v.isneg, 1) assert_equal(v.isneg?, true) v += 200 assert_equal(v.isnonneg, 1) assert_equal(v.isnonneg?, true) assert_equal(v.ispos, 1) assert_equal(v.ispos?, true) end def test_vector_subvector v = GSL::Vector::Int.indgen(12) # args = [] vv = v.subvector assert_not_equal(v.object_id, vv.object_id) assert_equal(v.subvector, v) # args = [Fixnum] vv = v.subvector(3) assert_equal([0, 1, 2], vv.to_a) assert_nothing_raised("subvector(-1)") {v.subvector(-1)} vv = v.subvector(-1) assert_equal([11], vv.to_a) vv = v.subvector(-2) assert_equal([10, 11], vv.to_a) assert_raise(RangeError) {v.subvector(-13)} # args = [Fixnum, Fixnum] vv = v.subvector(2, 3) assert_equal([2, 3, 4], vv.to_a) vv = v.subvector(-4, 3) assert_equal([8, 9, 10], vv.to_a) assert_nothing_raised("subvector(-4, -3)") {v.subvector(-4, -3)} vv = v.subvector(-4, -3) assert_equal([8, 7, 6], vv.to_a) assert_raise(GSL::ERROR::EINVAL) {v.subvector(-11, -3)} # args = [Fixnum, Fixnum, Fixnum] vv = v.subvector(1, 3, 4) assert_equal([1, 4, 7, 10], vv.to_a) # args = [Range] tests = { # ( range ) => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] ( 1.. 3) => [ 1, 2, 3 ], ( 1... 3) => [ 1, 2 ], ( 3.. 1) => [ 3, 2, 1 ], ( 3... 1) => [ 3, 2 ], (-7.. 9) => [ 5, 6, 7, 8, 9 ], (-7... 9) => [ 5, 6, 7, 8 ], ( 4.. -3) => [ 4, 5, 6, 7, 8, 9 ], ( 4...-3) => [ 4, 5, 6, 7, 8 ], ( 2.. -2) => [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ], ( 2...-2) => [ 2, 3, 4, 5, 6, 7, 8, 9 ], (-2.. 2) => [ 10, 9, 8, 7, 6, 5, 4, 3, 2 ], (-2... 2) => [ 10, 9, 8, 7, 6, 5, 4, 3 ], (-3.. -1) => [ 9, 10, 11], (-3...-1) => [ 9, 10 ], (-1.. -3) => [ 11, 10, 9], (-1...-3) => [ 11, 10 ], # Add more test cases here... } tests.each do |r, x| assert_nothing_raised("subvector(#{r})") {v.subvector(r)} assert_equal(x, v.subvector(r).to_a, "subvector(#{r})") end # args = [Range, Fixnum] tests = { # [( range ), s] => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] [( 1.. 6), 2] => [ 1, 3, 5 ], [( 1... 6), 2] => [ 1, 3, 5 ], [( 0.. 6), 3] => [0, 3, 6 ], [( 0... 6), 3] => [0, 3 ], # Add more test cases here... } tests.each do |(r,s), x| assert_nothing_raised("subvector(#{r},#{s})") {v.subvector(r)} assert_equal(x, v.subvector(r,s).to_a, "subvector(#{r},#{s})") end end end gsl-1.15.3/tests/vector/vector_complex_test.rb0000755000175000017500000001063412220252463021032 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("test/unit") class VectorComplexTest < Test::Unit::TestCase def test_vector_complex_get v = GSL::Vector::Complex.indgen(5) assert_equal(GSL::Vector::Complex[[3,0],[1,0],[2,0]], v.get([3, 1, 2])) end def test_vector_complex_addsub a = GSL::Vector::Complex[[-2, 5], [ 4, -1]] b = GSL::Vector::Complex[[10, 30], [20, 40]] c = GSL::Vector::Complex[[ 8, 35], [24, 39]] d = GSL::Vector::Complex[[12, 25], [16, 41]] assert_equal(c, a+b) assert_equal(d, b-a) end def test_vector_complex_collect v = GSL::Vector::Complex.indgen(5) u = GSL::Vector::Complex[[0,0], [1,0], [4,0], [9,0], [16,0]] w = v.collect { |val| val*val } assert_equal(u, w) end def test_vector_complex_subvector v = GSL::Vector::Complex.indgen(12) # args = [] vv = v.subvector assert_not_equal(v.object_id, vv.object_id) assert_equal(v.subvector, v) # args = [Fixnum] vv = v.subvector(3) assert_equal([0, 0, 1, 0, 2, 0], vv.to_a) assert_nothing_raised("subvector(-1)") {v.subvector(-1)} vv = v.subvector(-1) assert_equal([11, 0], vv.to_a) vv = v.subvector(-2) assert_equal([10, 0, 11, 0], vv.to_a) assert_raise(RangeError) {v.subvector(-13)} # args = [Fixnum, Fixnum] vv = v.subvector(2, 3) assert_equal([2, 0, 3, 0, 4, 0], vv.to_a) vv = v.subvector(-4, 3) assert_equal([8, 0, 9, 0, 10, 0], vv.to_a) assert_nothing_raised("subvector(-4, -3)") {v.subvector(-4, -3)} vv = v.subvector(-4, -3) assert_equal([8, 0, 7, 0, 6, 0], vv.to_a) assert_raise(GSL::ERROR::EINVAL) {v.subvector(-11, -3)} # args = [Fixnum, Fixnum, Fixnum] vv = v.subvector(1, 3, 4) assert_equal([1, 0, 4, 0, 7, 0, 10, 0], vv.to_a) # args = [Range] tests = { # ( range ) => [0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0] ( 1.. 3) => [ 1, 0, 2, 0, 3, 0 ], ( 1... 3) => [ 1, 0, 2, 0, ], ( 3.. 1) => [ 3, 0, 2, 0, 1, 0 ], ( 3... 1) => [ 3, 0, 2, 0 ], (-7.. 9) => [ 5, 0, 6, 0, 7, 0, 8, 0, 9, 0 ], (-7... 9) => [ 5, 0, 6, 0, 7, 0, 8, 0 ], ( 4.. -3) => [ 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0 ], ( 4...-3) => [ 4, 0, 5, 0, 6, 0, 7, 0, 8, 0 ], ( 2.. -2) => [ 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0 ], ( 2...-2) => [ 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0 ], (-2.. 2) => [ 10, 0, 9, 0, 8, 0, 7, 0, 6, 0, 5, 0, 4, 0, 3, 0, 2, 0 ], (-2... 2) => [ 10, 0, 9, 0, 8, 0, 7, 0, 6, 0, 5, 0, 4, 0, 3, 0 ], (-3.. -1) => [ 9, 0, 10, 0, 11, 0], (-3...-1) => [ 9, 0, 10, 0 ], (-1.. -3) => [ 11, 0, 10, 0, 9, 0], (-1...-3) => [ 11, 0, 10, 0 ], # Add more test cases here... } tests.each do |r, x| assert_nothing_raised("subvector(#{r})") {v.subvector(r)} assert_equal(x, v.subvector(r).to_a, "subvector(#{r})") end # args = [Range, Fixnum] tests = { # [( range ), s] => [0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0] [( 1.. 6), 2] => [ 1, 0, 3, 0, 5, 0 ], [( 1... 6), 2] => [ 1, 0, 3, 0, 5, 0 ], [( 0.. 6), 3] => [0, 0, 3, 0, 6, 0 ], [( 0... 6), 3] => [0, 0, 3, 0 ], # Add more test cases here... } tests.each do |(r,s), x| assert_nothing_raised("subvector(#{r},#{s})") {v.subvector(r)} assert_equal(x, v.subvector(r,s).to_a, "subvector(#{r},#{s})") end end end gsl-1.15.3/tests/sf/0000755000175000017500000000000012220252463013514 5ustar boutilboutilgsl-1.15.3/tests/sf/test_airy.rb0000755000175000017500000002175412220252463016060 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT TEST_SF(s, "GSL::Sf::airy_Ai_e", "(-500.0, GSL::MODE_DEFAULT)", 0.0725901201040411396, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(-5.0, GSL::MODE_DEFAULT)", 0.3507610090241142, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(-0.3000000000000094, GSL::MODE_DEFAULT)", 0.4309030952855831, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(0.6999999999999907, GSL::MODE_DEFAULT)", 0.1891624003981519, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(1.649999999999991, GSL::MODE_DEFAULT)", 0.05831058618720882, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(1.649999999999991, GSL::MODE_DEFAULT)", 0.0583105861872088521, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(2.54999999999999, GSL::MODE_DEFAULT)", 0.01446149513295428, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(3.499999999999987, GSL::MODE_DEFAULT)", 0.002584098786989702, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_e", "(5.39999999999998, GSL::MODE_DEFAULT)", 4.272986169411866e-05, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_scaled_e", "(-5.0, GSL::MODE_DEFAULT)", 0.3507610090241142, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_scaled_e", "(0.6999999999999907, GSL::MODE_DEFAULT)", 0.2795125667681217, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_scaled_e", "(1.649999999999991, GSL::MODE_DEFAULT)", 0.2395493001442741, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_scaled_e", "(2.54999999999999, GSL::MODE_DEFAULT)", 0.2183658595899388, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_scaled_e", "(3.499999999999987, GSL::MODE_DEFAULT)", 0.2032920808163519, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_scaled_e", "(5.39999999999998, GSL::MODE_DEFAULT)", 0.1836050093282229, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_e", "(-500.0, GSL::MODE_DEFAULT)", -0.094688570132991028, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_e", "(-5.0, GSL::MODE_DEFAULT)", -0.1383691349016005, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_e", "(0.6999999999999907, GSL::MODE_DEFAULT)", 0.9733286558781599, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_e", "(1.649999999999991, GSL::MODE_DEFAULT)", 2.196407956850028, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_e", "(2.54999999999999, GSL::MODE_DEFAULT)", 6.973628612493443, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_e", "(3.499999999999987, GSL::MODE_DEFAULT)", 33.05550675461069, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_e", "(5.39999999999998, GSL::MODE_DEFAULT)", 1604.476078241272, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_scaled_e", "(-5.0, GSL::MODE_DEFAULT)", -0.1383691349016005, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_scaled_e", "(0.6999999999999907, GSL::MODE_DEFAULT)", 0.6587080754582302, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_scaled_e", "(1.649999999999991, GSL::MODE_DEFAULT)", 0.5346449995597539, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_scaled_e", "(2.54999999999999, GSL::MODE_DEFAULT)", 0.461835455542297, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_scaled_e", "(3.499999999999987, GSL::MODE_DEFAULT)", 0.4201771882353061, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_scaled_e", "(5.39999999999998, GSL::MODE_DEFAULT)", 0.3734050675720473, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_e", "(-5.0, GSL::MODE_DEFAULT)", 0.3271928185544435, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_e", "(-0.5500000000000094, GSL::MODE_DEFAULT)", -0.1914604987143629, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_e", "(0.4999999999999906, GSL::MODE_DEFAULT)", -0.2249105326646850, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_e", "(1.899999999999992, GSL::MODE_DEFAULT)", -0.06043678178575718, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_e", "(3.249999999999988, GSL::MODE_DEFAULT)", -0.007792687926790889, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_e", "(5.199999999999981, GSL::MODE_DEFAULT)", -0.0001589434526459543, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_scaled_e", "(-5.0, GSL::MODE_DEFAULT)", 0.3271928185544435, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_scaled_e", "(0.5499999999999906, GSL::MODE_DEFAULT)", -0.2874057279170166, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_scaled_e", "(1.499999999999991, GSL::MODE_DEFAULT)", -0.3314199796863637, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_scaled_e", "(2.49999999999999, GSL::MODE_DEFAULT)", -0.3661089384751620, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_scaled_e", "(3.649999999999986, GSL::MODE_DEFAULT)", -0.3974033831453963, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Ai_deriv_scaled_e", "(6.299999999999977, GSL::MODE_DEFAULT)", -0.4508799189585947, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_e", "(-5.0, GSL::MODE_DEFAULT)", 0.778411773001899, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_e", "(-0.5500000000000094, GSL::MODE_DEFAULT)", 0.5155785358765014, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_e", "(0.4999999999999906, GSL::MODE_DEFAULT)", 0.5445725641405883, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_e", "(1.899999999999992, GSL::MODE_DEFAULT)", 3.495165862891568, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_e", "(3.249999999999988, GSL::MODE_DEFAULT)", 36.55485149250338, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_e", "(5.199999999999981, GSL::MODE_DEFAULT)", 2279.748293583233, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_scaled_e", "(-5.0, GSL::MODE_DEFAULT)", 0.778411773001899, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_scaled_e", "(0.5499999999999906, GSL::MODE_DEFAULT)", 0.4322811281817566, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_scaled_e", "(1.499999999999991, GSL::MODE_DEFAULT)", 0.5542307563918037, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_scaled_e", "(2.49999999999999, GSL::MODE_DEFAULT)", 0.6755384441644985, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_scaled_e", "(3.649999999999986, GSL::MODE_DEFAULT)", 0.7613959373000228, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_Bi_deriv_scaled_e", "(6.299999999999977, GSL::MODE_DEFAULT)", 0.8852064139737571, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_e", "(2)", -4.087949444130970617, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_e", "(50)", -38.02100867725525443, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_e", "(100)", -60.45555727411669871, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_e", "(110)", -64.43135670991324811, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_e", "(2)", -3.271093302836352716, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_e", "(50)", -37.76583438165180116, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_e", "(100)", -60.25336482580837088, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_e", "(110)", -64.2355167606561537, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_e", "(111)", -64.6268994819519378, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_e", "(200)", -95.88699147356682665, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_deriv_e", "(2)", -3.248197582179836561, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_deriv_e", "(50)", -37.76565910053887108, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_deriv_e", "(100)", -60.25329596442479317, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_deriv_e", "(110)", -64.23545617243546956, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Ai_deriv_e", "(1000)", -280.9378080358935071, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_deriv_e", "(2)", -4.073155089071828216, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_deriv_e", "(50)", -38.02083574095788210, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_deriv_e", "(100)", -60.45548887257140819, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_deriv_e", "(110)", -64.43129648944845060, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_deriv_e", "(111)", -64.82208737584206093, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_deriv_e", "(200)", -96.04731050310324450, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::airy_zero_Bi_deriv_e", "(1000)", -281.0315164471118527, TEST_TOL0, GSL::SUCCESS) gsl-1.15.3/tests/sf/test_mathieu.rb0000755000175000017500000000555112220252463016545 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 TEST_SNGL = 1.0e-06 TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 0.0, 0.0)", 0.7071067811865475, TEST_SNGL, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 0.0, GSL::M_PI_2)", 0.7071067811865475, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 5.0, 0.0)", 0.04480018165188902, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 5.0, GSL::M_PI_2)", 1.334848674698019, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 10.0, 0.0)", 0.007626517570935782, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 10.0, GSL::M_PI_2)", 1.468660470712856, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 15.0, 0.0)", 0.001932508315204592, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 15.0, GSL::M_PI_2)", 1.550108146686649, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 20.0, 0.0)", 0.0006037438292242197, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 20.0, GSL::M_PI_2)", 1.609890857395926, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 25.0, 0.0)", 0.0002158630184146612, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(0, 25.0, GSL::M_PI_2)", 1.657510298323475, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(1, 0.0, 0.0)", 1.00000000, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(1, 5.0, 0.0)", 0.2565428793223637, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(1, 10.0, 0.0)", 0.05359874774717657, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(1, 15.0, 0.0)", 0.01504006645382623, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_se_e", "(5, 0.0, GSL::M_PI_2)", 1.0000000, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_se_e", "(5, 5.0, GSL::M_PI_2)", 0.9060779302023551, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_se_e", "(5, 10.0, GSL::M_PI_2)", 0.8460384335355106, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_se_e", "(5, 15.0, GSL::M_PI_2)", 0.837949340012484, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_se_e", "(5, 20.0, GSL::M_PI_2)", 0.8635431218533667, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_se_e", "(5, 25.0, GSL::M_PI_2)", 0.8992683245108413, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(10, 0.0, 0.0)", 1.00000000, TEST_SNGL, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::mathieu_ce_e", "(10, 0.0, GSL::M_PI_2)", -1.00000000, TEST_SNGL, GSL::SUCCESS); gsl-1.15.3/tests/sf/test_mode.rb0000644000175000017500000000054312220252463016026 0ustar boutilboutilrequire 'minitest/autorun' require 'minitest/unit' require 'gsl' class Sf < MiniTest::Unit::TestCase def test_mode # TODO!!! z = GSL::Complex[1,0] m = GSL::Matrix::Complex.eye(2, z) assert_equal(z, m[0,0]) assert_equal(GSL::Complex[0,0], m[0,1]) assert_equal(GSL::Complex[0,0], m[1,0]) assert_equal(z, m[1,1]) end end gsl-1.15.3/tests/sf/test_sf.rb0000755000175000017500000023636212220252463015527 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT mode = GSL::MODE_DEFAULT GSL::set_error_handler_off TEST_SF(s, "GSL::Sf::clausen_e", "(M_PI/20.0)", 0.4478882448133546, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::clausen_e", "(M_PI/6.0)", 0.8643791310538927, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::clausen_e", "(M_PI/3.0)", 1.0149416064096535, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::clausen_e", "( 2.0*M_PI + M_PI/3.0)", 1.0149416064096535, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::clausen_e", "(100.0*M_PI + M_PI/3.0)", 1.0149416064096535, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(0, 1, 1, 0, 1, -1)", sqrt(1.0/2.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, 1, 2, 1, -1, 0)", sqrt(1.0/6.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(2, 4, 6, 0, 2, -2)", sqrt(8.0/105.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(4, 4, 8, 0, 0, 0)", sqrt(2.0/35.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(4, 4, 8, 2, -2, 0)", 2.0/3.0*sqrt(2.0/35.0), TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(4, 4, 8, 4, -4, 0)", 1.0/(3.0*sqrt(70.0)), TEST_TOL2, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::coupling_3j_e", "(-1, 1, 2, 1, -1, 0)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, -1, 2, 1, -1, 0)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, 1, -2, 1, -1, 0)", GSL::NAN, GSL::NAN, GSL::EDOM) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, 1, 2, 2, -1, 0)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, 1, 2, 1, -2, 0)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, 1, 2, 1, -1, 3)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, 1, 3, 1, -1, 0)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(1, 4, 2, 1, -1, 0)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_3j_e", "(4, 1, 2, 1, -1, 0)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 4, 2, 2, 2)", 1.0/6.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(4, 4, 2, 4, 4, 4)", -1.0/10.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(4, 4, 2, 4, 4, 2)", 1.0/6.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(4, 4, 2, 2, 2, 2)", -0.5/sqrt(5.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(4, 4, 4, 2, 2, 2)", sqrt(7.0/3.0)/10.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(6, 6, 6, 4, 4, 4)", -sqrt(3.0/5.0)/14.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(6, 6, 6, 4, 4, 2)", -sqrt(3.0/5.0)/7.0, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::coupling_6j_e", "(-2, 2, 4, 2, 2, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, -2, 4, 2, 2, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, -4, 2, 2, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 4, -2, 2, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 4, 2, -2, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 4, 2, 2, -2)", GSL::NAN, GSL::NAN, GSL::EDOM) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 4, 2, 2, 7)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 4, 2, 7, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 4, 7, 2, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 2, 7, 2, 2, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(2, 7, 4, 2, 2, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_6j_e", "(7, 2, 4, 2, 2, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 2, 1, 1, 2)", -sqrt(1.0/6.0)/10.0, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(8, 4, 10, 7, 3, 8, 1, 1, 2)", sqrt(7.0/3.0)/60.0, TEST_TOL2, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(-4, 2, 4, 3, 3, 2, 1, 1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, -2, 4, 3, 3, 2, 1, 1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, -4, 3, 3, 2, 1, 1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, -3, 3, 2, 1, 1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, -3, 2, 1, 1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, -2, 1, 1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 2, -1, 1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 2, 1, -1, 2)", GSL::NAN, GSL::NAN, GSL::EDOM) # TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 2, 1, 1, -2)", GSL::NAN, GSL::NAN, GSL::EDOM) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(10, 2, 4, 3, 3, 2, 1, 1, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 10, 4, 3, 3, 2, 1, 1, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 10, 3, 3, 2, 1, 1, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 10, 3, 2, 1, 1, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 10, 2, 1, 1, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 10, 1, 1, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 2, 10, 1, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 2, 1, 10, 2)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::coupling_9j_e", "(4, 2, 4, 3, 3, 2, 1, 1, 10)", 0, 0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dawson_e", "(1.0e-15)", 1.0e-15, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dawson_e", "(0.5)", 0.4244363835020222959, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dawson_e", "(2.0)", 0.30134038892379196603, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dawson_e", "(1000.0)", 0.0005000002500003750009, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_1_e", "(0.1)", 0.975277750004723276, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_1_e", "(1.0)", 0.777504634112248239, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_1_e", "(10.0)", 0.164443465679946027, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_2_e", "(0.1)", 0.967083287045302664, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_2_e", "(1.0)", 0.70787847562782924, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_2_e", "(10.0)", 0.0479714980201218708, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_3_e", "(0.1)", 0.962999940487211048, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_3_e", "(1.0)", 0.674415564077814667, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_3_e", "(10.0)", 0.0192957656903454886, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_4_e", "(0.1)", 0.960555486124335944, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_4_e", "(1.0)", 0.654874068886737049, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::debye_4_e", "(10.0)", 0.00967367556027115896, TEST_TOL0, GSL::SUCCESS) x = 0.2*DBL_MAX TEST_SF(s, "GSL::Sf::multiply_e", "(-3.0,2.0)", -6.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::multiply_e", "(#{x}, 1.0/#{x})", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::multiply_e", "(#{x}, 0.2)", 0.04*DBL_MAX, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::multiply_e", "(#{x}, 4.0)", 0.8*DBL_MAX, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_Kcomp_e", "( 0.99, #{mode})", 3.3566005233611923760, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_Kcomp_e", "( 0.50, #{mode})", 1.6857503548125960429, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_Kcomp_e", "(0.010, #{mode})", 1.5708355989121522360, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_Ecomp_e", "(0.99, #{mode})", 1.0284758090288040010, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_Ecomp_e", "(0.50, #{mode})", 1.4674622093394271555, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_Ecomp_e", "(0.01, #{mode})", 1.5707570561503852873, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_F_e", "(M_PI/3.0, 0.99, #{mode})", 1.3065333392738766762, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_F_e", "(M_PI/3.0, 0.50, #{mode})", 1.0895506700518854093, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_F_e", "(M_PI/3.0, 0.01, #{mode})", 1.0472129063770918952, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_E_e", "(M_PI/3.0, 0.99, #{mode})", 0.8704819220377943536, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_E_e", "(M_PI/3.0, 0.50, #{mode})", 1.0075555551444720293, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_E_e", "(M_PI/3.0, 0.01, #{mode})", 1.0471821963889481104, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_P_e", "(M_PI/3.0, 0.99, 0.5, #{mode})", 1.1288726598764099882, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_P_e", "(M_PI/3.0, 0.50, 0.5, #{mode})", 0.9570574331323584890, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_P_e", "(M_PI/3.0, 0.01, 0.5, #{mode})", 0.9228868127118118465, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_RF_e", "(5.0e-11, 1.0e-10, 1.0, #{mode})", 12.36441982979439, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_RF_e", "(1.0, 2.0, 3.0, #{mode})", 0.7269459354689082, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_RD_e", "(5.0e-11, 1.0e-10, 1.0, #{mode})", 34.0932594919337362, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_RD_e", "(1.0, 2.0, 3.0, #{mode})", 0.2904602810289906, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_RC_e", "(1.0, 2.0, #{mode})", 0.7853981633974482, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::ellint_RJ_e", "(2.0, 3.0, 4.0, 5.0, #{mode})", 0.1429757966715675, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(-10.0)", 2.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(-5.0000002)", 1.9999999999984625433, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(-5.0)", 1.9999999999984625402, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(-1.0)", 1.8427007929497148693, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(-0.5)", 1.5204998778130465377, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(1.0)", 0.15729920705028513066, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(3.0)", 0.000022090496998585441373, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(7.0)", 4.183825607779414399e-23, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erfc_e", "(10.0)", 2.0884875837625447570e-45, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(-1.0)", log(1.842700792949714869), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(-0.1)", 0.106576400586522485015, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(-1e-10)", 1.1283791670318505967e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(0.0)", log(1.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(1e-10)", -1.128379167159174551e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(0.001)", -0.0011290158896213548027, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(0.1)", -0.119304973737395598329, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(1.0)", log(0.15729920705028513066), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_erfc_e", "(10.0)", log(2.0884875837625447570e-45), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erf_e", "(-10.0)", -1.0000000000000000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erf_e", "(0.5)", 0.5204998778130465377, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erf_e", "(1.0)", 0.8427007929497148693, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erf_e", "(10.0)", 1.0000000000000000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erf_Z_e", "(1.0)", 0.24197072451914334980, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::erf_Q_e", "(10.0)", 7.619853024160526066e-24, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(-20.0)", 5.5209483621597631896e-88, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(-10.0)", 7.6945986267064193463e-23, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(-1.0)", 0.28759997093917836123, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "( 0.0)", 0.79788456080286535588, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "( 1.0)", 1.5251352761609812091, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(10.0)", 10.098093233962511963, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(20.0)", 20.049753068527850542, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(30.0)", 30.033259667433677037, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(50.0)", 50.019984031905639809, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(80.0)", 80.012496096798234468, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(150.0)", 150.00666607420571802, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(300.0)", 300.00333325926337415, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(900.0)", 900.00111110836764382, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(1001.0)", 1001.0009989990049990, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hazard_e", "(2000.0)", 2000.0004999997500003, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_e", "(-10.0)", exp(-10.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_e", "( 10.0)", exp( 10.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_err_e", "(-10.0, TEST_TOL1)", exp(-10.0), TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_err_e", "( 10.0, TEST_TOL1)", exp( 10.0), TEST_TOL1, GSL::SUCCESS) x = 0 TEST_SF(s, "GSL::Sf::exp_mult_e", "(-10.0, 1.0e-06)", 1.0e-06*exp(-10.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(-10.0, 2.0)", 2.0*exp(-10.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(-10.0, -2.0)", -2.0*exp(-10.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "( 10.0, 1.0e-06)", 1.0e-06*exp( 10.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "( 10.0, -2.0)", -2.0*exp( 10.0), TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(#{x}, 1.00001)", 1.00001*exp(x), TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(#{x}, 1.000001)", 1.000001*exp(x), TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(#{x}, 1.000000001)", 1.000000001*exp(x), TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(#{x}, 100.0)", 100.0*exp(x), TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(#{x}, 1.0e+20)", 1.0e+20*exp(x), TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_e", "(#{x}, exp(-#{x})*exp(M_LN2))", 2.0, TEST_TOL4, GSL::SUCCESS ) TEST_SF(s, "GSL::Sf::exp_mult_err_e", "(-10.0, TEST_SQRT_TOL0, 2.0, TEST_SQRT_TOL0)", 2.0*exp(-10.0), TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exp_mult_err_e", "(#{x}, TEST_SQRT_TOL0*#{x}, exp(-#{x})*exp(M_LN2), TEST_SQRT_TOL0*#{x})", 2.0, TEST_SQRT_TOL0, GSL::SUCCESS ) TEST_SF(s, "GSL::Sf::expm1_e", "(-10.0)", exp(-10.0)-1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expm1_e", "(-0.001)", -0.00099950016662500845, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expm1_e", "(-1.0e-8)", -1.0e-08 + 0.5e-16, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expm1_e", "( 1.0e-8)", 1.0e-08 + 0.5e-16, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expm1_e", "( 0.001)", 0.0010005001667083417, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expm1_e", "( 10.0)", exp(10.0)-1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_e", "(-10.0)", 0.0999954600070237515, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_e", "(-0.001)", 0.9995001666250084, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_e", "(-1.0e-8)", 1.0 - 0.5e-08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_e", "( 1.0e-8)", 1.0 + 0.5e-08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_e", "( 0.001)", 1.0005001667083417, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_e", "( 10.0)", 2202.5465794806716517, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_2_e", "(-10.0)", 0.18000090799859524970, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_2_e", "(-0.001)", 0.9996667499833361107, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_2_e", "(-1.0e-8)", 0.9999999966666666750, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_2_e", "( 1.0e-8)", 1.0000000033333333417, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_2_e", "( 0.001)", 1.0003334166833361115, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_2_e", "( 10.0)", 440.3093158961343303, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, -1000.0)", 0.00299400600000000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, -100.0)", 0.02940600000000000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, -10.0)", 0.24599972760042142509, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, -3.0)", 0.5444917625849191238, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, -0.001)", 0.9997500499916678570, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, -1.0e-8)", 0.9999999975000000050, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, 1.0e-8)", 1.0000000025000000050, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, 0.001)", 1.0002500500083345240, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, 3.0)", 2.5745637607083706091, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, 3.1)", 2.6772417068460206247, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, 10.0)", 131.79279476884029910, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(3, 100.0)", 1.6128702850896812690e+38, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, -1000.0)", 0.04766231609253975959, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, -100.0)", 0.3348247572345889317, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, -10.0)", 0.8356287051853286482, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, -3.0)", 0.9443881609152163615, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, -1.0)", 0.980762245565660617, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, -1.0e-8)", 1.0 -1.0e-8/51.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, 1.0e-8)", 1.0 +1.0e-8/51.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, 1.0)", 1.01999216583666790, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, 3.0)", 1.0624205757460368307, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, 48.0)", 7.499573876877194416, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, 50.1)", 9.311803306230992272, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, 100.0)", 8.175664432485807634e+07, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(50, 500.0)", 4.806352370663185330e+146, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, -1000.0)", 0.3334815803127619256, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, -100.0)", 0.8335646217536183909, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, -10.0)", 0.9804297803131823066, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, -3.0)", 0.9940475488850672997, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, -1.0)", 0.9980079602383488808, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, -1.0e-8)", 1.0 -1.0e-8/501.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 1.0e-8)", 1.0 +1.0e-8/501.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 1.0)", 1.0019999920160634252, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 3.0)", 1.0060240236632444934, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 48.0)", 1.1059355517981272174, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 100.0)", 1.2492221464878287204, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 500.0)", 28.363019877927630858, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 1000.0)", 2.4037563160335300322e+68, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::exprel_n_e", "(500, 1600.0)", 7.899293535320607403e+226, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(-1.0)", -1.8951178163559367555, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(1.0e-10)", 22.448635265138923980, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(1.0e-05)", 10.935719800043695615, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(0.1)", 1.82292395841939066610, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(1.0)", 0.21938393439552027368, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(10.0)", 4.156968929685324277e-06, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(50.0)", 3.783264029550459019e-24, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_e", "(300.0)", 1.710384276804510115e-133, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(-1.0)", 0.8231640121031084799, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(1.0/4294967296.0)", 0.9999999947372139168, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(1.0/65536.0)", 0.9998243233207178845, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(0.1)", 0.7225450221940205066, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(1.0)", 0.14849550677592204792, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(10.0)", 3.830240465631608762e-06, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(50.0)", 3.711783318868827367e-24, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_e", "(300.0)", 1.7047391998483433998e-133, TEST_TOL2, GSL::SUCCESS) if GSL_VERSION >= "1.9.90" TEST_SF(s, "GSL::Sf::expint_En_e", "(1, -1.0)", -1.8951178163559367555, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_En_e", "(1, 1.0e-10)", 22.448635265138923980, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_En_e", "(1, 1.0e-5)", 10.93571980004369561, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_En_e", "(1,0.1)", 1.82292395841939066610, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(1,1.0)", 0.21938393439552027368, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(1,10.0)", 4.156968929685324277e-06, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(1,50.0)", 3.783264029550459019e-24, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(1,300.0)", 1.710384276804510115e-133, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,-1.0)", 0.8231640121031084799, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,0.0)", 1.0, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,1.0/4294967296.0)", 0.9999999947372139168, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,1.0/65536.0)", 0.9998243233207178845, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,0.1)", 0.7225450221940205066, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,1.0)", 0.14849550677592204792, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,10.0)", 3.830240465631608762e-06, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,50.0)", 3.711783318868827367e-24, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(2,300.0)", 1.7047391998483433998e-133, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,0.0)", 0.5, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,1.0/4294967296.0)", 0.499999999767169356972, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,1.0/65536.0)", 0.4999847426094515610, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,0.1)", 0.4162914579082787612543, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,1.0)", 0.10969196719776013683858, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,10.0)",0.000003548762553084381959981, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,50.0)", 3.6429094264752049812e-24, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(3,300.0)",1.699131143349179084e-133, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,0.0)", 0.111111111111111111, TEST_TOL0, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,1.0/4294967296.0)", 0.111111111082007280658, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,1.0/65536.0)", 0.11110920377910896018606, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,0.1)", 0.099298432000896813567905, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,1.0)", 0.036393994031416401634164534, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,10.0)", 0.00000232530265702821081778968, TEST_TOL1, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,50.0)", 3.223296586749110919572e-24, TEST_TOL2, GSL::SUCCESS); TEST_SF(s, "GSL::Sf::expint_En_e", "(10,300.0)", 1.6608815083360041367294736e-133, TEST_TOL2, GSL::SUCCESS); end TEST_SF(s, "GSL::Sf::expint_Ei_e", "(-1.0)", -0.21938393439552027368, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_Ei_e", "(1.0/4294967296.0)", -21.603494112783886397, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_Ei_e", "(1.0)", 1.8951178163559367555, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(-10000.0)", -0.00010001000200060024012, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(-1000.0)", -0.0010010020060241207251, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(-10.0)", -0.11314702047341077803, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(-1.0)", -0.69717488323506606877, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(1.0e-10)", 22.448635267383787506, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(1.0e-05)", 10.935829157788483865, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(0.1)", 2.0146425447084516791, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(1.0)", 0.59634736232319407434, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(10.0)", 0.091563333939788081876, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(50.0)", 0.019615109930114870365, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(300.0)", 0.0033222955652707070644, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(1000.0)", 0.00099900199402388071500, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E1_scaled_e", "(10000.0)", 0.000099990001999400239880, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(-10000.0)", -0.00010002000600240120072, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(-1000.0)", -0.0010020060241207250807, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(-10.0)", -0.13147020473410778034, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(-1.0)", 0.30282511676493393123, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(1.0/4294967296.0)", 0.99999999497004455927, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(1.0/65536.0)", 0.99983957954556245453, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(0.1)", 0.79853574552915483209, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(1.0)", 0.40365263767680592566, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(10.0)", 0.084366660602119181239, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(50.0)", 0.019244503494256481735, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(300.0)", 0.0033113304187878806691, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(1000.0)", 0.00099800597611928500004, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_E2_scaled_e", "(10000.0)", 0.000099980005997601199281, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_Ei_scaled_e", "(-1000.0)", -0.00099900199402388071500, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_Ei_scaled_e", "(-1.0)", -0.59634736232319407434, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_Ei_scaled_e", "(1.0/4294967296.0)", -21.603494107753930958, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_Ei_scaled_e", "(1.0)", 0.69717488323506606877, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_Ei_scaled_e", "(1000.0)", 0.0010010020060241207251, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(-1.0)", -1.0572508753757285146, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(1.0/4294967296.0)", 2.3283064365386962891e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(1.0/65536.0)", 0.00001525878906269737298, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(0.1)", 0.1000555722250569955, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(1.0)", 1.0572508753757285146, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(10.0)", 1246.1144901994233444, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(50.0)", 5.292818448565845482e+19, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Shi_e", "(300.0)", 3.248241254044332895e+127, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(-1.0)", 0.8378669409802082409, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(1.0/4294967296.0)", -21.603494113016717041, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(1.0/65536.0)", -10.513139223999384429, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(1.0/8.0)", -1.4983170827635760646, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(1.0)", 0.8378669409802082409, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(10.0)", 1246.1144860424544147, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(50.0)", 5.292818448565845482e+19, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Chi_e", "(300.0)", 3.248241254044332895e+127, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(1.0e-10)", 1.0e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(1.0e-05)", 9.9999999999999975e-06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(0.1)", 0.09997500714119079665122, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(0.5)", 0.48491714311363971332427, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(1.0)", 0.80751118213967145285833, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(2.0)", 0.89295351429387631138208, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(5.0)", 0.89297951156924921121856, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(10.0)", 0.89297951156924921121856, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::expint_3_e", "(100.0)", 0.89297951156924921121856, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(-1.0)", -0.9460830703671830149, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(1.0e-10)", 1.0e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(1.0e-05)", 9.999999999944444444e-06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(0.1)", 0.09994446110827695016, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(1.0)", 0.9460830703671830149, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(10.0)", 1.6583475942188740493, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(50.0)", 1.5516170724859358947, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(300.0)", 1.5708810882137495193, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Si_e", "(1.0e+20)", 1.5707963267948966192, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(1.0/4294967296.0)", -21.603494113016717041, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(1.0/65536.0)", -10.513139224115799751, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(1.0/8.0)", -1.5061295845296396649, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(1.0)", 0.3374039229009681347, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(10.0)", -0.04545643300445537263, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(50.0)", -0.005628386324116305440, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(300.0)", -0.003332199918592111780, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(65536.0)", 0.000010560248837656279453, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(4294967296.0)", -1.0756463261957757485e-10, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::Ci_e", "(1099511627776.0)", -3.689865584710764214e-13, 1024.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(1.0e-10)", 1.0e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(1.0e-05)", 9.99999999988888888889e-06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(0.1)", 0.09988928686033618404, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(1.0)", 0.91596559417721901505, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(2.0)", 1.57601540344632342236, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(10.0)", 3.71678149306806859029, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(50.0)", 6.16499047850274874222, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(300.0)", 8.96281388924518959990, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::atanint_e", "(1.0e+5)", 18.084471031038661920, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_m1_e", "(-10.0)", 0.00004539786870243439450, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_m1_e", "( -1.0)", 0.26894142136999512075, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_m1_e", "( 1.0)", 0.7310585786300048793, TEST_TOL0, GSL::SUCCESS) # 2008/Oct/17 YT # This test fails in Darwin 9.5.0, gcc4.0.1 # expected: 0.9999546021312975 # obtained: 0.9999546021312976 2.217778082901727e-19 2.21788e-19 # fracdiff: 5.551367143362476e-17 TEST_SF(s, "GSL::Sf::fermi_dirac_m1_e", "( 10.0)", 0.9999546021312975656, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_0_e", "(-10.0)", 0.00004539889921686464677, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_0_e", "( -1.0)", 0.31326168751822283405, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_0_e", "( 1.0)", 1.3132616875182228340, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_0_e", "( 10.0)", 10.000045398899216865, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "(-10.0)", 0.00004539941448447633524, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( -2.0)", 0.13101248471442377127, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( -1.0)", 0.3386479964034521798, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( -0.4)", 0.5825520806897909028, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 0.4)", 1.1423819861584355337, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 1.0)", 1.8062860704447742567, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 1.5)", 2.5581520872227806402, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 2.5)", 4.689474797599761667, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 10.0)", 51.64488866743374196, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 12.0)", 73.64492792264531092, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 20.0)", 201.64493406478707282, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_1_e", "( 50.0)", 1251.6449340668482264, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "(-10.0)", 0.00004539967212174776662, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( -2.0)", 0.13313272938565030508, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( -1.0)", 0.3525648792978077590, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( -0.4)", 0.6229402647001272120, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 0.4)", 1.2915805581060844533, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 1.0)", 2.1641656128127008622, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 1.5)", 3.247184513920792475, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 2.5)", 6.797764392735056317, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 10.0)", 183.11605273482105278, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 12.0)", 307.73921494638635166, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 20.0)", 1366.2320146723590157, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "( 50.0)", 20915.580036675744655, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_2_e", "(200.0)", 1.3336623201467029786e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "(-10.0)", 0.00004539847236080549532, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( -2.0)", 0.12366562180120994266, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( -1.0)", 0.29402761761145122022, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( -0.4)", 0.4631755336886027800, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 0.4)", 0.7654084737661656915, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 1.0)", 1.0270571254743506890, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 1.5)", 1.2493233478527122008, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 2.5)", 1.6663128834358313625, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 10.0)", 3.552779239536617160, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 12.0)", 3.897268231925439359, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 20.0)", 5.041018507535328603, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_mhalf_e", "( 50.0)", 7.977530858581869960, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "(-10.0)", 0.00004539920105264132755, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( -2.0)", 0.12929851332007559106, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( -1.0)", 0.3277951592607115477, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( -0.4)", 0.5522452153690688947, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 0.4)", 1.0386797503389389277, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 1.0)", 1.5756407761513002308, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 1.5)", 2.1448608775831140360, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 2.5)", 3.606975377950373251, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 10.0)", 24.084656964637653615, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 12.0)", 31.540203287044242593, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 20.0)", 67.49151222165892049, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_half_e", "( 50.0)", 266.09281252136259343, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "(-10.0)", 0.00004539956540456176333, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( -2.0)", 0.13224678225177236685, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( -1.0)", 0.3466747947990574170, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( -0.4)", 0.6056120213305040910, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 0.4)", 1.2258236403963668282, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 1.0)", 2.0022581487784644573, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 1.5)", 2.9277494127932173068, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 2.5)", 5.768879312210516582, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 10.0)", 101.00510084332600020, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 12.0)", 156.51518642795728036, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 20.0)", 546.5630100657601959, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_3half_e", "( 50.0)", 5332.353566687145552, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(3, -2.0)", 0.1342199155038680215, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(3, 0.0)", 0.9470328294972459176, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(3, 0.1)", 1.0414170610956165759, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(3, 1.0)", 2.3982260822489407070, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(3, 3.0)", 12.621635313399690724, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(3, 100.0)", 4.174893231066566793e+06, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(3, 500.0)", 2.604372285319088354e+09, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(5, -2.0)", 0.13505242246823676478, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(5, 0.0)", 0.9855510912974351041, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(5, 0.1)", 1.0876519750101492782, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(5, 1.0)", 2.6222337848692390539, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(5, 3.0)", 17.008801618012113022, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(5, 100.0)", 1.3957522531334869874e+09, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(5, 500.0)", 2.1705672808114817955e+13, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, -2.0)", 0.1352641105671255851, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, 0.0)", 0.9962330018526478992, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, 0.1)", 1.1005861815180315485, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, 1.0)", 2.6918878172003129203, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, 3.0)", 19.033338976999367642, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, 10.0)", 5654.530932873610014, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, 50.0)", 1.005005069985066278e+09, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(7, 500.0)", 9.691690268341569514e+16, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, -2.0)", 0.1353174385330242691, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, 0.0)", 0.9990395075982715656, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, 0.1)", 1.1039997234712941212, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, 1.0)", 2.7113648898129249947, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, 3.0)", 19.768544008138602223, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, 10.0)", 10388.990167312912478, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, 50.0)", 2.85466960802601649e+10, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(9, 500.0)", 2.69273849842695876e+20, 2*TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, -2.0)", 0.13532635396712288092, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, 0.0)", 0.9995171434980607541, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, 0.1)", 1.1045818238852612296, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, 1.0)", 2.7147765350346120647, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, 3.0)", 19.917151938411675171, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, 10.0)", 12790.918595516495955, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, 50.0)", 1.3147703201869657654e+11, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(10, 500.0)", 1.2241331244469204398e+22, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, -2.0)", 0.1353308162894847149, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, 0.0)", 0.9997576851438581909, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, 0.1)", 1.1048751811565850418, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, 1.0)", 2.7165128749007313436, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, 3.0)", 19.997483022044603065, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, 10.0)", 14987.996005901818036, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, 50.0)", 5.558322924078990628e+11, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(11, 500.0)", 5.101293089606198280e+23, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, -2.0)", 0.13533527450327238373, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, 0.0)", 0.9999995232582155428, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, 0.1)", 1.1051703357941368203, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, 1.0)", 2.7182783069905721654, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, 3.0)", 20.085345296028242734, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, 10.0)", 21898.072920149606475, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, 50.0)", 1.236873256595717618e+16, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fermi_dirac_int_e", "(20, 500.0)", 9.358938204369557277e+36, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_1_e", "(-0.2, 1.0)", -0.4, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_1_e", "( 0.0, 1.0)", 2.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_1_e", "( 1.0, 1.0)", 2.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_1_e", "( 1.0, 0.5)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_1_e", "( 5.0, 1.0)", 10.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_1_e", "( 100.0, 0.5)", 100.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_2_e", "(-0.2, 0.5)", 0.12, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_2_e", "( 0.0, 1.0)", 1.00, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_2_e", "( 1.0, 1.0)", 3.00, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_2_e", "( 1.0, 0.1)", -0.96, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_2_e", "( 5.0, 1.0)", 55.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_2_e", "( 100.0, 0.5)", 4950.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_3_e", "(-0.2, 0.5)", 0.112, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_3_e", "( 0.0, 1.0)", -2.0/3.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_3_e", "( 1.0, 1.0)", 4.000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_3_e", "( 1.0, 0.1)", -0.392, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_3_e", "( 5.0, 1.0)", 220.000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_3_e", "( 100.0, 0.5)", 161600.000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(1, 1.0, 1.0)", 2.000 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(10, 1.0, 1.0)", 11.000 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(10, 1.0, 0.1)", -0.4542309376 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(10, 5.0, 1.0)", 9.23780e+4 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(10, 100.0, 0.5)", 1.5729338392690000e+13, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(1000, 100.0, 1.0)", 3.3353666135627322e+232, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(100, 2000.0, 1.0)", 5.8753432034937579e+202, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(103, 207.0, 2.0)", 1.4210272202235983e+145, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gegenpoly_n_e", "(103, -0.4, 0.3)", -1.64527498094522e-04, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_1_e", "(0.5, -1.0)", 2.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_1_e", "(0.5, 1.0)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_1_e", "(1.0, 1.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_2_e", "( 0.5, -1.0)", 4.875, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_2_e", "( 0.5, 1.0)", -0.125, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_2_e", "( 1.0, 1.0)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_2_e", "(-1.0, 1.0)", -0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_2_e", "(-2.0, 1.0)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_2_e", "(-3.0, 1.0)", 2.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_3_e", "(0.5, -1.0)", 8.479166666666666667, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_3_e", "(0.5, 1.0)", -0.6041666666666666667, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_3_e", "(1.0, 1.0)", -0.16666666666666666667, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_3_e", "( 2.0, 1.0)", 2.3333333333333333333, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_3_e", "(-2.0, 1.0)", 1.0/3.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_3_e", "(-3.0, 1.0)", -1.0/6.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_3_e", "(-4.0, 1.0)", -8.0/3.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(1, 0.5, 1.0)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(2, 1.0, 1.0)", 0.5, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(3, 2.0, 1.0)", 2.3333333333333333333, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(4, 2.0, 0.5)", 6.752604166666666667, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(90, 2.0, 0.5)", -48.79047157201507897, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(90, 2.0, -100.0)", 2.5295879275042410902e+63, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(90, 2.0, 100.0)", -2.0929042259546928670e+20, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, 2.0, -0.5)", 2.2521795545919391405e+07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, 2.0, 0.5)", -28.764832945909097418, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(1000, 2.0, -0.5)", 2.4399915170947549589e+21, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100000, 2.0, 1.0)", 5107.73491348319, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(1, -2.0, 1.0)", -2.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(2, -2.0, 1.0)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(3, -2.0, 1.0)", 1.0/3.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(10, -2.0, 1.0)", -0.04654954805996472663, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(10, -5.0, 1.0)", -0.0031385030864197530864, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(10, -9.0, 1.0)", -2.480158730158730159e-06, TEST_TOL5, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(10, -11.0, 1.0)", 2.7182818011463844797, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(10, -11.0, -1.0)", 0.3678794642857142857, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -2.0, 1.0)", -0.0027339992019526273866, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -2.0, -1.0)", 229923.09193402028290, TEST_TOL5, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -10.0, 1.0)", 3.25966665871244092e-11, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -10.0, -1.0)", 0.00016484365618205810025, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -20.0, 1.0)", 5.09567630343671251e-21, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -30.0, 1.0)", 3.46063150272466192e-34, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -50.0, 1.0)", 1.20981872933162889e-65, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -50.0, -1.0)", 8.60763477742332922e-65, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -50.5, 1.0)", 4.84021010426688393e-31, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -50.5, -1.0)", 8.49861345212160618e-33, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -101.0, 1.0)", 2.7182818284590452354, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -101.0, -1.0)", 0.3678794411714423216, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -102.0, 1.0)", 271.8281828459045235, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -102.0, -1.0)", 37.52370299948711680, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -110.0, 1.0)", 1.0666955248998831554e+13, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -110.0, -1.0)", 1.7028306108058225871e+12, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -200.0, 1.0)", 7.47851889721356628e+58, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -200.0, -1.0)", 2.73740299754732273e+58, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -50.0, 10.0)", 4.504712811317745591e-21, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::laguerre_n_e", "(100, -50.0, -10.0)", 1.475165520610679937e-11, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(0.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(1.0)", 0.567143290409783872999969, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(2.0)", 0.852605502013725491346472, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(20.0)", 2.205003278024059970493066, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(1000.0)", 5.24960285240159622712606, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(1.0e+6)", 11.38335808614005262200016, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(1.0e+12)", 24.43500440493491313826305, TEST_TOL0, GSL::SUCCESS) # This fails in Darwin9.5.0, gcc4.0.1 TEST_SF(s, "GSL::Sf::lambert_W0_e", "(1.0e+308)", 702.641362034106812081125, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::lambert_W0_e", "(-1.0/M_E - GSL::DBL_EPSILON)", -1.0, TEST_TOL0, GSL::EDOM) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(-1.0/M_E + 1.0/(1024.0*1024.0*1024.0))", -0.999928845560308370714970, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(-1.0/M_E + 1.0/(1024.0*1024.0))", -0.997724730359774141620354, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(-1.0/M_E + 1.0/512.0)", -0.900335676696088773044678, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_W0_e", "(-1.0/M_E + 0.25)", -0.1349044682661213545487599, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(0.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(1.0)", 0.567143290409783872999969, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(2.0)", 0.852605502013725491346472, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(20.0)", 2.205003278024059970493066, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(-1.0/M_E - GSL::DBL_EPSILON)", -1.0, TEST_TOL0, GSL::EDOM) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(-1.0/M_E + 1.0/(1024.0*1024.0*1024.0))", -1.000071157815154608049055, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(-1.0/M_E + 1.0/(1024.0*1024.0))", -1.002278726118593023934693, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(-1.0/M_E + 1.0/512.0)", -1.106761200865743124599130, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(-1.0/M_E + 1.0/64.0)", -1.324240940341812125489772, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lambert_Wm1_e", "(-1.0/M_E + 0.25)", -3.345798131120112, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_e", "(0.1)", -2.3025850929940456840, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_e", "(1.1)", 0.09531017980432486004, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_e", "(1000.0)", 6.907755278982137052, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_abs_e", "(-0.1)", -2.3025850929940456840, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_abs_e", "(-1.1)", 0.09531017980432486004, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_abs_e", "(-1000.0)", 6.907755278982137052, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_abs_e", "(0.1)", -2.3025850929940456840, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_abs_e", "(1.1)", 0.09531017980432486004, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_abs_e", "(1000.0)", 6.907755278982137052, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(1.0e-10)", 9.999999999500000000e-11, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(1.0e-8)", 9.999999950000000333e-09, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(1.0e-4)", 0.00009999500033330833533, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(0.1)", 0.09531017980432486004, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(0.49)", 0.3987761199573677730, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(-0.49)", -0.6733445532637655964, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(1.0)", M_LN2, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_e", "(-0.99)", -4.605170185988091368, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(1.0e-10)", -4.999999999666666667e-21, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(1.0e-8)", -4.999999966666666917e-17, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(1.0e-4)", -4.999666691664666833e-09, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(0.1)", -0.004689820195675139956, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(0.49)", -0.09122388004263222704, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(-0.49)", -0.18334455326376559639, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(1.0)", M_LN2-1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::log_1plusx_mx_e", "(-0.99)", -3.615170185988091368, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(2.0, 3)", 8.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-2.0, 3)", -8.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(2.0, -3)", 1.0/8.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-2.0, -3)", -1.0/8.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(10.0, 4)", 1.0e+4, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(10.0, -4)", 1.0e-4, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-10.0, 4)", 1.0e+4, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-10.0, -4)", 1.0e-4, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(10.0, 40)", 1.0e+40, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(8.0, -40)", 7.523163845262640051e-37, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-10.0, 40)", 1.0e+40, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-8.0, -40)", 7.523163845262640051e-37, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(10.0, 41)", 1.0e+41, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(8.0, -41)", 9.403954806578300064e-38, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-10.0, 41)", -1.0e+41, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pow_int_e", "(-8.0, -41)", -9.403954806578300064e-38, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(1)", -0.57721566490153286060, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(2)", 0.42278433509846713939, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(3)", 0.92278433509846713939, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(4)", 1.2561176684318004727, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(5)", 1.5061176684318004727, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(100)", 4.600161852738087400, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(110)", 4.695928024251535633, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_int_e", "(5000)", 8.517093188082904107, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_e", "(5000.0)", 8.517093188082904107, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_e", "(5.0)", 1.5061176684318004727, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_e", "(-10.5)", 2.3982391295357816134, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_e", "(-100.5)", 4.615124601338064117, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_e", "(-1.0e+5-0.5)", 11.512935464924395337, 4.0*TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_e", "(-262144.0-0.5)", 12.476653064769611581, 4.0*TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(0.8)", -0.07088340212750589223, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(1.0)", 0.09465032062247697727, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(5.0)", 1.6127848446157465854, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(100.0)", 4.605178519404762003, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(2000.0)", 7.600902480375416216, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(-0.8)", -0.07088340212750589223, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(-1.0)", 0.09465032062247697727, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(-5.0)", 1.6127848446157465854, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(-100.0)", 4.605178519404762003, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1piy_e", "(-2000.0)", 7.600902480375416216, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(1)", 1.6449340668482264364, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(2)", 0.64493406684822643647, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(3)", 0.39493406684822643647, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(4)", 0.28382295573711532536, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(1)", 1.6449340668482264365, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(5)", 0.22132295573711532536, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(100)", 0.010050166663333571395, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(110)", 0.009132356622022545705, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_int_e", "(500)", 0.0020020013333322666697, TEST_TOL0, GSL::SUCCESS) if RB_GSL_VERSION >= "1.5" TEST_SF(s, "GSL::Sf::psi_1_e", "(1.0/32.0)", 1025.5728544782377089, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(1.0)", 1.6449340668482264365, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(5.0)", 0.22132295573711532536, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(100.0)", 0.010050166663333571395, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(110.0)", 0.009132356622022545705, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(500.0)", 0.0020020013333322666697, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(-1.0 - 1.0/128.0)", 16386.648472598746587, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(-1.50)", 9.3792466449891237539, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(-10.5)", 9.7787577398148123845, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(-15.5)", 9.8071247184113896201, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(-50.5)", 9.8499971860824842274, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_1_e", "(-1000.5)", 9.8686054001734414233, TEST_TOL0, GSL::SUCCESS) end TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 1)", 1.6449340668482264364, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 2)", 0.64493406684822643647, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 3)", 0.39493406684822643647, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 4)", 0.28382295573711532536, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 5)", 0.22132295573711532536, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 100)", 0.010050166663333571395, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 110)", 0.009132356622022545705, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, 500)", 0.0020020013333322666697, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(3, 5.0)", 0.021427828192755075022, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(3, 500.0)", 1.6048063999872000683e-08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(10, 5.0)", -0.08675107579196581317, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(10, 50.0)", -4.101091112731268288e-12, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(0, -1.5)", 0.70315664064524318723, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::psi_n_e", "(1, -1.5)", 9.3792466449891237539, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::synchrotron_1_e", "(0.01)", 0.444972504114210632, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::synchrotron_1_e", "(1.0)", 0.651422815355364504, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::synchrotron_1_e", "(10.0)", 0.000192238264300868882, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::synchrotron_1_e", "(100.0)", 4.69759366592220221e-43, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::synchrotron_2_e", "(0.01)", 0.23098077342226277732, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::synchrotron_2_e", "(1.0)", 0.4944750621042082670, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::synchrotron_2_e", "(10.0)", 0.00018161187569530204281, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_2_e", "(1.0e-10)", 9.9999999999999999999e-11, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_2_e", "(1.0)", 0.97303256135517012845, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_2_e", "(3.0)", 2.41105004901695346199, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_2_e", "(10.0)", 3.28432911449795173575, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_2_e", "(100.0)", 3.28986813369645287294, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_2_e", "(1.0e+05)", 3.28986813369645287294, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(1.0e-10)", 4.999999999999999999997e-21, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(1.0)", 0.479841006572417499939, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(3.0)", 3.210604662942246772338, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(5.0)", 5.614386613842273228585, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(10.0)", 7.150322712008592975030, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(30.0)", 7.212341416160946511930, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(100.0)", 7.212341418957565712398, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_3_e", "(1.0e+05)", 7.212341418957565712398, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(1.0e-10)", 3.33333333333333333333e-31, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(1.0e-07)", 3.33333333333333166666e-22, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(1.0e-04)", 3.33333333166666666726e-13, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(0.1)", 0.000333166726172109903824, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(1.0)", 0.31724404523442648241, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(3.0)", 5.96482239737147652446, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(5.0)", 15.3597843168821829816, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(10.0)", 25.2736676770304417334, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(30.0)", 25.9757575220840937469, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(100.0)", 25.9757576090673165963, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_4_e", "(1.0e+05)", 25.9757576090673165963, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(1.0e-10)", 2.49999999999999999999e-41, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(1.0e-07)", 2.49999999999999861111e-29, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(1.0e-04)", 2.49999999861111111163e-17, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(0.1)", 0.000024986116317791487410, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(1.0)", 0.236615879239094789259153, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(3.0)", 12.77055769104415951115760, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(5.0)", 50.26309221817518778543615, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(10.0)", 116.3807454024207107698556, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(30.0)", 124.4313279083858954839911, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(100.0)", 124.4313306172043911597639, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::transport_5_e", "(1.0e+05)", 124.43133061720439115976, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(-10.0)", 0.5440211108893698134, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(1.0)", 0.8414709848078965067, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(1000.0)", 0.8268795405320025603, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(1048576.75)", 0.8851545351115651914, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(62831853.75)", 0.6273955953485000827, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(1073741822.5)", -0.8284043541754465988, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(1073741824.0)", -0.6173264150460421708, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(1073741825.5)", 0.7410684679436226926, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sin_e", "(1099511627776.0)", -0.4057050115328287198, 32.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(-10.0)", -0.8390715290764524523, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(1.0)", 0.5403023058681397174, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(1000.0)", 0.5623790762907029911, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(1048576.75)", 0.4652971620066351799, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(62831853.75)", 0.7787006914966116436, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(1073741822.5)", -0.5601305436977716102, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(1073741824.0)", 0.7867071229411881196, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::cos_e", "(1099511627776.0)", -0.9140040719915570023, 128.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sinc_e", "(1.0/1024.0)", 0.9999984312693665404, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sinc_e", "(1.0/2.0)", 2.0/M_PI, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sinc_e", "(80.5)", 0.0039541600768172754, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sinc_e", "(100.5)", 0.0031672625490924445, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::sinc_e", "(1.0e+06 + 0.5)", 3.18309727028927157e-07, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::sin_pi_x_e", "(1000.5)", 1.0, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::sin_pi_x_e", "(10000.0 + 1.0/65536.0)", 0.00004793689960306688455, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::sin_pi_x_e", "(1099511627776.0 + 1 + 0.125)", -0.3826834323650897717, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnsinh_e", "(0.1)", -2.3009189815304652235, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnsinh_e", "(1.0)", 0.16143936157119563361, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnsinh_e", "(5.0)", 4.306807418479684201, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnsinh_e", "(100.0)", 99.30685281944005469, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lncosh_e", "(0.125)", 0.007792239318898252791, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lncosh_e", "(1.0)", 0.4337808304830271870, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lncosh_e", "(5.0)", 4.306898218339271555, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lncosh_e", "(100.0)", 99.30685281944005469, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_int_e", "(-61.0)", -3.30660898765775767257e+34, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_int_e", "(-5.0)", -0.003968253968253968253968, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_int_e", "( 5.0)", 1.0369277551433699263313655, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_int_e", "(31.0)", 1.0000000004656629065033784, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_int_e", "(-61.0)", -3.30660898765775767257e+34, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_int_e", "(-5.0)", -1.003968253968253968253968, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_int_e", "( 5.0)", 0.0369277551433699263313655, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_int_e", "(31.0)", 0.0000000004656629065033784, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(-151)", 8.195215221831378294e+143, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(-51)", 9.68995788746359406565e+24, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(-5)", -0.003968253968253968253968, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(-0.5)", -0.207886224977354566017307, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(-1e-10)", -0.49999999990810614668948, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(0.0)", -0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(1e-10)", -0.50000000009189385333058, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(0.5)", -1.460354508809586812889499, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(1.0-1.0/1024.0)", -1023.4228554489429787, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(1.0+1.0/1048576)", 1.0485765772157343441e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(5.0)", 1.036927755143369926331365, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zeta_e", "(25.5)", 1.000000021074106110269959, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(0.5)", -2.460354508809586812889499, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(2.0)", 0.64493406684822643647, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(3.0)", 0.20205690315959428540, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(5.0)", 0.0369277551433699263314, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(9.5)", 0.0014125906121736622712, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(10.5)", 0.000700842641736155219500, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(12.5)", 0.000173751733643178193390, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(13.5)", 0.000086686727462338155188, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(15.5)", 0.000021619904246069108133, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(16.5)", 0.000010803124900178547671, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::zetam1_e", "(25.5)", 0.000000021074106110269959, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(2, 1.0)", 1.6449340668482264365, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(2, 10.0)", 0.1051663356816857461, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(5, 1.0)", 1.0369277551433699263, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(5, 10.0)", 0.000030413798676470276, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(9, 0.1)", 1.0000000004253980e+09, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(30, 0.5)", 1.0737418240000053e+09, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(30, 0.9)", 2.3589824880264765e+01, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hzeta_e", "(75, 0.25)", 1.4272476927059599e+45, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "(-91)", -4.945598888750002040e+94, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "(-51)", -4.363969073121683116e+40, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "(-5)", 0.25, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "(-1)", 0.25, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "( 0)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "( 5)", 0.9721197704469093059, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "( 6)", 0.9855510912974351041, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "( 20)", 0.9999990466115815221, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_int_e", "( 1000)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "(-51.5)", -1.2524184036924703656e+41, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "(-5)", 0.25, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "(0.5)", 0.6048986434216303702, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "(0.999)", 0.6929872789683383574, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "(1.0)", 0.6931471805599453094, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "(1.0+1.0e-10)", 0.6931471805759321998, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "( 5)", 0.9721197704469093059, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "( 5.2)", 0.9755278712546684682, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "( 6)", 0.9855510912974351041, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::eta_e", "( 20)", 0.9999990466115815221, TEST_TOL0, GSL::SUCCESS) gsl-1.15.3/tests/sf/test_hyperg.rb0000755000175000017500000011240012220252463016377 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT TEST_SF(s, "GSL::Sf::hyperg_0F1_e", "(1, 0.5)", 1.5660829297563505373, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_0F1_e", "(5, 0.5)", 1.1042674404828684574, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_0F1_e", "(100, 30)", 1.3492598639485110176, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_0F1_e", "(-0.5, 3)", -39.29137997543434276, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_0F1_e", "(-100.5, 50)", 0.6087930289227538496, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_0F1_e", "(1, -5.0)", -0.3268752818235339109, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_0F1_e", "(-0.5, -5.0)",-4.581634759005381184, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(1, 1, 0.5)", 1.6487212707001281468, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(1, 2, 500.0)", 2.8071844357056748215e+214, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(1, 2, -500.0)", 0.002, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(8, 1, 0.5)", 13.108875178030540372, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 1, 1.0)", 131.63017574352619931, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 1, 10.0)", 8.514625476546280796e+09, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 1, 100.0)", 1.5671363646800353320e+56, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 20, 1.0)", 1.6585618002669675465, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 20, 10.0)", 265.26686430340188871, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 20, 100.0)", 3.640477355063227129e+34, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, 1.0)", 1.1056660194025527099, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, 10.0)", 2.8491063634727594206, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, 40.0)", 133.85880835831230986, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, 80.0)", 310361.16228011433406, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, 100.0)", 8.032171336754168282e+07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, 500.0)", 7.633961202528731426e+123, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 1, 1.0)", 6.892842729046469965e+07, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 1, 10.0)", 2.4175917112200409098e+28, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 1, 100.0)", 1.9303216896309102993e+110, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 200, 1.0)", 1.6497469106162459226, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 200, 10.0)", 157.93286197349321981, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 200, 100.0)", 2.1819577501255075240e+24, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 200, 400.0)", 3.728975529926573300e+119, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 400, 10.0)", 12.473087623658878813, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 400, 100.0)", 9.071230376818550241e+11, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 400, 150.0)", 7.160949515742170775e+18, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 400, 200.0)", 2.7406690412731576823e+26, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 400, 300.0)", 6.175110613473276193e+43, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 400, 400.0)", 1.1807417662711371440e+64, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 400, 600.0)", 2.4076076354888886030e+112, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 1, -1.0)", 0.11394854824644542810, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 1, -10.0)", 0.0006715506365396127863, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 1, -100.0)", -4.208138537480269868e-32, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 50, -1.0)", 0.820006196079380, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, -10.0)", 0.38378859043466243, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, -100.0)", 0.0008460143401464189061, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, -500.0)", 1.1090822141973655929e-08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(10, 100, -10000.0)", 5.173783508088272292e-21, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(50, 1, -90.0)", -1.6624258547648311554e-21, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(50, 1, -100.0)", 4.069661775122048204e-24, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(50, 1, -110.0)", 1.0072444993946236025e-25, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 10, -100.0)", -2.7819353611733941962e-37, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 1, -90.0)", 7.501705041159802854e-22, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 1, -100.0)", 6.305128893152291187e-25, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 1, -110.0)", -7.007122115422439755e-26, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(100, 10, -100.0)", -2.7819353611733941962e-37, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(200, 50, -1.0)", 0.016087060191732290813, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(200, 50, -300.0)", -4.294975979706421471e-121, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(200, 100, -1.0)", 0.13397521083325179687, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(200, 100, -10.0)", 5.835134393749807387e-10, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(200, 100, -100.0)", 4.888460453078914804e-74, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(200, 100, -500.0)", -1.4478509059582015053e-195, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-1, 1, 2.0)", -1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-1, -2, 2.0)", 2.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-2, -3, 2.0)", 3.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, 1, 1.0)", 0.4189459325396825397, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, 1, 10.0)", 27.984126984126984127, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, 1, 100.0)", 9.051283795429571429e+12, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-100, 20, 1.0)", 0.0020203016320697069566, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -20, 1.0)", 1.6379141878548080173, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -20, 10.0)", 78.65202404521289970, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -20, 100.0)", 4.416169713262624315e+08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -100, 1.0)", 1.1046713999681950919, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -100, 10.0)", 2.6035952191039006838, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -100, 100.0)", 1151.6852040836932392, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-100, -200, 1.0)", 1.6476859702535324743, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-100, -200, 10.0)", 139.38026829540687270, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-100, -200, 100.0)", 1.1669433576237933752e+19, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -20, -1.0)", 0.6025549561148035735, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -20, -10.0)", 0.00357079636732993491, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -20, -100.0)", 1.64284868563391159e-35, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -100, -1.0)", 0.90442397250313899, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -100, -10.0)", 0.35061515251367215, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-10, -100, -100.0)", 8.19512187960476424e-09, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-100, -200, -1.0)", 0.6061497939628952629, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-100, -200, -10.0)", 0.0063278543908877674, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_int_e", "(-100, -200, -100.0)", 4.34111795007336552e-25, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, 1)", 2.0300784692787049755, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, 10)", 6172.859561078406855, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, 100)", 2.3822817898485692114e+42, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, 500)", 5.562895351723513581e+215, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1.5, 2.5, 1)", 1.8834451238277954398, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1.5, 2.5, 10)", 3128.7352996840916381, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 1.1, 1)", 110.17623733873889579, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 1.1, 10)", 6.146657975268385438e+09, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 1.1, 100)", 9.331833897230312331e+55, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 1.1, 500)", 4.519403368795715843e+235, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 50.1, 2)", 1.5001295507968071788, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 50.1, 10)", 8.713385849265044908, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 50.1, 100)", 5.909423932273380330e+18, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 50.1, 500)", 9.740060618457198900e+165, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, 1)", 5.183531067116809033e+07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, 10)", 1.6032649110096979462e+28, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, 100)", 1.1045151213192280064e+110, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 50.1, 1)", 7.222953133216603757, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 50.1, 10)", 1.0998696410887171538e+08, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 50.1, 100)", 7.235304862322283251e+63, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, -1)", 0.5380795069127684191, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, -10)", 0.05303758099290164485, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, -100)", 0.005025384718759852803, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.5, -500)", 0.0010010030151059555322, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(1, 1.1, -500)", 0.00020036137599690208265, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 1.1, -1)", 0.07227645648935938168, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 1.1, -10)", 0.0003192415409695588126, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(10, 1.1, -500)", -3.400379216707701408e-23, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(50, 1.1, -100)", 4.632883869540640460e-24, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(50, 1.1, -110.0)", 5.642684651305310023e-26, 0.03, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -1)", 0.0811637344096042096, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -10)", 0.00025945610092231574387, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -50)", 2.4284830988994084452e-13, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -90)", 2.4468224638378426461e-22, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -99)", 1.0507096272617608461e-23, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -100)", 1.8315497474210138602e-24, TEST_TOL2, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -101)", -2.3916306291344452490e-24, 0.04, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 1.1, -110)", -4.517581986037732280e-26, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, 10.1, -220)", -4.296130300021696573e-64, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10, -10.1, 10.0)", 10959.603204633058116, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10, -10.1, 1000.0)", 2.0942691895502242831e+23, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10, -100.1, 10.0)", 2.6012036337980078062, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-1000, -1000.1, 10.0)", 22004.341698908631636, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-1000, -1000.1, 200.0)", 7.066514294896245043e+86, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-8.1, -10.1, -10.0)", 0.00018469685276347199258, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10, -5.1, 1)", 16.936141866089601635, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10, -5.1, 10)", 771534.0349543820541, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10, -5.1, 100)", 2.2733956505084964469e+17, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, -50.1, -1)", 0.13854540373629275583, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, -50.1, -10)", -9.142260314353376284e+19, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, -50.1, -100)", -1.7437371339223929259e+87, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, -50.1, 1)", 7.516831748170351173, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, -50.1, 10)", 1.0551632286359671976e+11, TEST_SQRT_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, -50.1, 50)", -7.564755600940346649e+36, TEST_TOL3, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, -50.1, 100)", 4.218776962675977e+55, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10.5, -8.1, 0.1)", 1.1387201443786421724, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-10.5, -11.1, 1)", 2.5682766147138452362, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100.5, -80.1, 10)", 355145.4517305220603, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100.5, -102.1, 10)", 18678.558725244365016, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100.5, -500.1, 10)", 7.342209011101454, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100.5, -500.1, 100)", 1.2077443075367177662e+8, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-500.5, -80.1, 2)", 774057.8541325341699, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, -10.1, 1)", -2.1213846338338567395e+12, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, -10.1, 10)", -6.624849346145112398e+39, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, -10.1, 100)", -1.2413466759089171904e+129, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, -10.1, -1)", 34456.29405305551691, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, -10.1, -10)", -7.809224251467710833e+07, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(100, -10.1, -100)", -5.214065452753988395e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 1.1, 1)", 0.21519810496314438414, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 1.1, 10)", 8.196123715597869948, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 1.1, 100)", -1.4612966715976530293e+20, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 20.1, 1)", 0.0021267655527278456412, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 20.1, 10)", 2.0908665169032186979e-11, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 20.1, 100)", -0.04159447537001340412, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 1.1, -1)", 2.1214770215694685282e+07, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 1.1, -10)", 1.0258848879387572642e+24, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 1.1, -100)", 1.1811367147091759910e+67, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 50.1, -1)", 6.965259317271427390, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 50.1, -10)", 1.0690052487716998389e+07, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-100, 50.1, -100)", 6.889644435777096248e+36, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_1F1_e", "(-2.05, 1.0, 5.05)", 3.79393389516785e+00, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 1, 0.0001)", 8.634088070212725330, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 1, 0.01)", 4.078511443456425847, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 1, 0.5)", 0.9229106324837304688, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 1, 2.0)", 0.3613286168882225847, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 1, 100)", 0.009901942286733018406, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 1, 1000)", 0.0009990019940238807150, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 8, 0.01)", 7.272361203006010000e+16, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 8, 1)", 1957.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 8, 5)", 1.042496, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 8, 8)", 0.3207168579101562500, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 8, 50)", 0.022660399001600000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 8, 100)", 0.010631236727200000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 8, 1000)", 0.0010060301203607207200, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 20, 1)", 1.7403456103284421000e+16, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 20, 20)", 0.22597813610531052969, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 50, 1)", 3.374452117521520758e+61, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 50, 50)", 0.15394136814987651785, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 100, 0.1)", 1.0418325171990852858e+253, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 100, 1)", 2.5624945006073464385e+154, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 100, 50)", 3.0978624160896431391e+07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 100, 100)", 0.11323192555773717475, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 100, 200)", 0.009715680951406713589, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 100, 1000)", 0.0011085142546061528661, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, 1000, 2000)", 0.0009970168547036318206, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -1, 1)", 0.29817368116159703717, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -1, 10)", 0.07816669698940409380, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -10, 1)", 0.08271753756946041959, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -10, 5)", 0.06127757419425055261, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -10, 10)", 0.04656199948873187212, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -10, 20)", 0.031606421847946077709, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -100, 0.01)", 0.009900000099999796950, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -100, 1)", 0.009802970197050404429, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -100, 10)", 0.009001648897173103447, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -100, 20)", 0.008253126487166557546, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -100, 50)", 0.006607993916432051008, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -100, 90)", 0.005222713769726871937, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -100, 110)", 0.004727658137692606210, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(1, -1000, 1010)", 0.0004971408839859245170, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(8, 1, 0.001)", 0.0007505359326875706975, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(8, 1, 0.5)", 6.449509938973479986e-06, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(8, 1, 8)", 6.190694573035761284e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(8, 1, 20)", 3.647213845460374016e-12, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(8, 8, 1)", 0.12289755012652317578, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(8, 8, 10)", 5.687710359507564272e-09, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(8, 8, 20)", 2.8175404594901039724e-11, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(100, 100, 0.01)", 1.0099979491941914867e+196, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(100, 100, 0.1)", 1.0090713562719862833e+97, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(100, 100, 1)", 0.009998990209084729106, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(100, 100, 20)", 1.3239363905866130603e-131, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 1, 0.01)", 3.274012540759009536e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 1, 1)", 1.5202710000000000000e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 1, 10)", 1.0154880000000000000e+08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 1, 100)", 3.284529863685482880e+19, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 10, 1)", 1.1043089864100000000e+11, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 100, 1)", 1.3991152402448957897e+20, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 100, 10)", 5.364469916567136000e+19, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 100, 100)", 3.909797568000000000e+12, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-10, 100, 500)", 8.082625576697984130e+25, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, 1, 0.01)", 1.6973422555823855798e+64, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, 1, 1)", 7.086160198304780325e+63, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, 1, 10)", 5.332862895528712200e+65, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, 10, 1)", -7.106713471565790573e+71, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, 100, 1)", 2.4661377199407186476e+104, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, 10, 10)", 5.687538583671241287e+68, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, 100, 10)", 1.7880761664553373445e+102, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-90, 1, 0.01)", 4.185245354032917715e+137, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-90, 1, 0.1)", 2.4234043408007841358e+137, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-90, 1, 10)", -1.8987677149221888807e+139, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-90, 10, 10)", -5.682999988842066677e+143, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-90, 100, 10)", 2.3410029853990624280e+189, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-90, 1000, 10)", 1.9799451517572225316e+271, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, -1, 10)", -9.083195466262584149e+64, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, -10, 10)", -1.4418257327071634407e+62, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, -100, 0.01)", 3.0838993811468983931e+93, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-50, -100, 10)", 4.014552630378340665e+95, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-100, -100, 10)", 2.0556466922347982030e+162, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-100, -200, 10)", 1.1778399522973555582e+219, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_int_e", "(-100, -200, 100)", 9.861313408898201873e+235, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 0.0001, 0.0001)", 1.0000576350699863577, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 0.0001, 1.0)", 0.9999403679233247536, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 0.0001, 100.0)", 0.9995385992657260887, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 1, 0.0001)", 1.0009210608660065989, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 1.0, 1.0)", 0.9999999925484179084, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 10, 1)", 13.567851006281412726, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 10, 10)", 0.9999244381454633265, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 100, 98)", 0.9998517867411840044, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 1000, 999)", 0.9997195294193261604, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.0001, 1000, 1100)", 0.9995342990014584713, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.5, 1000, 800)", 9.103916020464797207e+08, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.5, 1000, 998)", 0.21970269691801966806, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(0.5, 0.5, 1.0)", 0.7578721561413121060, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(1, 0.0001, 0.0001)", 0.9992361337764090785, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(1, 0.0001, 1)", 0.4036664068111504538, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(1, 0.0001, 100)", 0.009805780851264329587, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(1, 1.2, 2.0)", 0.3835044780075602550, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(1, -0.0001, 1)", 0.4036388693605999482, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(8, 10.5, 1)", 27.981926466707438538, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(8, 10.5, 10)", 2.4370135607662056809e-8, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(8, 10.5, 100)", 1.1226567526311488330e-16, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(10, -2.5, 10)", 6.734690720346560349e-14, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(10, 2.5, 10)", 6.787780794037971638e-13, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(10, 2.5, 50)", 2.4098720076596087125e-18, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 1.1, 1)", -3.990841457734147e+6, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 1.1, 10)", 1.307472052129343e+8, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 1.1, 50)", 3.661978424114088e+16, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 1.1, 90)", 8.09469542130868e+19, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 1.1, 99)", 2.546328328942063e+20, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 1.1, 100)", 2.870463201832814e+20, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 1.1, 200)", 8.05143453769373e+23, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 10.1, 0.1)", -3.043016255306515e+20, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 10.1, 1)", -3.194745265896115e+12, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 10.1, 4)", -6.764203430361954e+07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 10.1, 10)", -2.067399425480545e+09, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 10.1, 50)", 4.661837330822824e+14, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 100.4, 10)", -6.805460513724838e+66, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 100.4, 50)", -2.081052558162805e+18, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 100.4, 80)", 2.034113191014443e+14, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 100.4, 100)", 6.85047268436107e+13, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-10.5, 100.4, 200)", 1.430815706105649e+20, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-19.5, 82.1, 10)", 5.464313196201917432e+60, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-50.5, 100.1, 10)", -5.5740216266953e+126, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-50.5, 100.1, 40)", 5.937463786613894e+91, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-50.5, 100.1, 50)", -1.631898534447233e+89, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-50.5, 100.1, 70)", 3.249026971618851e+84, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_U_e", "(-50.5, 100.1, 100)", 1.003401902126641e+85, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1, 1, 1, 0.5)", 2.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, 8, 1, 0.5)", 12451584.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, -8, 1, 0.5)", 0.13671875, TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, -8.1, 1, 0.5)", 0.14147385378899930422, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, -8, 1, -0.5)", 4945.136718750000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, -8, -5.5, 0.5)", -906.6363636363636364, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, -8, -5.5, -0.5)", 24565.363636363636364, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, 8, 1, -0.5)", -0.006476312098196747669, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, 8, 5, 0.5)", 4205.714285714285714, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(8, 8, 5, -0.5)", 0.0028489656290296436616, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, 1, 0.99)", 1.2363536673577259280e+38 , TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -1.5, 0.99)", 3.796186436458346579e+46, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -1.5, -0.99)", 0.14733409946001025146, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -8.5, 0.99)", -1.1301780432998743440e+65, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -8.5, -0.99)", -8.856462606575344483, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -21.5, 0.99)", 2.0712920991876073253e+95, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -21.5, -0.99)", -74.30517015382249216, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -100.5, 0.99)", -3.186778061428268980e+262, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(9, 9, -100.5, -0.99)", 2.4454358338375677520, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(25, 25, 1, -0.5)", -2.9995530823639545027e-06, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, 1.0-1.0/64.0)", 3.17175539044729373926, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, 1.0-1.0/128.0)", 3.59937243502024563424, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, 1.0-1.0/256.0)", 4.03259299524392504369, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, 1.0-1.0/1024.0)", 4.90784159359675398250, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, 1.0-1.0/65536.0)", 7.552266033399683914, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, 1.0-1.0/16777216.0)", 11.08235454026043830363, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, -1.0+1.0/1024.0)", 0.762910940909954974527, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, -1.0+1.0/65536.0)", 0.762762124908845424449, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_e", "(1.5, 0.5, 2.0, -1.0+1.0/1048576.0)", 0.762759911089064738044, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_e", "(1, 1, 1, 0.5)", 3.352857095662929028, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_e", "(8, 8, 1, 0.5)", 1.7078067538891293983e+09, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_e", "(8, 8, 5, 0.5)", 285767.15696901140627, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_e", "(8, 8, 1, -0.5)", 0.007248196261471276276, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_e", "(8, 8, 5, -0.5)", 0.00023301916814505902809, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_e", "(25, 25, 1, -0.5)", 5.1696944096e-06, TEST_SQRT_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_2F0_e", "(0.01, 1.0, -0.02)", 0.999803886708565 , TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_2F0_e", "(0.1, 0.5, -0.02)", 0.999015947934831 , TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_2F0_e", "(1, 1, -0.02)", 0.980755496569062 , TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_2F0_e", "(8, 8, -0.02)", 0.3299059284994299 , TEST_TOL0, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::hyperg_2F0_e", "(50, 50, -0.02)", 2.688995263773233e-13, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(1, 1, 1, 0.5)", 2.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(8, 8, 1, 0.5)", 12451584.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(8, -8, 1, 0.5)", 0.13671875, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(8, -8, 1, -0.5)", 4945.13671875, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(8, -8, -5.5, 0.5)", -83081.19167659493609, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(8, -8, -5.5, -0.5)", 2.2510895952730178518e+06, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(8, 8, 5, 0.5)", 175.2380952380952381, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(9, 9, -1.5, 0.99)", 1.6063266334913066551e+46, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(9, 9, -1.5, -0.99)", 0.06234327316254516616, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(5, 5, -1, 0.5)", 4949760.0, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(5, 5, -10, 0.5)", 139408493229637632000.0, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_renorm_e", "(5, 5, -100, 0.5)", 3.0200107544594411315e+206, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_renorm_e", "(9, 9, -1.5, 0.99)", 5.912269095984229412e+49, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_renorm_e", "(9, 9, -1.5, -0.99)", 0.10834020229476124874, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_renorm_e", "(5, 5, -1, 0.5)", 1.4885106335357933625e+08, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_renorm_e", "(5, 5, -10, 0.5)", 7.968479361426355095e+21, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hyperg_2F1_conj_renorm_e", "(5, 5, -100, 0.5)", 3.1113180227052313057e+208, TEST_TOL3, GSL::SUCCESS) gsl-1.15.3/tests/sf/test_coulomb.rb0000755000175000017500000000204412220252463016543 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT TEST_SF(s, "GSL::Sf::hydrogenicR_1_e", "(3.0, 2.0)", 0.025759948256148471036, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hydrogenicR_1_e", "(3.0, 10.0)", 9.724727052062819704e-13, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hydrogenicR_e", "(4, 0, 3.0, 2.0)", -0.03623182256981820062, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hydrogenicR_e", "(4, 1, 3.0, 2.0)", -0.028065049083129581005, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hydrogenicR_e", "(4, 2, 3.0, 2.0)", 0.14583027278668431009, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hydrogenicR_e", "(100, 0, 3.0, 2.0)", -0.00007938950980052281367, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hydrogenicR_e", "(100, 10, 3.0, 2.0)", 7.112823375353605977e-12, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::hydrogenicR_e", "(100, 90, 3.0, 2.0)", 5.845231751418131548e-245, TEST_TOL2, GSL::SUCCESS) gsl-1.15.3/tests/sf/gsl_test_sf.rb0000755000175000017500000001715312220252463016367 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Math module GSL module Test module Sf TEST_TOL0 = 2.0*GSL::DBL_EPSILON TEST_TOL1 = 16.0*GSL::DBL_EPSILON TEST_TOL2 = 256.0*GSL::DBL_EPSILON TEST_TOL3 = 2048.0*GSL::DBL_EPSILON TEST_TOL4 = 16384.0*GSL::DBL_EPSILON TEST_TOL5 = 131072.0*GSL::DBL_EPSILON TEST_TOL6 = 1048576.0*GSL::DBL_EPSILON TEST_SQRT_TOL0 = 2.0*GSL::SQRT_DBL_EPSILON TEST_SNGL = 1.0e-06 TEST_SF_INCONS = 1 TEST_SF_ERRNEG = 2 TEST_SF_TOLBAD = 4 TEST_SF_RETBAD = 8 TEST_FACTOR = 100.0 TEST_SIGMA = 1.5 def test_sf_frac_diff(x1, x2) if x1.zero? and x2.zero? return 0.0 elsif x1 <= DBL_MAX and x2 < DBL_MAX and (x1 + x1 != 0.0) return ((x1 - x2)/(x1 + x2)).abs else return 1.0 end end def test_sf_check_result(mbuf, r, val, tol) s = 0 f = 0.0 if isnan?(r.val) or isnan?(val) s = isnan(r.val) != isnan(val) ? TEST_SF_INCONS : s elsif isinf?(r.val) or isinf?(val) s = isinf(r.val) != isinf(val) ? TEST_SF_INCONS : s else f = test_sf_frac_diff(val, r.val) if (val - r.val).abs > 2.0*TEST_SIGMA*r.err s |= TEST_SF_INCONS end if r.err < 0.0 s |= TEST_SF_ERRNEG end if f > TEST_FACTOR * tol s |= TEST_SF_TOLBAD end end if s != 0 message = sprintf(" expected: %20.16g\n", val) mbuf += message message = sprintf(" obtained: %20.16g %20.16g %g\n", r.val, r.err, r.err/(r.val.abs + r.err)) mbuf += message message = sprintf(" fracdiff: %20.16g\n", f) mbuf += message end if s & TEST_SF_INCONS mbuf += " value/expected not consistent within reported error\n" end if s & TEST_SF_ERRNEG mbuf += " reported error negative\n" end if s & TEST_SF_TOLBAD mbuf += " value not within tolerance of expected value\n" end return s, mbuf end def test_sf_check_val(mbuf, rval, val, tol) s = 0; f = test_sf_frac_diff(val, rval) if f > TEST_FACTOR * tol s |= TEST_SF_TOLBAD end if s != 0 buf = sprintf(" expected: %20.16g\n", val) mbuf += buf buf = sprintf(" obtained: %20.16g\n", rval) mbuf += buf buf = sprintf(" fracdiff: %20.16g\n", f) mbuf += buf end if s & TEST_SF_TOLBAD mbuf += " value not within tolerance of expected value\n" end return s, mbuf end def test_sf_check_result_relax(mbuf, r, val, tol) s = 0; f = test_sf_frac_diff(val, r.val) if f > GSL_MAX_DBL(TEST_SNGL, TEST_FACTOR * tol) s |= TEST_SF_INCONS end if r.err < 0.0 s |= TEST_SF_ERRNEG end if f > TEST_FACTOR * tol s |= TEST_SF_TOLBAD end if s != 0 buf = sprintf(" expected: %20.16g\n", val) mbuf += buf buf = sprintf(" obtained: %20.16g %20.16g %g\n", r.val, r.err, r.err/(r.val.abs + r.err)) mbuf += buf buf = sprintf(" fracdiff: %20.16g\n", f) mbuf += buf end if s & TEST_SF_INCONS mbuf += " value/expected not consistent MAX(tol,SINGLE_PREC)\n" end if s & TEST_SF_ERRNEG mbuf += " reported error negative\n" end if s & TEST_SF_TOLBAD mbuf += " value not within tolerance of expected value\n" end return s, mbuf end def test_sf_check_return(mbuf, val, expected) if val != expected buf = sprintf(" unexpected return code: %d\n", val) mbuf += buf return TEST_SF_RETBAD, mbuf else return 0, mbuf end end def test_sf(r, val, tol, status, expect, desc) local_s = 0 mbuf = "" s, mbuf = test_sf_check_result(mbuf, r, val, tol) local_s |= s s, mbuf = test_sf_check_return(mbuf, status, expect) local_s |= s GSL::Test::test(local_s, desc) if local_s != 0 print(mbuf) printf(" %22.18g %22.18g\n", r.val, r.err) end return local_s end def test_sf_val(val, val_in, tol, desc) local_s = 0 mbuf = "" s, mbuf = test_sf_check_val(mbuf, val, val_in, tol) local_s |= s GSL::Test::test(local_s, desc) if local_s != 0 printf("%s", mbuf) printf(" %22.18g\n", val) end return local_s end def test_sf_rlx(r, val_in, tol, status, expect_return, desc) local_s = 0 message_buff = "" s, message_buff = test_sf_check_result_relax(message_buff, r, val_in, tol) local_s |= s s, message_buff = test_sf_check_return(message_buff, status, expect_return) local_s |= s GSL::Test::test(local_s, desc) if local_s != 0 printf("%s", message_buff) printf(" %22.18g %22.18g\n", r.val, r.err) end return local_s end def test_sf_2(r1, val1, tol1, r2, val2, tol2, status, expect_return, desc) int local_s = 0 message_buff = "" s, message_buff = test_sf_check_result(message_buff, r1, val1, tol1) local_s |= s s, message_buff = test_sf_check_result(message_buff, r2, val2, tol2) local_s |= s s, message_buff = test_sf_check_return(message_buff, status, expect_return) local_s |= s GSL::Test::test(local_s, desc) if local_s != 0 printf("%s", message_buff) printf(" %22.18g %22.18g\n", r1.val, r1.err) printf(" %22.18g %22.18g\n", r2.val, r2.err) end return local_s end def test_sf_sgn(r, sgn, val_in, tol, expect_sgn, status, expect_return, desc) local_r local_s = 0 message_buff = "" local_r.val = sgn local_r.err = 0.0 s, message_buff = test_sf_check_result(message_buff, r, val_in, tol) local_s |= s s, message_buff = test_sf_check_result(message_buff, local_r, expect_sgn, 0.0) local_s |= s s, message_buff = test_sf_check_return(message_buff, status, expect_return) local_s |= s GSL::Test::test(local_s, desc) if local_s != 0 printf("%s", message_buff) printf(" %22.18g %22.18g\n", r.val, r.err) end return local_s end def TEST_SF(stat, func, args, val_in, tol, expect_return) r, = eval("#{func}#{args}") # p r # p val_in status = 0 stat += test_sf(r, val_in, tol, status, expect_return, "#{func}#{args}") return stat end def TEST_SF_2(stat, func, args, val1, tol1, val2, tol2, expect_return) r, = eval("#{func}#{args}") status = 0 stat += test_sf_2(r1, val1, tol1, r2, val2, tol2, status, expect_return, "#{func}#{args}") return stat end def TEST_SF_SGN(stat, func, args, val_in, tol, expect_sgn, expect_return) r, = eval("#{func}#{args}") status = 0 stat += test_sf_sgn(r, sgn, val_in, tol, expect_sgn, status, expect_return, "#{func}#{args}") return stat end end end end gsl-1.15.3/tests/sf/test_gamma.rb0000755000175000017500000004702012220252463016170 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT TEST_SF(s, "GSL::Sf::lngamma_e", "(-0.1)", 2.368961332728788655 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(-1.0/256.0)", 5.547444766967471595 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(1.0e-08)", 18.420680738180208905 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(0.1)", 2.252712651734205 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(1.0 + 1.0/256.0)", -0.0022422226599611501448 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(2.0 + 1.0/256.0)", 0.0016564177556961728692 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(100.0)", 359.1342053695753 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(-1.0-1.0/65536.0)", 11.090348438090047844 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(-1.0-1.0/268435456.0)", 19.408121054103474300 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(-100.5)", -364.9009683094273518 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lngamma_e", "(-100-1.0/65536.0)", -352.6490910117097874 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(1.0 + 1.0/4096.0)", 0.9998591371459403421 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(1.0 + 1.0/32.0)", 0.9829010992836269148 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(2.0 + 1.0/256.0)", 1.0016577903733583299 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(9.0)", 40320.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(10.0)", 362880.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(100.0)", 9.332621544394415268e+155 , TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(170.0)", 4.269068009004705275e+304 , TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(171.0)", 7.257415615307998967e+306 , TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(-10.5)", -2.640121820547716316e-07 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_e", "(-1.0+1.0/65536.0)", -65536.42280587818970 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(1.0e-08)", 3989.423555759890865 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(1.0e-05)", 126.17168469882690233 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(0.001)", 12.708492464364073506 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(1.5)", 1.0563442442685598666 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(3.0)", 1.0280645179187893045 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(9.0)", 1.0092984264218189715 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(11.0)", 1.0076024283104962850 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(100.0)", 1.0008336778720121418 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(1.0e+05)", 1.0000008333336805529 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammastar_e", "(1.0e+20)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(1.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(2.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(3.0)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(4.0)", 1.0/6.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(10.0)", 1.0/362880.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(100.0)", 1.0715102881254669232e-156, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(0.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(-1.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(-2.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(-3.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(-4.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(-10.5)", -1.0/2.640121820547716316e-07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(-11.25)", 1.0/6.027393816261931672e-08, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gammainv_e", "(-1.0+1.0/65536.0)", -1.0/65536.42280587818970 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(10, 1.0/1048576.0)", 1.7148961854776073928e-67 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(10, 1.0/1024.0)", 2.1738891788497900281e-37 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(10, 1.0)", 2.7557319223985890653e-07 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(10, 5.0)", 2.6911444554673721340 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(10, 500.0)", 2.6911444554673721340e+20 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(100, 100.0)", 1.0715102881254669232e+42 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(1000, 200.0)", 2.6628790558154746898e-267 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::taylorcoeff_e", "(1000, 500.0)", 2.3193170139740855074e+131 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fact_e", "(0)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fact_e", "(1)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fact_e", "(7)", 5040.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::fact_e", "(33)", 8.683317618811886496e+36 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::doublefact_e", "(0)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::doublefact_e", "(1)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::doublefact_e", "(7)", 105.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::doublefact_e", "(33)", 6.332659870762850625e+18 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnfact_e", "(0)", 0.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnfact_e", "(1)", 0.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnfact_e", "(7)", 8.525161361065414300 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnfact_e", "(33)", 85.05446701758151741 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lndoublefact_e", "(0)", 0.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lndoublefact_e", "(7)", 4.653960350157523371 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lndoublefact_e", "(33)", 43.292252022541719660 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lndoublefact_e", "(34)", 45.288575519655959140 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lndoublefact_e", "(1034)", 3075.6383796271197707 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lndoublefact_e", "(1035)", 3078.8839081731809169 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnchoose_e", "(7,3)", 3.555348061489413680 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnchoose_e", "(5,2)", 2.302585092994045684 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(7,3)", 35.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(7,4)", 35.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(5,2)", 10.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(5,3)", 10.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(500,495)", 255244687600.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(500,5)", 255244687600.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(500,200)", 5.054949849935532221e+144 , TEST_TOL5, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::choose_e", "(500,300)", 5.054949849935532221e+144 , TEST_TOL5, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnpoch_e", "(5, 1.0/65536.0)", 0.000022981557571259389129, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnpoch_e", "(5, 1.0/256.0)", 0.005884960217985189004, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnpoch_e", "(7,3)", 6.222576268071368616, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnpoch_e", "(5,2)", 3.401197381662155375, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::poch_e", "(7,3)", 504.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::poch_e", "(5,2)", 30.0 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::poch_e", "(5,1.0/256.0)", 1.0059023106151364982 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pochrel_e", "(7,3)", 503.0/3.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pochrel_e", "(5,2)", 29.0/2.0, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pochrel_e", "(5,0.01)", 1.5186393661368275330, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pochrel_e", "(-5.5,0.01)", 1.8584945633829063516, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pochrel_e", "(-5.5,-1.0/8.0)", 1.0883319303552135488, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pochrel_e", "(-5.5,-1.0/256.0)", 1.7678268037726177453, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::pochrel_e", "(-5.5,-11.0)", 0.09090909090939652475, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(0.001, 1.0)", 0.9997803916424144436, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(0.001, 10.0)", 0.9999999958306921828, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(1.0, 0.001)", 0.0009995001666250083319, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(1.0, 1.01)", 0.6357810204284766802, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(1.0, 10.0)", 0.9999546000702375151, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(10.0, 10.01)", 0.5433207586693410570, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(10.0, 20.0)", 0.9950045876916924128, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(1000.0, 1000.1)", 0.5054666401440661753, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(1000.0, 2000.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(34.0, 32.0)", 0.3849626436463866776322932129, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(37.0, 3.499999999999999289e+01)", 0.3898035054195570860969333039, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(10, 1e-16)", 2.755731922398588814734648067e-167, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(0.001, 0.001)", 0.006312353291139709793, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(0.001, 1.0)", 0.00021960835758555639171, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(0.001, 2.0)", 0.00004897691783098147880, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(0.001, 5.0)", 1.1509813397308608541e-06, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(1.0, 0.001)", 0.9990004998333749917, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(1.0, 1.01)", 0.3642189795715233198, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(1.0, 10.0)", 0.00004539992976248485154, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(10.0, 10.01)", 0.4566792413306589430, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(10.0, 100.0)", 1.1253473960842733885e-31, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(1000.0, 1000.1)", 0.4945333598559338247, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(1000.0, 2000.0)", 6.847349459614753180e-136, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(100, 99.0)", 0.5266956696005394, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_Q_e", "(200, 199.0)", 0.5188414119121281, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(100, 99.0)", 0.4733043303994607, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_P_e", "(200, 199.0)", 0.4811585880878718, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-1.0/1048576.0, 1.0/1048576.0)", 13.285819596290624271, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.001, 1.0/1048576.0)", 13.381275128625328858, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-1.0, 1.0/1048576.0)", 1.0485617142715768655e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.00001,0.001)", 6.3317681434563592142, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.0001,0.001)", 6.3338276439767189385, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.001, 0.001)", 6.3544709102510843793, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.5, 0.001)", 59.763880515942196981, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-1.0, 0.001)", 992.66896046923884234, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-3.5, 0.001)", 9.0224404490639003706e+09, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-10.5, 0.001)", 3.0083661558184815656e+30, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.001, 0.1)", 1.8249109609418620068, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.5, 0.1)", 3.4017693366916154163, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-10.0, 0.1)", 8.9490757483586989181e+08, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-10.5, 0.1)", 2.6967403834226421766e+09, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.001, 1.0)", 0.21928612679072766340, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.5, 1.0)", 0.17814771178156069019, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-1.0, 1.0)", 0.14849550677592204792, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-2.5, 1.0)", 0.096556648631275160264, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-1.0, 10.0)", 3.8302404656316087616e-07, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.001, 10.0)", 4.1470562324807320961e-06, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-0.5, 10.0)", 1.2609042613241570681e-06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-1.0, 10.0)", 3.8302404656316087616e-07, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-10.5, 10.0)", 6.8404927328441566785e-17, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-100.0, 10.0)", 4.1238327669858313997e-107, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(-200.0, 10.0)", 2.1614091830529343423e-207, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 0.0, 0.001)", 6.3315393641361493320, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 0.001, 0.001)", 6.3087159394864007261, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 1.0, 0.001)", 0.99900049983337499167, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 10.0, 0.001)", 362880.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 0.0, 1.0)", 0.21938393439552027368, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 0.001, 1.0)", 0.21948181320730279613, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 1.0, 1.0)", 0.36787944117144232160, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 10.0, 1.0)", 362879.95956592242045, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(100.0, 1.0)", 9.3326215443944152682e+155, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 0.0, 100.0)", 3.6835977616820321802e-46, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 0.001, 100.0)", 3.7006367674063550631e-46, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 1.0, 100.0)", 3.7200759760208359630e-44, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "( 10.0, 100.0)", 4.0836606309106112723e-26, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::gamma_inc_e", "(100.0, 100.0)", 4.5421981208626694294e+155, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0e-8, 1.0e-8)", 19.113827924512310617 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0e-8, 0.01)", 18.420681743788563403 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0e-8, 1.0)", 18.420680743952365472 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0e-8, 10.0)", 18.420680715662683009 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0e-8, 1000.0)", 18.420680669107656949 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(0.1, 0.1)", 2.9813614810376273949 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(0.1, 1.0)", 2.3025850929940456840 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(0.1, 100.0)", 1.7926462324527931217 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(0.1, 1000)", 1.5619821298353164928 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0, 1.00025)", -0.0002499687552073570, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0, 1.01)", -0.009950330853168082848 , TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(1.0, 1000.0)", -6.907755278982137052 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(100.0, 100.0)", -139.66525908670663927 , TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(100.0, 1000.0)", -336.4348576477366051 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::lnbeta_e", "(100.0, 1.0e+8)", -1482.9339185256447309 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_e", "(1.0, 1.0)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_e", "(1.0, 1.001)", 0.9990009990009990010 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_e", "(1.0, 5.0)", 0.2 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_e", "(1.0, 100.0)", 0.01 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_e", "(10.0, 100.0)", 2.3455339739604649879e-15 , TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(1.0, 1.0, 0.0)", 0.0, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(1.0, 1.0, 1.0)", 1.0, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(0.1, 0.1, 1.0)", 1.0, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 1.0, 1.0, 0.5)", 0.5, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 0.1, 1.0, 0.5)", 0.9330329915368074160, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(10.0, 1.0, 0.5)", 0.0009765625000000000000, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(50.0, 1.0, 0.5)", 8.881784197001252323e-16, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 1.0, 0.1, 0.5)", 0.06696700846319258402, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 1.0, 10.0, 0.5)", 0.99902343750000000000, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 1.0, 50.0, 0.5)", 0.99999999999999911180, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 1.0, 1.0, 0.1)", 0.10, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 1.0, 2.0, 0.1)", 0.19, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 1.0, 2.0, 0.9)", 0.99, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(50.0, 60.0, 0.5)", 0.8309072939016694143, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(90.0, 90.0, 0.5)", 0.5, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "( 500.0, 500.0, 0.6)", 0.9999999999157549630, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(5000.0, 5000.0, 0.4)", 4.518543727260666383e-91, TEST_TOL5, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(5000.0, 5000.0, 0.6)", 1.0, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::beta_inc_e", "(5000.0, 2000.0, 0.6)", 8.445388773903332659e-89, TEST_TOL5, GSL::SUCCESS) gsl-1.15.3/tests/sf/test_bessel.rb0000755000175000017500000007517712220252463016401 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT TEST_SF(s, "GSL::Sf::bessel_J0_e", "(0.1)", 0.99750156206604003230, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_J0_e", "(2.0)", 0.22389077914123566805, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_J0_e", "(100.0)", 0.019985850304223122424, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_J0_e", "(1.0e+10)", 2.1755917502468917269e-06, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_J1_e", "(0.1)", 0.04993752603624199756, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_J1_e", "(2.0)", 0.57672480775687338720, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_J1_e", "(100.0)", -0.07714535201411215803, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_J1_e", "(1.0e+10)", -7.676508175684157103e-06, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(4, 0.1)", 2.6028648545684032338e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(5, 2.0)", 0.007039629755871685484, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(10, 20.0)", 0.18648255802394508321, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(100, 100.0)", 0.09636667329586155967, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(2, 900.0)", -0.019974345269680646400, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(2, 15000.0)", -0.0020455820181216382666, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(0, 1.0e+10)", 2.1755917502468917269e-06, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(1, 1.0e+10)", -7.676508175684157103e-06, TEST_TOL4, GSL::SUCCESS) # TEST_SF(s, "GSL::Sf::bessel_Jn_e", "(0, 20000)", -7.676508175684157103e-06, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y0_e", "(0.1)", -1.5342386513503668441, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y0_e", "(2)", 0.5103756726497451196, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y0_e", "(256.0)", -0.03381290171792454909 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y0_e", "(4294967296.0)", 3.657903190017678681e-06, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y1_e", "(0.1)", -6.45895109470202698800, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y1_e", "(2)", -0.10703243154093754689, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y1_e", "(100.0)", -0.020372312002759793305, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Y1_e", "(4294967296.0)", 0.000011612249378370766284, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Yn_e", "(4, 0.1)", -305832.29793353160319, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Yn_e", "(5, 2)", -9.935989128481974981, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Yn_e", "(100, 100.0)", -0.16692141141757650654, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Yn_e", "(100, 4294967296.0)", 3.657889671577715808e-06, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Yn_e", "(1000, 4294967296.0)", 3.656551321485397501e-06, 2.0e-05, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Yn_e", "(2, 15000.0)", -0.006185217273358617849, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_scaled_e", "(1e-10)", 0.99999999990000000001, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_scaled_e", "(0.1)", 0.90710092578230109640, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_scaled_e", "(2)", 0.30850832255367103953, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_scaled_e", "(100.0)", 0.03994437929909668265, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_scaled_e", "(65536.0)", 0.0015583712551952223537, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I1_scaled_e", "(0.1)", 0.04529844680880932501, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I1_scaled_e", "(2)", 0.21526928924893765916, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I1_scaled_e", "(100.0)", 0.03974415302513025267, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I1_scaled_e", "(65536.0)", 0.0015583593657207350452, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_In_scaled_e", "( -4, 0.1)", 2.3575258620054605307e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_In_scaled_e", "( 4, 0.1)", 2.3575258620054605307e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_In_scaled_e", "( 5, 2.0)", 0.0013297610941881578142, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_In_scaled_e", "( 100, 100.0)", 1.7266862628167695785e-22, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_e", "(0.1)", 1.0025015629340956014, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_e", "(2.0)", 2.2795853023360672674, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I0_e", "(100.0)", 1.0737517071310738235e+42, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I1_e", "(0.1)", 0.05006252604709269211, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I1_e", "(2.0)", 1.59063685463732906340, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_I1_e", "(100.0)", 1.0683693903381624812e+42, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_In_e", "( 4, 0.1)", 2.6054690212996573677e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_In_e", "( 5, 2.0)", 0.009825679323131702321, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_In_e", "( 100, 100.0)", 4.641534941616199114e+21, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K0_scaled_e", "(0.1)", 2.6823261022628943831, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K0_scaled_e", "(2.0)", 0.8415682150707714179, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K0_scaled_e", "(100.0)", 0.1251756216591265789, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K1_scaled_e", "(0.1)", 10.890182683049696574, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K1_scaled_e", "(2.0)", 1.0334768470686885732, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K1_scaled_e", "(100.0)", 0.1257999504795785293, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Kn_scaled_e", "( 4, 0.1)", 530040.2483725626207, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Kn_scaled_e", "( 5, 2.0)", 69.68655087607675118, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Kn_scaled_e", "( 100, 100.0)", 2.0475736731166756813e+19, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K0_e", "(0.1)", 2.4270690247020166125, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K0_e", "(2.0)", 0.11389387274953343565, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K0_e", "(100.0)", 4.656628229175902019e-45, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K1_e", "(0.1)", 9.853844780870606135, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K1_e", "(2.0)", 0.13986588181652242728, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_K1_e", "(100.0)", 4.679853735636909287e-45, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Kn_e", "( 4, 0.1)", 479600.2497925682849, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Kn_e", "( 5, 2.0)", 9.431049100596467443, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Kn_e", "( 100, 100.0)", 7.617129630494085416e-25, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j0_e", "(-10.0)", -0.05440211108893698134, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j0_e", "(0.001)", 0.9999998333333416667, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j0_e", "( 1.0)", 0.84147098480789650670, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j0_e", "( 10.0)", -0.05440211108893698134, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j0_e", "(100.0)", -0.005063656411097587937, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j0_e", "(1048576.0)", 3.1518281938718287624e-07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j1_e", "(-10.0)", -0.07846694179875154709, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j1_e", "(0.01)", 0.003333300000119047399, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j1_e", "( 1.0)", 0.30116867893975678925, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j1_e", "( 10.0)", 0.07846694179875154709, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j1_e", "(100.0)", -0.008673825286987815220, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j1_e", "(1048576.0)", -9.000855242905546158e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j2_e", "(-10.0)", 0.07794219362856244547, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j2_e", "(0.01)", 6.666619047751322551e-06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j2_e", "( 1.0)", 0.06203505201137386110, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j2_e", "( 10.0)", 0.07794219362856244547, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j2_e", "(100.0)", 0.004803441652487953480, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_j2_e", "(1048576.0)", -3.1518539455252413111e-07, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(0, 0.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(1, 10.0)", 0.07846694179875154709000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(5, 1.0)", 0.00009256115861125816357, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(10, 10.0)", 0.06460515449256426427, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(100, 100.0)", 0.010880477011438336539, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(2000, 1048576.0)", 7.449384239168568534e-07, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(2, 900.0)", -0.0011089115568832940086, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_jl_e", "(2, 15000.0)", -0.00005955592033075750554, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y0_e", "(0.001)", -999.99950000004166670, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y0_e", "( 1.0)", -0.5403023058681397174, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y0_e", "( 10.0)", 0.08390715290764524523, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y0_e", "(100.0)", -0.008623188722876839341, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y0_e", "(65536.0)", 0.000011014324202158573930, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y0_e", "(4294967296.0)", 2.0649445131370357007e-10, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y1_e", "( 0.01)", -10000.499987500069444, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y1_e", "( 1.0)", -1.3817732906760362241, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y1_e", "( 10.0)", 0.06279282637970150586, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y1_e", "(100.0)", 0.004977424523868819543, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y1_e", "(4294967296.0)", 1.0756463271573404688e-10, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y2_e", "( 0.01)", -3.0000500012499791668e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y2_e", "( 1.0)", -3.605017566159968955, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y2_e", "( 10.0)", -0.06506930499373479347, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y2_e", "(100.0)", 0.008772511458592903927, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_y2_e", "(4294967296.0)", -2.0649445123857054207e-10, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(0, 0.01)", -99.995000041666528, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(0, 1.0)", -0.54030230586813972, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(1, 10.0)", 0.062792826379701506, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(5, 1.0)", -999.44034339223641, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(10, 0.01)", -6.5473079797378378e+30, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(10, 10.0)", -0.172453672088057849, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(100, 1.0)", -6.6830794632586775e+186, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(100, 100.0)", -0.0229838504915622811, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_yl_e", "(2000, 1048576.0)", 5.9545201447146155e-07, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i0_scaled_e", "(0.1)", 0.9063462346100907067, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i0_scaled_e", "(2.0)", 0.24542109027781645493, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i0_scaled_e", "(100.0)", 0.005000000000000000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i1_scaled_e", "(0.1)", 0.030191419289002226846, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i1_scaled_e", "(2.0)", 0.131868364583275317610, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i1_scaled_e", "(100.0)", 0.004950000000000000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i2_scaled_e", "(0.1)", 0.0006036559400239012567, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i2_scaled_e", "(2.0)", 0.0476185434029034785100, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_i2_scaled_e", "(100.0)", 0.0048515000000000000000, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_il_scaled_e", "( 4, 0.001)", 1.0571434341190365013e-15, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_il_scaled_e", "( 4, 0.1)", 9.579352242057134927e-08, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_il_scaled_e", "( 5, 2.0)", 0.0004851564602127540059, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_il_scaled_e", "( 5, 100.0)", 0.004300446777500000000, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_il_scaled_e", "( 100, 100.0)", 1.3898161964299132789e-23, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k0_scaled_e", "(0.1)", 15.707963267948966192, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k0_scaled_e", "(2.0)", 0.7853981633974483096, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k0_scaled_e", "(100.0)", 0.015707963267948966192, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k1_scaled_e", "(0.1)", 172.78759594743862812, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k1_scaled_e", "(2.0)", 1.1780972450961724644, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k1_scaled_e", "(100.0)", 0.015865042900628455854, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k2_scaled_e", "(0.1)", 5199.335841691107810, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k2_scaled_e", "(2.0)", 2.5525440310417070063, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_k2_scaled_e", "(100.0)", 0.016183914554967819868, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_kl_scaled_e", "( 4, 1.0/256.0)", 1.8205599816961954439e+14, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_kl_scaled_e", "( 4, 1.0/8.0)", 6.1173217814406597530e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_kl_scaled_e", "( 5, 2.0)", 138.10735829492005119, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_kl_scaled_e", "( 100, 100.0)", 3.985930768060258219e+18, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(0.0001, 1.0)", 0.7652115411876708497, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(0.0001, 10.0)", -0.2459270166445205, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(0.0009765625, 10.0)", -0.2458500798634692, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(0.75, 1.0)", 0.5586524932048917478, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(0.75, 10.0)", -0.04968928974751508135, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "( 1.0, 0.001)", 0.0004999999375000026, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "( 1.0, 1.0)", 0.4400505857449335160, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "( 1.75, 1.0)", 0.168593922545763170103, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(30.0, 1.0)", 3.482869794251482902e-42, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(30.0, 100.0)", 0.08146012958117222297, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(10.0, 1.0)", 2.6306151236874532070e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(10.0, 100.0)", -0.05473217693547201474, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(10.2, 100.0)", -0.03548919161046526864, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(2.0, 900.0)", -0.019974345269680646400, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Jnu_e", "(2.0, 15000.0)", -0.0020455820181216382666, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "(0.0001, 1.0)", 0.08813676933044478439, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "(0.0001,10.0)", 0.05570979797521875261, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "( 0.75, 1.0)", -0.6218694174429746383, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "( 0.75, 10.0)", 0.24757063446760384953, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "( 1.0, 0.001)", -636.6221672311394281, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "( 1.0, 1.0)", -0.7812128213002887165, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "(30.0, 1.0)", -3.0481287832256432162e+39, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "(30.0, 100.0)", 0.006138839212010033452, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "(10.0, 1.0)", -1.2161801427868918929e+08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "(10.0, 100.0)", 0.05833157423641492875, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Ynu_e", "(10.2, 100.0)", 0.07169383985546287091, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "(0.0001,10.0)", 0.12783333709581669672, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "( 1.0, 0.001)", 0.0004995003123542213370, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "( 1.0, 1.0)", 0.20791041534970844887, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "(30.0, 1.0)", 1.3021094983785914437e-42, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "(30.0, 100.0)", 0.0004486987756920986146, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "(10.0, 1.0)", 1.0127529864692066036e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "(10.0, 100.0)", 0.024176682718258828365, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_scaled_e", "(10.2, 100.0)", 0.023691628843913810043, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "(0.0001,10.0)", 2815.7166269770030352, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "( 1.0, 0.001)", 0.0005000000625000026042, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "( 1.0, 1.0)", 0.5651591039924850272, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "(30.0, 1.0)", 3.539500588106447747e-42, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "(30.0, 100.0)", 1.2061548704498434006e+40, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "(10.0, 1.0)", 2.7529480398368736252e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "(10.0, 100.0)", 6.498975524720147799e+41, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Inu_e", "(10.2, 100.0)", 6.368587361287030443e+41, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(0.0001,10.0)", 0.3916319346235421817, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "( 1.0, 0.001)", 1000.9967345590684524, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "( 1.0, 1.0)", 1.6361534862632582465, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(30.0, 1.0)", 1.2792629867539753925e+40, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(30.0, 100.0)", 10.673443449954850040, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(10.0, 1.0)", 4.912296520990198599e+08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(10.0, 100.0)", 0.20578687173955779807, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(10.0, 1000.0)", 0.04165905142800565788, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(10.0, 1.0e+8)", 0.00012533147624060789938, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_scaled_e", "(10.2, 100.0)", 0.20995808355244385075, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(0.0001,0.001)", 7.023689431812884141, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(0.0001,10.0)", 0.000017780062324654874306, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "( 1.0, 0.001)", 999.9962381560855743, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "( 1.0, 1.0)", 0.6019072301972345747, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(10.0, 0.001)", 1.8579455483904008064e+38, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(10.0, 1.0)", 1.8071328990102945469e+08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(10.0, 100.0)", 7.655427977388100611e-45, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(10.2, 100.0)", 7.810600225948217841e-45, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(30.0, 1.0)", 4.706145526783626883e+39, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_Knu_e", "(30.0, 100.0)", 3.970602055959398739e-43, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(0.0001,1.0e-100)", 5.439794449319847, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(0.0001,0.0001)", 2.232835507214331, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(0.0001,10.0)", -10.93743282256098, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "( 1.0, 1.0e-100)", 230.2585092994045, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "( 1.0, 1.0e-10)", 23.025850929940456840, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "( 1.0, 0.001)", 6.907751517131146, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "( 1.0, 1.0)", -0.5076519482107523309, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(30.0, 1.0e-100)", 6999.113586185543475, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(30.0, 1.0)", 91.34968784026325464, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(30.0, 100.0)", -97.63224126416760932, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(100.0, 1.0e-100)", 23453.606706185466825, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(100.0, 1.0)", 427.7532510250188083, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(100.0, 100.0)", -55.53422771502921431, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(1000.0, 1.0e-100)", 236856.183755993135, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_lnKnu_e", "(10000.0, 1.0e-100)", 2.39161558914890695e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J0_e", "( 1)", 2.404825557695771, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J0_e", "( 2)", 5.520078110286304, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J0_e", "(20)", 62.048469190227081, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J0_e", "(25)", 77.756025630388058, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J0_e", "(100)", 313.37426607752784, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J1_e", "( 1)", 3.831705970207512, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J1_e", "( 2)", 7.015586669815619, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J1_e", "(20)", 63.61135669848124, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J1_e", "(25)", 79.32048717547630, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_J1_e", "(100)", 314.9434728377672, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(0.0, 1)", 2.404825557695771, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(0.0, 2)", 5.520078110286304, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(0.0, 20)", 62.048469190227081, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(0.0, 25)", 77.756025630388058, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(0.0, 100)", 313.37426607752784, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 1)", 4.4934094579090641, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 1)", 8.7714838159599540, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 2)", 7.7252518369377072, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 2)", 12.338604197466944, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 3)", 10.904121659428900, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 3)", 15.700174079711671, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 4)", 14.066193912831473, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 4)", 18.980133875179921, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 5)", 17.220755271930768, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 5)", 22.217799896561268, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 8.0, 5)", 26.266814641176644, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(20.0, 5)", 41.413065513892636, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 6)", 20.371302959287563, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 6)", 25.430341154222704, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 8.0, 6)", 29.545659670998550, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 7)", 23.519452498689007, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 7)", 28.626618307291138, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 8.0, 7)", 32.795800037341462, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 8)", 26.666054258812674, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 8)", 31.811716724047763, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(10.0, 8)", 38.761807017881651, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 9)", 29.811598790892959, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 9)", 34.988781294559295, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(10.0, 9)", 42.004190236671805, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 1.5, 10)", 32.956389039822477, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 10)", 38.159868561967132, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 10)", 52.017241278881633, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 11)", 41.326383254047406, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 11)", 55.289204146560061, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 12)", 44.4893191232197314, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 12)", 58.5458289043850856, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 13)", 47.6493998066970948, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 13)", 61.7897598959450550, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 14)", 50.8071652030063595, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 14)", 65.0230502510422545, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 15)", 53.9630265583781707, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 15)", 68.2473219964207837, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 16)", 57.1173027815042647, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 16)", 71.4638758850226630, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 17)", 60.2702450729428077, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 17)", 74.6737687121404241, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 18)", 63.4220540458757799, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 18)", 77.8778689734863729, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 19)", 66.5728918871182703, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 19)", 81.0768977206328326, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 20)", 69.722891161716742, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(15.0, 20)", 84.271459069716442, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 23.0, 11)", 65.843393469524653, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 30.0, 11)", 74.797306585175426, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 32.0, 15)", 90.913637691861741, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 50.0, 15)", 113.69747988073942, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 5.0, 22)", 76.020793430591605, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 10.0, 22)", 83.439189796105756, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "( 12.0, 22)", 86.345496520534055, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(100.0, 22)", 199.82150220122519, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::bessel_zero_Jnu_e", "(500.0, 22)", 649.34132440891735, TEST_TOL2, GSL::SUCCESS) gsl-1.15.3/tests/sf/test_dilog.rb0000755000175000017500000000331312220252463016201 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT TEST_SF(s, "GSL::Sf::dilog_e", "(-3.0)", -1.9393754207667089531, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(-0.5)", -0.4484142069236462024, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(-0.001)", -0.0009997501110486510834, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(0.1)", 0.1026177910993911, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(0.7)", 0.8893776242860387386, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(1.0)", 1.6449340668482260, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(1.5)", 2.3743952702724802007, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(2.0)", 2.4674011002723397, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "( 5.0)", 1.7837191612666306277, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "( 11.0)", 0.3218540439999117111, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(12.59)", 0.0010060918167266208634, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(12.595)", 0.00003314826006436236810, TEST_TOL5, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(13.0)", -0.07806971248458575855, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(20.0)", -1.2479770861745251168, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(150.0)", -9.270042702348657270, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::dilog_e", "(1100.0)", -21.232504073931749553, TEST_TOL0, GSL::SUCCESS) gsl-1.15.3/tests/sf/test_legendre.rb0000755000175000017500000005623512220252463016703 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") require("./gsl_test_sf.rb") include GSL::Test include Math include GSL::Test::Sf s = 0 m = GSL::MODE_DEFAULT TEST_SF(s, "GSL::Sf::legendre_P1_e", "(-0.5)", -0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P1_e", "( 0.5)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P2_e", "(0.0)", -0.5 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P2_e", "(0.5)", -0.125, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P2_e", "(1.0)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P2_e", "(100.0)", 14999.5 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P3_e", "( -0.5)", 0.4375, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P3_e", "( 0.5)", -0.4375, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P3_e", "( 1.0)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_P3_e", "(100.0)", 2.49985e+06, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1, -0.5)", -0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1, 1.0e-8)", 1.0e-08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1, 0.5)", 0.5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1, 1.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(10, -0.5)", -0.1882286071777345, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(10, 1.0e-8)", -0.24609374999999864648, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(10, 0.5)", -0.18822860717773437500, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(10, 1.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(99, -0.5)", 0.08300778172138770477, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(99, 1.0e-8)", -7.958923738716563193e-08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(99, 0.5)", -0.08300778172138770477, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(99, 0.999)", -0.3317727359254778874, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(99, 1.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1000, -0.5)", -0.019168251091650277878, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1000, 1.0e-8)", 0.02522501817709828, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1000, 0.5)", -0.019168251091650277878, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(1000, 1.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(4000, -0.5)", -0.009585404456573080972, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(4000, 0.5)", -0.009585404456573080972, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Pl_e", "(4000, 1.0)", 1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 0, -0.5)", -0.18822860717773437500, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 0, 1.0e-08)", -0.24609374999999864648, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 0, 0.5)", -0.18822860717773437500, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 1, -0.5)", -2.0066877394361256516, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 1, 1.0e-08)", -2.7070312499999951725e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 1, 0.5)", 2.0066877394361256516, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 5, -0.5)", -30086.169706116174977, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 5, 1.0e-08)", -0.0025337812499999964949, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 5, 0.5)", 30086.169706116174977, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(10, 5, 0.999)", -0.5036411489013270406, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(100, 5, -0.5)", -6.617107444248382171e+08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(100, 5, 1.0e-08)", 817.8987598063712851, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(100, 5, 0.5)", 6.617107444248382171e+08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Plm_e", "(100, 5, 0.999)", -1.9831610803806212189e+09, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 0, -0.5)", -0.24332702369300133776, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 0, 0.5)", -0.24332702369300133776, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 0, 0.999)", 1.2225754122797385990, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 5, -0.5)", -0.3725739049803293972, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 5, 1.0e-08)", -3.1377233589376792243e-08, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 5, 0.5)", 0.3725739049803293972, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 5, 0.999)", -6.236870674727370094e-06, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 10, -0.5)", 0.12876871185785724117, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 10, 0.5)", 0.12876871185785724117, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(10, 10, 0.999)", 1.7320802307583118647e-14, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(200, 1, -0.5)", 0.3302975570099492931, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(200, 1, 0.5)", -0.3302975570099492931, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_sphPlm_e", "(200, 1, 0.999)", -1.4069792055546256912, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(0.0, -0.5)", 0.8573827581049917129, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(0.0, 0.5)", 0.8573827581049917129, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(0.0, 2.0)", 0.6062611623284649811, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(0.0, 100.0)", 0.07979045091636735635, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(10.0, -0.5)", 5.345484922591867188e+08, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(10.0, 0.5)", 15137.910380385258370, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(10.0, 2.0)", 0.4992680691891618544, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(10.0, 100.0)", -0.07272008163718195685, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(200.0, -1.0e-3)", 1.3347639529084185010e+136, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(200.0, 1.0e-8)", 1.0928098010940058507e+136, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(200.0, 0.5)", 3.895546021611205442e+90, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(200.0, 10.0)", -0.04308567180833581268, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(200.0, 100.0)", -0.04694669186576399194, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(200.0, 1000.0)", 0.023698140704121273277, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(200.0, 1.0e+8)", -0.00006790983312124277891, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(1.0e+8, 1.1)", 1.1599311133054742944, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_half_e", "(1.0e+8, 100.0)", 0.07971967557381557875, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(0.0, -0.5)", 1.7956982494514644808, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(0.0, 0.5)", 0.8978491247257322404, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(0.0, 2.0)", 0.7984204253272901551, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(0.0, 100.0)", 0.4227531369388072584, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(10.0, -0.5)", 5.345484922591867181e+07, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(10.0, 0.5)", 1513.7910356104985334, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(10.0, 2.0)", 0.03439243987215615642, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(10.0, 100.0)", 0.003283756665952609624, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(200.0, -0.5)", 1.7699538115312304280e+179, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(200.0, 1.0e-8)", 5.464049005470029253e+133, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(200.0, 0.5)", 1.9477730108056027211e+88, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(200.0, 10.0)", 0.0012462575917716355362, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(200.0, 100.0)", -0.0003225881344802625149, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(200.0, 1000.0)", -0.00004330652890886567623, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(200.0, 1.0e+8)", 2.0943091278037078483e-07, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(1.0e+8, 1.1)", 2.092320445620989618e-09, 16.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_mhalf_e", "(1.0e+8, 100.0)", -3.359967833599016923e-11, 256.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(0.0, -0.5)", 1.3728805006183501647, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(0.0, 0.5)", 1.0731820071493643751, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(0.0, 2.0)", 0.9012862993604472987, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(0.0, 100.0)", 0.30091748588199264556, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(10.0, -0.5)", 1.6795592815421804669e+08, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(10.0, 0.5)", 4826.034132009618240, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(10.0, 2.0)", 0.18798468917758716146, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(10.0, 100.0)", -0.008622130749987962529, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(200.0, -0.5)", 2.502194818646823e+180, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(1000.0, 100.0)", 0.0017908817653497715844, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(1000.0, 1000.0)", -0.0006566893804926284301, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_0_e", "(1000.0, 1.0e+8)", 2.3167213561756390068e-06, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(0.0, -0.5)", 0.4939371126656998499, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(0.0, 0.5)", 0.14933621085538265636, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(0.0, 2.0)", -0.13666874968871549533, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(0.0, 100.0)", -0.10544528203156629098, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(10.0, -0.5)", 1.7253802958788312520e+09, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(10.0, 0.5)", 46781.02294059967988, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(10.0, 2.0)", 0.26613342643657444400, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(10.0, 100.0)", -0.23281959695501029796, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(200.0, -0.999)", 2.71635193199341135e+270, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(200.0, -0.9)", 4.2952493176812905e+234, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(200.0, -0.5)", 5.01159205956053439e+182, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(200.0, 0.999)", 195733.0396081538, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(200.0, 10.0)", -2.9272610662414349553, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(1000.0, 100.0)", -1.7783258105862399857, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(1000.0, 1000.0)", 0.4535161075156427179, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_1_e", "(1000.0, 1.0e+8)", 0.0009983414549874888478, TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(2, 1.0, -0.5)", 1.6406279287008789526, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(10, 1.0, -0.5)", 0.000029315266725049129448, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(20, 1.0, -0.5)", 7.335769429462034431e-15, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(30, 1.0, -0.5)", 1.3235612394267378871e-26, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(10, 1.0, 0.5)", 2.7016087199857873954e-10, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(20, 1.0, 0.5)", 1.1782569701435933399e-24, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(30, 1.0, 0.5)", 3.636240588303797919e-41, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(10, 1.0, 2.0)", 2.4934929626284934483e-10, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(20, 1.0, 2.0)", 1.1284762488012616191e-24, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_sph_reg_e", "(30, 100.0, 100.0)", -1.6757772087159526048e-64, TEST_TOL6, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(2, 1.0, -0.5)", 2.2048510472375258708, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(10, 1.0, -0.5)", 0.00007335034531618655690, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(20, 1.0, -0.5)", 2.5419860619212164696e-14, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(30, 1.0, -0.5)", 5.579714972260536827e-26, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(10, 1.0, 0.5)", 1.1674078819646475282e-09, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(20, 1.0, 0.5)", 7.066408031229072207e-24, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(30, 1.0, 0.5)", 2.6541973286862588488e-40, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(10, 1.0, 2.0)", 1.0736109751890863051e-09, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(20, 1.0, 2.0)", 6.760965304863386741e-24, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::conicalP_cyl_reg_e", "(30, 100.0, 100.0)", -4.268753482520651007e-63, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1.0e-06, 1.0e-06)", 0.9999999999998333333 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1.0, 0.0)", 1.0 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1.0, 1.0)", 0.7160229153604338713 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1.0, 100.0)", -3.767437313149604566e-44 , TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1.0, 500.0)", -6.665351935878582205e-218, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(100.0, 1.0)", -0.004308757035378200029 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(100.0, 10.0)", 7.508054627912986427e-07 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1000.0, 1.0)", 0.0007036067909088818319 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1.0e+08, 1.0)", 7.927485371429105968e-09 , TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_0_e", "(1.0e+08, 100.0)", -3.627118904186918957e-52 , 32.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0e-06, 1.0e-06)", 3.333333333334222222e-07, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0, 1.0e-10)", 4.714045207910316829e-11, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0, 1.0)", 0.3397013994799344639, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0, 100.0)", -7.200624449531811272e-44, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0, 500.0)", 4.192260336821728677e-218, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(100.0, 0.01)", 0.30117664944267412324 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(100.0, 1.0)", -0.007393833425336299309 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(100.0, 10.0)", -5.031062029821254982e-07 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1000.0, 0.001)", 0.30116875865090396421 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1000.0, 1.0)", -0.0004776144516074971885 , TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0e+08, 1.0e-08)", 0.30116867893975679722 , TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0e+08, 1.0)", 3.0921097047369081582e-09, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_1_e", "(1.0e+08, 100.0)", -6.496142701296286936e-52 , 32.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0e-06, 1.0e-06)", 1.1544011544013627977e-32, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0, 1.0e-10)", 2.0224912016958766992e-52, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0, 1.0)", 0.011498635037491577728, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0, 5.0)", 0.0020696945662545205776, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0, 7.0)", -0.0017555303787488993676, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0, 10.0)", 0.00008999979724504887101, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0, 100.0)", -4.185397793298567945e-44, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0, 500.0)", 1.4235113901091961263e-217, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 100.0, 0.001)", 9.642762597222417946e-10, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 100.0, 0.002)", 3.0821201254308036109e-08, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 100.0, 0.01)", 0.00009281069019005840532, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 100.0, 1.0)", -0.008043100696178624653, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 100.0, 10.0)", -3.927678432813974207e-07, TEST_TOL3, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1000.0, 0.001)", 0.00009256365284253254503, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1000.0, 0.01)", -0.05553733815473079983, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0e+08, 1.0e-08)", 0.00009256115861125841299, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_H3d_e", "(5, 1.0e+08, 100.0)", -6.496143209092860765e-52 , 128.0*TEST_SQRT_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "(-0.9999847412109375)", -5.8917472200477175158028143531855, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "(-0.5)", -0.5493061443340548457, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "(-1e-10)", -1.000000000000000000e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "(0.0)", 0.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "(1e-10)", 1.000000000000000000e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "(0.9999847412109375)", 5.8917472200477175158028143531855, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "( 1.0000152587890625)", 5.8917548494422489138325509750429, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "( 1.5)", 0.8047189562170501873, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "( 9.99)", 0.1004364599660005447, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "( 10.0)", 0.1003353477310755806, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "( 10.01)", 0.1002344395571710243, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "( 100)", 0.010000333353334762015, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q0_e", "( 1e10)", 1.000000000000000000e-10, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(-0.9999847412109375)", 4.8916573191196772369, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(-0.5)", -0.7253469278329725772, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(-0.01)", -0.9998999966664666524, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(-1e-10)", -0.999999999999999999, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(0.0)", -1.0, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(1e-10)", -0.999999999999999999, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(0.0001)", -0.9999999899999999667, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(0.01)", -0.9998999966664666524, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(0.5)", -0.7253469278329725772, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(0.9999847412109375)", 4.8916573191196772369, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "(1.0000152587890625)", 4.8918447504867045145, TEST_TOL4, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "( 1.5)", 0.20707843432557528095, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "( 9.99)", 3.360235060345441639e-3, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "( 10.0)", 3.353477310755806357e-3, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "( 10.01)", 3.346739967281953346e-3, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "( 100.0)", 3.333533347620158821e-5, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Q1_e", "( 1e10)", 3.333333333333333333e-21, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(10, -0.5)", -0.29165813966586752393, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(10, 0.5)", 0.29165813966586752393, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(10, 1.5)", 0.000014714232718207477406, TEST_TOL0, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(100, -0.5)", -0.09492507395207282096, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(100, 0.5)", 0.09492507395207282096, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(100, 1.5)", 1.1628163435044121988e-43, TEST_TOL2, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(1000, -0.5)", -0.030105074974005303500, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(1000, 0.5)", 0.030105074974005303500, TEST_TOL1, GSL::SUCCESS) TEST_SF(s, "GSL::Sf::legendre_Ql_e", "(1000, 1.1)", 1.0757258447825356443e-194, TEST_TOL3, GSL::SUCCESS) gsl-1.15.3/tests/blas/0000755000175000017500000000000012220252463014025 5ustar boutilboutilgsl-1.15.3/tests/blas/amax.rb0000755000175000017500000000047712220252463015313 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") include GSL::Test v = GSL::Vector.alloc(0.537, 0.826) expected = 1 k = v.idamax GSL::Test::test_int(k, expected, "damax") vz = GSL::Vector::Complex.alloc([0.913, -0.436], [-0.134, 0.129]) expected = 0 k = vz.izamax GSL::Test::test_int(k, expected, "zmax") gsl-1.15.3/tests/blas/dot.rb0000755000175000017500000000116512220252463015146 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") include GSL::Test dbleps = 1e-6 n = 1 x = GSL::Vector.alloc(0.002) y = GSL::Vector.alloc(-0.921) expected = GSL::Vector.alloc(0.002) Blas.dcopy(x, y) for i in 0...n do GSL::Test::test_rel(y[i], expected[i], dbleps, "dcopy") end x = GSL::Vector::Complex.alloc([[ 0.315, -0.324]]) y = GSL::Vector::Complex.alloc([[-0.312, -0.748]]) expected = GSL::Vector::Complex.alloc([[0.315, -0.324]]) Blas.zcopy(x, y) for i in 0...n do GSL::Test::test_rel(y[i].re, expected[i].re, dbleps, "zcopy real") GSL::Test::test_rel(y[i].im, expected[i].im, dbleps, "zcopy imag") end gsl-1.15.3/tests/blas/axpy.rb0000755000175000017500000000127212220252463015340 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") include GSL::Test dbleps = 1e-6 n = 1 alpha = -0.3 x = GSL::Vector.alloc(0.029) y = GSL::Vector.alloc(-0.992) expected = GSL::Vector.alloc(-1.0007) y2 = Blas.daxpy(alpha, x, y) for i in 0...n do GSL::Test::test_rel(y2[i], expected[i], dbleps, "daxpy") end alpha = GSL::Complex.alloc(0, 1) x = GSL::Vector::Complex.alloc([[0.776, -0.671]]) y = GSL::Vector::Complex.alloc([[0.39, 0.404]]) expected = GSL::Vector::Complex.alloc([[1.061, 1.18]]) y2 = Blas.zaxpy(alpha, x, y) for i in 0...n do GSL::Test::test_rel(y2[i].re, expected[i].re, dbleps, "zaxpy real") GSL::Test::test_rel(y2[i].im, expected[i].im, dbleps, "zaxpy imag") end gsl-1.15.3/tests/blas/copy.rb0000755000175000017500000000116512220252463015332 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") include GSL::Test dbleps = 1e-6 n = 1 x = GSL::Vector.alloc(0.002) y = GSL::Vector.alloc(-0.921) expected = GSL::Vector.alloc(0.002) Blas.dcopy(x, y) for i in 0...n do GSL::Test::test_rel(y[i], expected[i], dbleps, "dcopy") end x = GSL::Vector::Complex.alloc([[ 0.315, -0.324]]) y = GSL::Vector::Complex.alloc([[-0.312, -0.748]]) expected = GSL::Vector::Complex.alloc([[0.315, -0.324]]) Blas.zcopy(x, y) for i in 0...n do GSL::Test::test_rel(y[i].re, expected[i].re, dbleps, "zcopy real") GSL::Test::test_rel(y[i].im, expected[i].im, dbleps, "zcopy imag") end gsl-1.15.3/tests/blas/asum.rb0000755000175000017500000000055112220252463015323 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test.rb") include GSL::Test dbleps = 1e-6 v = GSL::Vector.alloc(0.271, -0.012) expected = 0.283 f = v.dasum GSL::Test::test_rel(f, expected, dbleps, "dasum") vz = GSL::Vector::Complex.alloc([-0.046, -0.671], [-0.323, 0.785]) expected = 1.825 f = vz.dzasum GSL::Test::test_rel(f, expected, dbleps, "dzasum") gsl-1.15.3/tests/qrng.rb0000755000175000017500000000561512220252463014412 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "qrng/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math GSL::IEEE::env_setup() def test_sobol() v = GSL::Vector.alloc(3) status = 0 g = GSL::QRng.alloc(GSL::QRng::SOBOL, 2) g.get(v) g.get(v) g.get(v) status += (v[0] != 0.25 or v[1] != 0.75) ? 1 : 0 g.get(v) status += (v[0] != 0.375 or v[1] != 0.375) ? 1 : 0 GSL::Test::test(status, "Sobol d=2") status = 0 g = GSL::QRng.alloc(GSL::QRng::SOBOL, 3) g.get(v) g.get(v) g.get(v) status += (v[0] != 0.25 or v[1] != 0.75) ? 1 : 0 g.get(v) status += (v[0] != 0.375 or v[1] != 0.375) ? 1 : 0 GSL::Test::test(status, "Sobol d=3") status = 0 g.init g.get(v) g.get(v) g.get(v) status += (v[0] != 0.25 or v[1] != 0.75) ? 1 : 0 g.get(v) status += (v[0] != 0.375 or v[1] != 0.375) ? 1 : 0 GSL::Test::test(status, "Sobol d=3 (reinitialized)") end def test_nied2() v = GSL::Vector.alloc(3) status = 0 g = GSL::QRng.alloc(GSL::QRng::NIEDERREITER_2, 2) g.get(v) g.get(v) g.get(v) status += (v[0] != 0.75 or v[1] != 0.25) ? 1 : 0 g.get(v) status += (v[0] != 0.25 or v[1] != 0.75) ? 1 : 0 g.get(v) g.get(v) g.get(v) status += (v[0] != 0.625 or v[1] != 0.125) ? 1 : 0 GSL::Test::test(status, "Niederreiter d=2") status = 0 g = GSL::QRng.alloc(GSL::QRng::NIEDERREITER_2, 3) g.get(v) g.get(v) g.get(v) status += (v[0] != 0.75 or v[1] != 0.25) ? 1 : 0 g.get(v) status += (v[0] != 0.25 or v[1] != 0.75) ? 1 : 0 g.get(v) g.get(v) g.get(v) status += (v[0] != 0.625 or v[1] != 0.125) ? 1 : 0 GSL::Test::test(status, "Niederreiter d=3") status = 0 g.init g.get(v) g.get(v) g.get(v) status += (v[0] != 0.75 or v[1] != 0.25) ? 1 : 0 g.get(v) status += (v[0] != 0.25 or v[1] != 0.75) ? 1 : 0 g.get(v) g.get(v) g.get(v) status += (v[0] != 0.625 or v[1] != 0.125) ? 1 : 0 GSL::Test::test(status, "Niederreiter d=3 (reinitialized)") end test_sobol() test_nied2() # Tests for an extension package "qrngextra" exit unless GSL::QRng.const_defined?("HDSOBOL") def test_hdsobol() v = GSL::Vector.alloc(3) status = 0 g = GSL::QRng.alloc(GSL::QRng::HDSOBOL, 2) g.get(v) g.get(v) g.get(v) status += (v[0] != 0.25 or v[1] != 0.75) ? 1 : 0 g.get(v) status += (v[0] != 0.375 or v[1] != 0.375) ? 1 : 0 GSL::Test::test(status, "HDSobol d=2") status = 0 g = GSL::QRng.alloc(GSL::QRng::SOBOL, 3) g.get(v) g.get(v) g.get(v) status += (v[0] != 0.25 or v[1] != 0.75 or v[2] != 0.25) ? 1 : 0 g.get(v) status += (v[0] != 0.375 or v[1] != 0.375 or v[2] != 0.625) ? 1 : 0 GSL::Test::test(status, "HDSobol d=3") status = 0 g.init g.get(v) g.get(v) g.get(v) status += (v[0] != 0.25 or v[1] != 0.75 or v[2] != 0.25) ? 1 : 0 g.get(v) status += (v[0] != 0.375 or v[1] != 0.375 or v[2] != 0.625) ? 1 : 0 GSL::Test::test(status, "HDSobol d=3 (reinitialized)") end test_hdsobol() gsl-1.15.3/tests/quartic.rb0000755000175000017500000000222712220252463015107 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("./gsl_test2.rb") include GSL::Test exit unless GSL::Poly.method_defined?("complex_solve_quartic") z = GSL::Poly.complex_solve_quartic(0.0, 0.0, 0.0, -81.0) puts("Four roots, x^4 - 81") GSL::Test::test_rel(z[0].re, -3.0, 1e-9, "z0.real") GSL::Test::test_rel(z[0].im, 0.0, 1e-9, "z0.imag") GSL::Test::test_rel(z[1].re, 0.0, 1e-9, "z1.real") GSL::Test::test_rel(z[1].im, -3.0, 1e-9, "z1.imag") GSL::Test::test_rel(z[2].re, 0.0, 1e-9, "z2.real") GSL::Test::test_rel(z[2].im, 3.0, 1e-9, "z2.imag") GSL::Test::test_rel(z[3].re, 3.0, 1e-9, "z3.real") GSL::Test::test_rel(z[3].im, 0.0, 1e-9, "z3.imag") sol = 3.0/Math.sqrt(2.0) z = GSL::Poly.complex_solve_quartic(0.0, 0.0, 0.0, 81.0) puts("Four roots, x^4 + 81") GSL::Test::test_rel(z[0].re, -sol, 1e-9, "z0.real") GSL::Test::test_rel(z[0].im, -sol, 1e-9, "z0.imag") GSL::Test::test_rel(z[1].re, -sol, 1e-9, "z1.real") GSL::Test::test_rel(z[1].im, sol, 1e-9, "z1.imag") GSL::Test::test_rel(z[2].re, sol, 1e-9, "z2.real") GSL::Test::test_rel(z[2].im, -sol, 1e-9, "z2.imag") GSL::Test::test_rel(z[3].re, sol, 1e-9, "z3.real") GSL::Test::test_rel(z[3].im, sol, 1e-9, "z3.imag") gsl-1.15.3/tests/multifit/0000755000175000017500000000000012220252463014741 5ustar boutilboutilgsl-1.15.3/tests/multifit/test_enso.rb0000755000175000017500000001134212220252463017275 0ustar boutilboutil#!/usr/bin/env ruby #require("gsl") #require("../gsl_test2.rb") require("./test_multifit.rb") include GSL::Test include Math Enso_N = 168; Enso_P = 9; Enso_x0 = GSL::Vector.alloc(10.0, 3.0, 0.5, 44.0, -1.5, 0.5, 26.0, 0.1, 1.5) Enso_x = GSL::Vector.alloc( 1.0510749193E+01, 3.0762128085E+00, 5.3280138227E-01, 4.4311088700E+01, -1.6231428586E+00, 5.2554493756E-01, 2.6887614440E+01, 2.1232288488E-01, 1.4966870418E+00) Enso_sumsq = 7.8853978668E+02 Enso_sigma = GSL::Vector.alloc( 1.7488832467E-01, 2.4310052139E-01, 2.4354686618E-01, 9.4408025976E-01, 2.8078369611E-01, 4.8073701119E-01, 4.1612939130E-01, 5.1460022911E-01, 2.5434468893E-01) Enso_F = GSL::Vector.alloc( 12.90000, 11.30000, 10.60000, 11.20000, 10.90000, 7.500000, 7.700000, 11.70000, 12.90000, 14.30000, 10.90000, 13.70000, 17.10000, 14.00000, 15.30000, 8.500000, 5.700000, 5.500000, 7.600000, 8.600000, 7.300000, 7.600000, 12.70000, 11.00000, 12.70000, 12.90000, 13.00000, 10.90000, 10.400000, 10.200000, 8.000000, 10.90000, 13.60000, 10.500000, 9.200000, 12.40000, 12.70000, 13.30000, 10.100000, 7.800000, 4.800000, 3.000000, 2.500000, 6.300000, 9.700000, 11.60000, 8.600000, 12.40000, 10.500000, 13.30000, 10.400000, 8.100000, 3.700000, 10.70000, 5.100000, 10.400000, 10.90000, 11.70000, 11.40000, 13.70000, 14.10000, 14.00000, 12.50000, 6.300000, 9.600000, 11.70000, 5.000000, 10.80000, 12.70000, 10.80000, 11.80000, 12.60000, 15.70000, 12.60000, 14.80000, 7.800000, 7.100000, 11.20000, 8.100000, 6.400000, 5.200000, 12.00000, 10.200000, 12.70000, 10.200000, 14.70000, 12.20000, 7.100000, 5.700000, 6.700000, 3.900000, 8.500000, 8.300000, 10.80000, 16.70000, 12.60000, 12.50000, 12.50000, 9.800000, 7.200000, 4.100000, 10.60000, 10.100000, 10.100000, 11.90000, 13.60000, 16.30000, 17.60000, 15.50000, 16.00000, 15.20000, 11.20000, 14.30000, 14.50000, 8.500000, 12.00000, 12.70000, 11.30000, 14.50000, 15.10000, 10.400000, 11.50000, 13.40000, 7.500000, 0.6000000, 0.3000000, 5.500000, 5.000000, 4.600000, 8.200000, 9.900000, 9.200000, 12.50000, 10.90000, 9.900000, 8.900000, 7.600000, 9.500000, 8.400000, 10.70000, 13.60000, 13.70000, 13.70000, 16.50000, 16.80000, 17.10000, 15.40000, 9.500000, 6.100000, 10.100000, 9.300000, 5.300000, 11.20000, 16.60000, 15.60000, 12.00000, 11.50000, 8.600000, 13.80000, 8.700000, 8.600000, 8.600000, 8.700000, 12.80000, 13.20000, 14.00000, 13.40000, 14.80000) enso_f = Proc.new { |x, t, y, f| b = x for i in 0...Enso_N ti = t[i] yy = b[0] yy += b[1]*cos(2.0*M_PI*ti/12) yy += b[2]*sin(2.0*M_PI*ti/12) yy += b[4]*cos(2.0*M_PI*ti/b[3]) yy += b[5]*sin(2.0*M_PI*ti/b[3]) yy += b[7]*cos(2.0*M_PI*ti/b[6]) yy += b[8]*sin(2.0*M_PI*ti/b[6]) f[i] = y[i] - yy end GSL::SUCCESS } enso_df = Proc.new { |x, t, y, df| b = x for i in 0...Enso_N ti = t[i] df.set(i, 0, -1.0) df.set(i, 1, -cos(2.0*M_PI*ti/12)) df.set(i, 2, -sin(2.0*M_PI*ti/12)) df.set(i, 3, -b[4]*(2.0*M_PI*ti/(b[3]*b[3]))*sin(2*M_PI*ti/b[3])+ b[5]*(2*M_PI*ti/(b[3]*b[3]))*cos(2*M_PI*ti/b[3])) df.set(i, 4, -cos(2*M_PI*ti/b[3])); df.set(i, 5, -sin(2*M_PI*ti/b[3])); df.set(i, 6, - b[7] * (2*M_PI*ti/(b[6]*b[6])) * sin(2*M_PI*ti/b[6]) + b[8] * (2*M_PI*ti/(b[6]*b[6])) * cos(2*M_PI*ti/b[6])) df.set(i, 7, -cos(2*M_PI*ti/b[6])); df.set(i, 8, -sin(2*M_PI*ti/b[6])); end GSL::SUCCESS } fdf = GSL::MultiFit::Function_fdf.alloc(enso_f, enso_df, Enso_P) #fdf.set_data(GSL::Vector.alloc(1..168), Enso_F) fdf.set_data(GSL::Vector.indgen(168, 1), Enso_F) test_fdf("nist-ENSO", fdf, Enso_x0, Enso_x, Enso_sumsq, Enso_sigma) gsl-1.15.3/tests/multifit/test_2dgauss.rb0000755000175000017500000000527512220252463017711 0ustar boutilboutil#!/usr/bin/env ruby # vim: set ts=8 sw=2 sts=2: #require("gsl") #require("../gsl_test2.rb") require("./test_multifit.rb") include GSL::Test include Math Maxiter = 10 N = 33 # point class Point attr_accessor :x, :y def initialize(x = nil, y = nil) @x, @y = x, y end end # model: a*exp(-((x-x0)**2+(y-y0)**2)/2/sigma**2) gauss_f = Proc.new { |x, t, y, s, f| # x: parameters as a Vecor # t: observed points as an Array # y: observed data as a GSL::Vector # s: errorbar # f: result a = x[0] x0 = x[1] y0 = x[2] sigma2 = x[3]**2 y.size.times do |i| f.set(i, (a*Math::exp(-((t[i].x - x0)**2+(t[i].y - y0)**2)/2/sigma2) - y[i])/s[i]) end GSL::SUCCESS } gauss_df = Proc.new { |x, t, y, s, df| a = x[0] x0 = x[1] y0 = x[2] sigma = x[3] sigma2 = sigma**2 y.size.times do |i| dx = t[i].x - x0; dx2 = dx**2 dy = t[i].y - y0; dy2 = dy**2 f = a*Math::exp(-(dx2+dy2)/2/sigma2) df.set(i, 0, f/a/s[i]) df.set(i, 1, f*dx/sigma2/s[i]) df.set(i, 2, f*dy/sigma2/s[i]) df.set(i, 3, f*(dx2+dy2)/sigma2/sigma/s[i]) end GSL::SUCCESS } # goal xgoal = GSL::Vector.alloc([1, 0, 0, 1]) parname = %w( a x0 y0 si ) # data t = Array.new tmin = -10.0 tmax = 10.0 N.times do |j| N.times do |i| t << Point.new(tmin + (tmax - tmin)*i/(N-1), tmin + (tmax - tmin)*j/(N-1)) end end stdev = xgoal[0]*0.1 s = GSL::Vector.alloc(Array.new(t.size, stdev)) # error bar of each datum r = Rng.alloc e = GSL::Vector.alloc(t.size) t.size.times do |i| e[i] = -r.gaussian(stdev) # perturbation to data end y = GSL::Vector.alloc(t.size) n = GSL::Vector.alloc(Array.new(t.size, 1.0)) gauss_f.call(xgoal, t, e, n, y) # data: y = model - e # fitting x = GSL::Vector.alloc([0.5, 0.1, -0.1, 2.0]) # initial guess fdf = GSL::MultiFit::Function_fdf.alloc(gauss_f, gauss_df, x.size) fdf.set_data(t, y, s) solver = GSL::MultiFit::FdfSolver.alloc(GSL::MultiFit::FdfSolver::LMSDER, t.size, x.size) solver.set(fdf, x) solver.print_state(0) Maxiter.times do |i| solver.iterate status = solver.test_delta(1e-6, 1e-6) solver.print_state(i+1) break unless GSL::CONTINUE == status end # results covar = solver.covar(0.0) xresult = solver.position dof = t.size - xresult.size chi2 = pow_2(solver.f.dnrm2) xsigma = GSL::Vector.alloc(xresult.size) xresult.size.times do |i| xsigma[i] = Math::sqrt(chi2/dof*covar[i,i]) * 2.0 # allow resulting parameters to differ two times than standard error end puts "a*exp(-((x-x0)**2+(y-y0)**2)/2/si**2), chi2/N:%.3g" % (chi2/t.size) xresult.size.times do |i| test_rel(xresult[i], xgoal[i], xsigma[i], "%-2.2s" % parname[i]) if (xresult[i] - xgoal[i]).abs > xsigma[i] then puts "#{'%-2.2s' % parname[i]} is #{xresult[i]} +- #{xsigma[i]}" exit 1 end end gsl-1.15.3/tests/multifit/test_gauss.rb0000755000175000017500000000451312220252463017455 0ustar boutilboutil#!/usr/bin/env ruby # vim: set ts=8 sw=2 sts=2: #require("gsl") #require("../gsl_test2.rb") require("./test_multifit.rb") include GSL::Test include Math Maxiter = 10 N = 1000 # model: a*exp(-(x-x0)**2/2/sigma**2) gauss_p = 3 gauss_f = Proc.new { |x, t, y, s, f| # x: parameters as a Vecor # t: observed points as a GSL::Vector # y: observed data as a GSL::Vector # s: errorbar # f: result a = x[0] x0 = x[1] sigma2 = x[2]**2 y.size.times do |i| f.set(i, (a*Math::exp(-(t[i] - x0)**2/2/sigma2) - y[i])/s[i]) end GSL::SUCCESS } gauss_df = Proc.new { |x, t, y, s, df| a = x[0] x0 = x[1] sigma = x[2] sigma2 = sigma**2 y.size.times do |i| dx = t[i] - x0 dx2 = dx**2 f = a*Math::exp(-dx2/2/sigma2) df.set(i, 0, f/a/s[i]) df.set(i, 1, f*dx/sigma2/s[i]) df.set(i, 2, f*dx2/sigma2/sigma/s[i]) end GSL::SUCCESS } # goal xgoal = GSL::Vector.alloc([1, 0, 1]) parname = %w( a x0 si ) # data t = GSL::Vector.alloc(N) # positions of data tmin = -10.0 tmax = 10.0 t.size.times do |i| t[i] = tmin + (tmax - tmin)*i/(N-1) end stdev = xgoal[0]*0.1 s = GSL::Vector.alloc(Array.new(t.size, stdev)) # error bar of each datum r = Rng.alloc e = GSL::Vector.alloc(t.size) t.size.times do |i| e[i] = -r.gaussian(stdev) # perturbation to data end y = GSL::Vector.alloc(t.size) n = GSL::Vector.alloc(Array.new(t.size, 1.0)) gauss_f.call(xgoal, t, e, n, y) # data: y = model - e # fitting x = GSL::Vector.alloc([0.5, 0.1, 2]) # initial guess fdf = GSL::MultiFit::Function_fdf.alloc(gauss_f, gauss_df, gauss_p) fdf.set_data(t, y, s) solver = GSL::MultiFit::FdfSolver.alloc(GSL::MultiFit::FdfSolver::LMSDER, t.size, gauss_p) solver.set(fdf, x) solver.print_state(0) Maxiter.times do |i| solver.iterate status = solver.test_delta(1e-6, 1e-6) solver.print_state(i+1) break unless GSL::CONTINUE == status end # results covar = solver.covar(0.0) xresult = solver.position dof = t.size - gauss_p chi2 = pow_2(solver.f.dnrm2) xsigma = GSL::Vector.alloc(xresult.size) xresult.size.times do |i| xsigma[i] = Math::sqrt(chi2/dof*covar[i,i]) * 2.0 # resulting parameters to differ two times than standard error end puts("a*exp(-(x-x0)**2/2/si**2), chi2/N:%.3g" % (chi2/t.size)) xresult.size.times do |i| test_rel(xresult[i], xgoal[i], xsigma[i], "%-2.2s" % parname[i]) exit 1 if (xresult[i] - xgoal[i]).abs > xsigma[i] end gsl-1.15.3/tests/multifit/test_longley.rb0000755000175000017500000001264612220252463020012 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Math Longley_n = 16; Longley_p = 7; Longley_x = GSL::Vector.alloc(1, 83.0, 234289, 2356, 1590, 107608, 1947, 1, 88.5, 259426, 2325, 1456, 108632, 1948, 1, 88.2, 258054, 3682, 1616, 109773, 1949, 1, 89.5, 284599, 3351, 1650, 110929, 1950, 1, 96.2, 328975, 2099, 3099, 112075, 1951, 1, 98.1, 346999, 1932, 3594, 113270, 1952, 1, 99.0, 365385, 1870, 3547, 115094, 1953, 1, 100.0, 363112, 3578, 3350, 116219, 1954, 1, 101.2, 397469, 2904, 3048, 117388, 1955, 1, 104.6, 419180, 2822, 2857, 118734, 1956, 1, 108.4, 442769, 2936, 2798, 120445, 1957, 1, 110.8, 444546, 4681, 2637, 121950, 1958, 1, 112.6, 482704, 3813, 2552, 123366, 1959, 1, 114.2, 502601, 3931, 2514, 125368, 1960, 1, 115.7, 518173, 4806, 2572, 127852, 1961, 1, 116.9, 554894, 4007, 2827, 130081, 1962) Longley_y = GSL::Vector.alloc(60323, 61122, 60171, 61187, 63221, 63639, 64989, 63761, 66019, 67857, 68169, 66513, 68655, 69564, 69331, 70551) def test_longley() work = GSL::MultiFit::Workspace.alloc(Longley_n, Longley_p) x = GSL::Matrix.alloc(Longley_x, Longley_n, Longley_p).view y = Longley_y.view expected_c = GSL::Vector.alloc(-3482258.63459582, 15.0618722713733, -0.358191792925910E-01, -2.02022980381683, -1.03322686717359, -0.511041056535807E-01, 1829.15146461355) expected_sd = GSL::Vector.alloc(890420.383607373, 84.9149257747669, 0.334910077722432E-01, 0.488399681651699, 0.214274163161675, 0.226073200069370, 455.478499142212) expected_chisq = 836424.055505915 c, cov, chisq, status = GSL::MultiFit.linear(x, y, work) for i in 0...7 test_rel(c[i], expected_c[i], 1e-10, "longley gsl_fit_multilinear c#{i}") end diag = cov.diagonal test_rel(diag[0], pow(expected_sd[0],2.0), 1e-10, "longley gsl_fit_multilinear cov00") ; test_rel(diag[1], pow(expected_sd[1],2.0), 1e-10, "longley gsl_fit_multilinear cov11") ; test_rel(diag[2], pow(expected_sd[2],2.0), 1e-10, "longley gsl_fit_multilinear cov22") ; test_rel(diag[3], pow(expected_sd[3],2.0), 1e-10, "longley gsl_fit_multilinear cov33") ; test_rel(diag[4], pow(expected_sd[4],2.0), 1e-10, "longley gsl_fit_multilinear cov44") ; test_rel(diag[5], pow(expected_sd[5],2.0), 1e-10, "longley gsl_fit_multilinear cov55") ; test_rel(diag[6], pow(expected_sd[6],2.0), 1e-10, "longley gsl_fit_multilinear cov66") ; test_rel(chisq, expected_chisq, 1e-10, "longley gsl_fit_multilinear chisq") ################### expected_cov = GSL::Matrix.alloc([8531122.56783558, -166.727799925578, 0.261873708176346, 3.91188317230983, 1.1285582054705, -0.889550869422687, -4362.58709870581], [-166.727799925578, 0.0775861253030891, -1.98725210399982e-05, -0.000247667096727256, -6.82911920718824e-05, 0.000136160797527761, 0.0775255245956248], [0.261873708176346, -1.98725210399982e-05, 1.20690316701888e-08, 1.66429546772984e-07, 3.61843600487847e-08, -6.78805814483582e-08, -0.00013158719037715], [3.91188317230983, -0.000247667096727256, 1.66429546772984e-07, 2.56665052544717e-06, 6.96541409215597e-07, -9.00858307771567e-07, -0.00197260370663974], [1.1285582054705, -6.82911920718824e-05, 3.61843600487847e-08, 6.96541409215597e-07, 4.94032602583969e-07, -9.8469143760973e-08, -0.000576921112208274], [-0.889550869422687, 0.000136160797527761, -6.78805814483582e-08, -9.00858307771567e-07, -9.8469143760973e-08, 5.49938542664952e-07, 0.000430074434198215], [-4362.58709870581, 0.0775255245956248, -0.00013158719037715, -0.00197260370663974, -0.000576921112208274, 0.000430074434198215, 2.23229587481535 ]) expected_chisq = 836424.055505915 w = GSL::Vector.alloc(Longley_n) w.set_all(1.0) c, cov, chisq, status = GSL::MultiFit.wlinear(x, w, y, work) for i in 0...7 test_rel(c[i], expected_c[i], 1e-10, "longley gsl_fit_wmultilinear c#{i}") ; end for i in 0...Longley_p for j in 0...Longley_p test_rel(cov[i,j], expected_cov[i,j], 1e-7, "longley gsl_fit_wmultilinear cov(#{i},#{j})") end end test_rel(chisq, expected_chisq, 1e-10, "longley gsl_fit_wmultilinear chisq") end test_longley() gsl-1.15.3/tests/multifit/test_filip.rb0000755000175000017500000002571712220252463017447 0ustar boutilboutil#!/usr/bin/env ruby #require("gsl") #require("../gsl_test2.rb") require("./test_multifit.rb") include GSL::Test include Math Filip_n = 82 Filip_p = 11 Filip_x = GSL::Vector.alloc(-6.860120914, -4.324130045, -4.358625055, -4.358426747, -6.955852379, -6.661145254, -6.355462942, -6.118102026, -7.115148017, -6.815308569, -6.519993057, -6.204119983, -5.853871964, -6.109523091, -5.79832982, -5.482672118, -5.171791386, -4.851705903, -4.517126416, -4.143573228, -3.709075441, -3.499489089, -6.300769497, -5.953504836, -5.642065153, -5.031376979, -4.680685696, -4.329846955, -3.928486195, -8.56735134, -8.363211311, -8.107682739, -7.823908741, -7.522878745, -7.218819279, -6.920818754, -6.628932138, -6.323946875, -5.991399828, -8.781464495, -8.663140179, -8.473531488, -8.247337057, -7.971428747, -7.676129393, -7.352812702, -7.072065318, -6.774174009, -6.478861916, -6.159517513, -6.835647144, -6.53165267, -6.224098421, -5.910094889, -5.598599459, -5.290645224, -4.974284616, -4.64454848, -4.290560426, -3.885055584, -3.408378962, -3.13200249, -8.726767166, -8.66695597, -8.511026475, -8.165388579, -7.886056648, -7.588043762, -7.283412422, -6.995678626, -6.691862621, -6.392544977, -6.067374056, -6.684029655, -6.378719832, -6.065855188, -5.752272167, -5.132414673, -4.811352704, -4.098269308, -3.66174277, -3.2644011) Filip_y = GSL::Vector.alloc(0.8116, 0.9072, 0.9052, 0.9039, 0.8053, 0.8377, 0.8667, 0.8809, 0.7975, 0.8162, 0.8515, 0.8766, 0.8885, 0.8859, 0.8959, 0.8913, 0.8959, 0.8971, 0.9021, 0.909, 0.9139, 0.9199, 0.8692, 0.8872, 0.89, 0.891, 0.8977, 0.9035, 0.9078, 0.7675, 0.7705, 0.7713, 0.7736, 0.7775, 0.7841, 0.7971, 0.8329, 0.8641, 0.8804, 0.7668, 0.7633, 0.7678, 0.7697, 0.77, 0.7749, 0.7796, 0.7897, 0.8131, 0.8498, 0.8741, 0.8061, 0.846, 0.8751, 0.8856, 0.8919, 0.8934, 0.894, 0.8957, 0.9047, 0.9129, 0.9209, 0.9219, 0.7739, 0.7681, 0.7665, 0.7703, 0.7702, 0.7761, 0.7809, 0.7961, 0.8253, 0.8602, 0.8809, 0.8301, 0.8664, 0.8834, 0.8898, 0.8964, 0.8963, 0.9074, 0.9119, 0.9228) def test_filip() work = GSL::MultiFit::Workspace.alloc(Filip_n, Filip_p) expected_c = GSL::Vector.alloc(-1467.48961422980, -2772.17959193342, -2316.37108160893, -1127.97394098372, -354.478233703349, -75.1242017393757, -10.8753180355343, -1.06221498588947, -0.670191154593408E-01, -0.246781078275479E-02, -0.402962525080404E-04) expected_sd = GSL::Vector.alloc(298.084530995537, 559.779865474950, 466.477572127796, 227.204274477751, 71.6478660875927, 15.2897178747400, 2.23691159816033, 0.221624321934227, 0.142363763154724E-01, 0.535617408889821E-03, 0.896632837373868E-05) expected_chisq = 0.795851382172941E-03 xx = GSL::Matrix.alloc(Filip_n, Filip_p) for i in 0...Filip_n for j in 0...Filip_p xx.set(i, j, pow(Filip_x[i], j)) end end c, cov, chisq, status = GSL::MultiFit.linear(xx, Filip_y, work) test_rel(c[0], expected_c[0], 1e-7, "filip gsl_fit_multilinear c0") test_rel(c[1], expected_c[1], 1e-7, "filip gsl_fit_multilinear c1") test_rel(c[2], expected_c[2], 1e-7, "filip gsl_fit_multilinear c2") test_rel(c[3], expected_c[3], 1e-7, "filip gsl_fit_multilinear c3") test_rel(c[4], expected_c[4], 1e-7, "filip gsl_fit_multilinear c4") test_rel(c[5], expected_c[5], 1e-7, "filip gsl_fit_multilinear c5") test_rel(c[6], expected_c[6], 1e-7, "filip gsl_fit_multilinear c6") test_rel(c[7], expected_c[7], 1e-7, "filip gsl_fit_multilinear c7") test_rel(c[8], expected_c[8], 1e-7, "filip gsl_fit_multilinear c8") test_rel(c[9], expected_c[9], 1e-7, "filip gsl_fit_multilinear c9") test_rel(c[10], expected_c[10], 1e-7, "filip gsl_fit_multilinear c10") diag = cov.diagonal test_rel(diag[0], pow(expected_sd[0],2.0), 1e-6, "filip gsl_fit_multilinear cov00") ; test_rel(diag[1], pow(expected_sd[1],2.0), 1e-6, "filip gsl_fit_multilinear cov11") ; test_rel(diag[2], pow(expected_sd[2],2.0), 1e-6, "filip gsl_fit_multilinear cov22") ; test_rel(diag[3], pow(expected_sd[3],2.0), 1e-6, "filip gsl_fit_multilinear cov33") ; test_rel(diag[4], pow(expected_sd[4],2.0), 1e-6, "filip gsl_fit_multilinear cov44") ; test_rel(diag[5], pow(expected_sd[5],2.0), 1e-6, "filip gsl_fit_multilinear cov55") ; test_rel(diag[6], pow(expected_sd[6],2.0), 1e-6, "filip gsl_fit_multilinear cov66") ; test_rel(diag[7], pow(expected_sd[7],2.0), 1e-6, "filip gsl_fit_multilinear cov77") ; test_rel(diag[8], pow(expected_sd[8],2.0), 1e-6, "filip gsl_fit_multilinear cov88") ; test_rel(diag[9], pow(expected_sd[9],2.0), 1e-6, "filip gsl_fit_multilinear cov99") ; test_rel(diag[10], pow(expected_sd[10],2.0), 1e-6, "filip gsl_fit_multilinear cov1010") ; test_rel(chisq, expected_chisq, 1e-7, "filip gsl_fit_multilinear chisq") expected_c = GSL::Vector.alloc( -1467.48961422980, -2772.17959193342, -2316.37108160893, -1127.97394098372, -354.478233703349, -75.1242017393757, -10.8753180355343, -1.06221498588947, -0.670191154593408E-01, -0.246781078275479E-02, -0.402962525080404E-04) expected_cov = GSL::Matrix.alloc([ 7.9269341767252183262588583867942e9, 1.4880416622254098343441063389706e10, 1.2385811858111487905481427591107e10, 6.0210784406215266653697715794241e9, 1.8936652526181982747116667336389e9, 4.0274900618493109653998118587093e8, 5.8685468011819735806180092394606e7, 5.7873451475721689084330083708901e6, 3.6982719848703747920663262917032e5, 1.3834818802741350637527054170891e4, 2.301758578713219280719633494302e2 ], [ 1.4880416622254098334697515488559e10, 2.7955091668548290835529555438088e10, 2.3286604504243362691678565997033e10, 1.132895006796272983689297219686e10, 3.5657281653312473123348357644683e9, 7.5893300392314445528176646366087e8, 1.1066654886143524811964131660002e8, 1.0921285448484575110763947787775e7, 6.9838139975394769253353547606971e5, 2.6143091775349597218939272614126e4, 4.3523386330348588614289505633539e2 ], [ 1.2385811858111487890788272968677e10, 2.3286604504243362677757802422747e10, 1.9412787917766676553608636489674e10, 9.4516246492862131849077729250098e9, 2.9771226694709917550143152097252e9, 6.3413035086730038062129508949859e8, 9.2536164488309401636559552742339e7, 9.1386304643423333815338760248027e6, 5.8479478338916429826337004060941e5, 2.1905933113294737443808429764554e4, 3.6493161325305557266196635180155e2 ], [ 6.0210784406215266545770691532365e9, 1.1328950067962729823273441573365e10, 9.4516246492862131792040001429636e9, 4.6053152992000107509329772255094e9, 1.4517147860312147098138030287038e9, 3.0944988323328589376402579060072e8, 4.5190223822292688669369522708712e7, 4.4660958693678497534529855690752e6, 2.8599340736122198213681258676423e5, 1.0720394998549386596165641244705e4, 1.7870937745661967319298031044424e2 ], [ 1.8936652526181982701620450132636e9, 3.5657281653312473058825073094524e9, 2.9771226694709917514149924058297e9, 1.451714786031214708936087401632e9, 4.5796563896564815123074920050827e8, 9.7693972414561515534525103622773e7, 1.427717861635658545863942948444e7, 1.4120161287735817621354292900338e6, 9.0484361228623960006818614875557e4, 3.394106783764852373199087455398e3, 5.6617406468519495376287407526295e1 ], [ 4.0274900618493109532650887473599e8, 7.589330039231444534478894935778e8, 6.3413035086730037947153564986653e8, 3.09449883233285893390542947998e8, 9.7693972414561515475770399055121e7, 2.0855726248311948992114244257719e7, 3.0501263034740400533872858749566e6, 3.0187475839310308153394428784224e5, 1.9358204633534233524477930175632e4, 7.2662989867560017077361942813911e2, 1.2129002231061036467607394277965e1 ], [ 5.868546801181973559370854830868e7, 1.1066654886143524778548044386795e8, 9.2536164488309401413296494869777e7, 4.5190223822292688587853853162072e7, 1.4277178616356585441556046753562e7, 3.050126303474040051574715592746e6, 4.4639982579046340884744460329946e5, 4.4212093985989836047285007760238e4, 2.8371395028774486687625333589972e3, 1.0656694507620102300567296504381e2, 1.7799982046359973175080475654123e0 ], [ 5.7873451475721688839974153925406e6, 1.0921285448484575071271480643397e7, 9.1386304643423333540728480344578e6, 4.4660958693678497427674903565664e6, 1.4120161287735817596182229182587e6, 3.0187475839310308117812257613082e5, 4.4212093985989836021482392757677e4, 4.3818874017028389517560906916315e3, 2.813828775753142855163154605027e2, 1.0576188138416671883232607188969e1, 1.7676976288918295012452853715408e-1 ], [ 3.6982719848703747742568351456818e5, 6.9838139975394768959780068745979e5, 5.8479478338916429616547638954781e5, 2.8599340736122198128717796825489e5, 9.0484361228623959793493985226792e4, 1.9358204633534233490579641064343e4, 2.8371395028774486654873647731797e3, 2.8138287757531428535592907878017e2, 1.8081118503579798222896804627964e1, 6.8005074291434681866415478598732e-1, 1.1373581557749643543869665860719e-2 ], [ 1.3834818802741350562839757244708e4, 2.614309177534959709397445440919e4, 2.1905933113294737352721470167247e4, 1.0720394998549386558251721913182e4, 3.3941067837648523632905604575131e3, 7.2662989867560016909534954790835e2, 1.0656694507620102282337905013451e2, 1.0576188138416671871337685672492e1, 6.8005074291434681828743281967838e-1, 2.5593857187900736057022477529078e-2, 4.2831487599116264442963102045936e-4 ], [ 2.3017585787132192669801658674163e2, 4.3523386330348588381716460685124e2, 3.6493161325305557094116270974735e2, 1.7870937745661967246233792737255e2, 5.6617406468519495180024059284629e1, 1.2129002231061036433003571679329e1, 1.7799982046359973135014027410646e0, 1.7676976288918294983059118597214e-1, 1.137358155774964353146460100337e-2, 4.283148759911626442000316269063e-4, 7.172253875245080423800933453952e-6 ]) expected_chisq = 0.795851382172941E-03; for i in 0...Filip_n for j in 0...Filip_p xx.set(i, j, pow(Filip_x[i], j)) end end w = GSL::Vector.alloc(Filip_n) w.set_all(1.0) c, cov, chisq, status = GSL::MultiFit.wlinear(xx, w, Filip_y, work) for i in 0...Filip_p test_rel(c[i], expected_c[i], 1e-7, "filip gsl_fit_multilinear c#{i}") end for i in 0...Filip_p for j in 0...Filip_p test_rel(cov[i,j], expected_cov[i,j], 1e-6, "filip gsl_fit_wmultilinear cov(#{i},#{j})") end end end test_filip() gsl-1.15.3/tests/multifit/test_multifit.rb0000755000175000017500000000252012220252463020164 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Math def test_lmder(fdf, x, xx, f, cov) s = GSL::MultiFit::FdfSolver.alloc("lmsder", fdf.n, fdf.p) s.set(fdf, x) iter = 0 begin status = s.iterate for i in 0...fdf.p test_rel(s.x[i], xx[fdf.p*iter+i], 1e-5, "lmsder, iter=#{iter}, x#{i}") end test_rel(Blas.dnrm2(s.f), f[iter], 1e-5, "lmsder, iter=#{iter}, f") iter += 1 end while iter < 20 covar = s.covar(0.0) for i in 0...fdf.p for j in 0...fdf.p test_rel(covar[i,j], cov[i*fdf.p+j], 1e-7, "gsl_multifit_covar cov(#{i},#{j})") end end end def test_fdf(name, fdf, x, x_final, f_sumsq, sigma) s = GSL::MultiFit::FdfSolver.alloc("lmsder", fdf.n, fdf.p) s.set(fdf, x) iter = 0 begin status = s.iterate # status = GSL::MultiFit::test_delta(s.dx, s.x, 0.0, 1e-7) status = s.test_delta(0.0, 1e-7) iter += 1 end while status == GSL::CONTINUE and iter < 1000 covar = s.covar(0.0) for i in 0...fdf.p test_rel(s.x[i], x_final[i], 1e-5, "#{name}, lmsder, x#{i}") end s2 = pow(Blas.dnrm2(s.f), 2.0) test_rel(s2, f_sumsq, 1e-5, "#{name}, lmsder, |f|^2") for i in 0...fdf.p ei = sqrt(s2/(fdf.n-fdf.p))*sqrt(covar[i,i]); test_rel(ei, sigma[i], 1e-4, "#{name}, sigma(#{i})") end end GSL::IEEE::env_setup() gsl-1.15.3/tests/multifit/test_brown.rb0000755000175000017500000000614012220252463017460 0ustar boutilboutil#!/usr/bin/env ruby #require("gsl") #require("../gsl_test2.rb") require("./test_multifit.rb") include GSL::Test include Math Brown_N = 20; Brown_P = 4; Brown_X = GSL::Matrix.alloc([24.3485677, 4.71448798, -2.19486633, 2.69405755], [22.4116222, 3.93075538, -1.42344852, 2.5233557], [17.88886, 2.9290853, 0.125174936, -3.96823353], [17.3237176, 2.99606803, 2.03285653, 2.28992327], [17.0906508, 3.02485425, 0.296995153, 0.0876226126], [16.578006, 3.1036312, -0.18617941, 0.103262914], [15.692993, 3.33088442, 0.0706406887, 1.05923955], [14.3232177, 3.85604218, -2.3762839, -3.09486813], [14.1279266, 3.97896121, 0.446109351, 1.40023753], [13.6081961, 4.16435075, -1.51250057, -1.52510626], [13.4295245, 4.22697223, -0.196985195, 0.532009293], [13.0176117, 4.3579261, -0.353131208, 0.301377627], [12.2713535, 4.62398535, -0.00183585584, 0.894170703], [11.0316144, 5.13967727, -2.38978772, -2.89510064], [10.8807981, 5.24558004, 0.230495952, 1.27315117], [10.4029264, 5.41141257, -1.5116632, -1.47615921], [10.2574435, 5.46211045, -0.299855732, 0.451893162], [9.87863876, 5.57914292, -0.368885288, 0.358086545], [9.1894983, 5.82082741, -0.230157969, 0.621476534], [8.00589008, 6.27788753, -1.46022815, -1.33468082]) Brown_F = GSL::Vector.alloc( 2474.05541, 1924.69004, 1280.63194, 1244.81867, 1190.53739, 1159.34935, 1108.44426, 1090.11073, 1015.92942, 1002.43533, 971.221084, 949.589435, 911.359899, 906.522994, 840.525729, 833.950164, 807.557511, 791.00924, 761.09598, 726.787783) Brown_cov = GSL::Matrix.alloc( [ 1.8893186910e-01, -4.7099989571e-02, 5.2154168404e-01, 1.6608168209e-02], [-4.7099989571e-02, 1.1761534388e-02, -1.2987843074e-01, -4.1615942391e-03], [ 5.2154168404e-01, -1.2987843074e-01, 1.4653936514e+00, 1.5738321686e-02], [ 1.6608168209e-02, -4.1615942391e-03, 1.5738321686e-02, 4.2348042340e-02] ) Brown_x0 = GSL::Vector.alloc(25, 5, -5, -1) brown_f = Proc.new { |x, t, y, f| for i in 0...Brown_N ti = 0.2 * (i + 1); ui = x[0] + x[1] * ti - exp(ti); vi = x[2] + x[3] * sin(ti) - cos(ti); f[i] = ui*ui + vi*vi end GSL::SUCCESS } brown_df = Proc.new { |x, t, y, df| for i in 0...Brown_N ti = 0.2 * (i + 1); ui = x[0] + x[1] * ti - exp(ti); vi = x[2] + x[3] * sin(ti) - cos(ti); df.set(i, 0, 2.0*ui) df.set(i, 1, 2.0*ui*ti) df.set(i, 2, 2.0*vi) df.set(i, 3, 2.0*vi*sin(ti)) end GSL::SUCCESS } fdf = GSL::MultiFit::Function_fdf.alloc(brown_f, brown_df, Brown_P) fdf.set_data(GSL::Vector.alloc(Brown_N), GSL::Vector.alloc(Brown_N)) test_lmder(fdf, Brown_x0, Brown_X.vector_view, Brown_F, Brown_cov.vector_view) gsl-1.15.3/tests/const.rb0000755000175000017500000000114612220252463014564 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "const/test.c" require("gsl") require("./gsl_test.rb") include GSL::Test include Math include GSL::CONST GSL::IEEE::env_setup() c = MKSA::SPEED_OF_LIGHT eps = MKSA::VACUUM_PERMITTIVITY mu = MKSA::VACUUM_PERMEABILITY GSL::Test.test_rel(c, 1.0/sqrt(eps*mu), 1e-6, "speed of light (mks)") ly = CGSM::LIGHT_YEAR c = CGSM::SPEED_OF_LIGHT y = 365.2425 * CGSM::DAY GSL::Test.test_rel(ly, c * y, 1e-6, "light year (cgs)") micro = NUM::MICRO mega = NUM::MEGA kilo = NUM::KILO GSL::Test.test_rel(mega/kilo, 1/(micro*kilo), 1e-10, "kilo (mega/kilo, 1/(micro*kilo))"); gsl-1.15.3/tests/interp.rb0000755000175000017500000000206712220252463014742 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "interpolation/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math def test_bsearch() status = 0 x_array = GSL::Vector.alloc(0.0, 1.0, 2.0, 3.0, 4.0) index_result = Interp.bsearch(x_array, 1.5, 0, 4) s = (index_result != 1) ? 1 : 0 status += 1 test(s, "simple bsearch") index_result = x_array.bsearch(4.0, 0, 4) s = (index_result != 3) ? 1 : 0 status += s; test(s, "upper endpoint bsearch"); index_result = Interp.bsearch(x_array, 0.0, 0, 4); s = (index_result != 0) ? 1 : 0 status += s; test(s, "lower endpoint bsearch"); index_result = Interp.bsearch(x_array, 2.0, 0, 4); s = (index_result != 2) ? 1 : 0 status += s; test(s, "degenerate bsearch"); index_result = Interp.bsearch(x_array, 10.0, 0, 4); s = (index_result != 3) ? 1 : 0 status += s; test(s, "out of bounds bsearch +"); index_result = Interp.bsearch(x_array, -10.0, 0, 4); s = (index_result != 0) ? 1 : 0 status += s; test(s, "out of bounds bsearch -"); end test_bsearch() gsl-1.15.3/tests/multiset.rb0000755000175000017500000000367612220252463015316 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("./gsl_test2.rb") include GSL::Test exit if GSL::VERSION < "1.14" c63 = [ [ 0,0,0 ], [ 0,0,1 ], [ 0,0,2 ], [ 0,0,3 ], [ 0,0,4 ], [ 0,0,5 ], [ 0,1,1 ], [ 0,1,2 ], [ 0,1,3 ], [ 0,1,4 ], [ 0,1,5 ], [ 0,2,2 ], [ 0,2,3 ], [ 0,2,4 ], [ 0,2,5 ], [ 0,3,3 ], [ 0,3,4 ], [ 0,3,5 ], [ 0,4,4 ], [ 0,4,5 ], [ 0,5,5 ], [ 1,1,1 ], [ 1,1,2 ], [ 1,1,3 ], [ 1,1,4 ], [ 1,1,5 ], [ 1,2,2 ], [ 1,2,3 ], [ 1,2,4 ], [ 1,2,5 ], [ 1,3,3 ], [ 1,3,4 ], [ 1,3,5 ], [ 1,4,4 ], [ 1,4,5 ], [ 1,5,5 ], [ 2,2,2 ], [ 2,2,3 ], [ 2,2,4 ], [ 2,2,5 ], [ 2,3,3 ], [ 2,3,4 ], [ 2,3,5 ], [ 2,4,4 ], [ 2,4,5 ], [ 2,5,5 ], [ 3,3,3 ], [ 3,3,4 ], [ 3,3,5 ], [ 3,4,4 ], [ 3,4,5 ], [ 3,5,5 ], [ 4,4,4 ], [ 4,4,5 ], [ 4,5,5 ], [ 5,5,5 ]] c = GSL::Multiset::alloc(6, 3) c.init_first() i = 0 status = 0 while true if i >= 56 status = 1; break end for j in 0...3 do if c.data[j] != c63[i][j] ret = 0 else ret = 1 end status |= ret end s1 = c.valid GSL::Test::test(s1, "gsl_multiset_valid(#{i})") i += 1 break if c.next != GSL::SUCCESS end gsl-1.15.3/tests/gsl_test2.rb0000755000175000017500000000564312220252463015352 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL module GSL module Test Verbose = true $tests = 0 $passed = 0 $failed = 0 # PASS if status == 0, FAIL otherwise def test(status, desc) $tests += 1 if status == 0 $passed += 1 printf("PASS: #{desc}\n") else $failed += 1 printf("FAIL: #{desc}\n") end end # PASS if status == true, FAIL otherwise def test2(status, desc) $tests += 1 if status == true $passed += 1 printf("PASS: #{desc}\n") else $failed += 1 printf("FAIL: #{desc}\n") end end def test_factor(result, expected, factor, desc) status = nil if result == expected status = 0 elsif expected == 0.0 status = (result > expected or result < expected) ? 1 : 0 else u = result/expected status = (u > factor or u < 1.0/factor) ? 1 : 0 end $tests += 1 if status == 0 $passed += 1 printf("PASS: #{desc} (%g observed vs %g expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) end end def test_rel(result, expected, relerr, desc) status = nil if isnan?(result) or isnan?(expected) status = isnan?(result) != isnan?(expected) ? 1 : 0 elsif isinf?(result) or isinf?(expected) status = isinf?(result) != isinf?(expected) ? 1 : 0 elsif expected.to_f != 0.0 status = (result - expected).abs/expected.abs > relerr ? 1 : 0 else status = result.abs > relerr ? 1 : 0 end $tests += 1 if status == 0 $passed += 1 printf("PASS: #{desc} (%g observed vs %g expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) end end def test_abs(result, expected, abserr, desc) status = nil if isnan?(result) or isnan?(expected) status = isnan?(result) != isnan?(expected) ? 1 : 0 elsif isinf?(result) or isinf?(expected) status = isinf?(result) != isinf?(expected) ? 1 : 0 else status = (result - expected).abs > abserr ? 1 : 0 end $tests += 1 if status == 0 $passed += 1 printf("PASS: #{desc} (%g observed vs %g expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) end end def test_int(result, expected, desc) status = (result != expected) ? 1 : 0 $tests += 1 if status == 0 $passed += 1 printf("PASS: #{desc} (%d observed vs %d expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%d observed vs %d expected)\n", result, expected) end end end end gsl-1.15.3/tests/sum.rb0000755000175000017500000000420712220252463014243 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "sum/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math N = 50 def check_trunc(t, expected, desc) w = GSL::Sum::Levin_utrunc.alloc(N) sum_accel, err, = w.accel(t) desc2 = sprintf("trunc result, %s", desc) GSL::Test::test_rel(sum_accel, expected, 1e-8, desc2) end def check_full(t, expected, desc) w = GSL::Sum::Levin_u.alloc(N) sum_accel, err_est, = w.accel(t) desc2 = sprintf("full result, %s", desc) GSL::Test::test_rel(sum_accel, expected, 1e-8, desc2) sd_est = -log10(err_est/sum_accel.abs); sd_actual = -log10(GSL::DBL_EPSILON + ((sum_accel - expected)/expected).abs); desc2 = sprintf("full significant digits, %s (%g vs %g)", desc, sd_est, sd_actual) GSL::Test::test((sd_est > sd_actual + 1.0) ? 1 : 0, desc2) end GSL::IEEE::env_setup() Zeta_2 = M_PI*M_PI/6.0 t = GSL::Vector.alloc(N) for n in 0...N np1 = n + 1.0 t[n] = 1.0/(np1*np1) end check_trunc(t, Zeta_2, "zeta(2)") check_full(t, Zeta_2, "zeta(2)") x = 10.0 y = exp(x) t[0] = 1.0 for n in 1...N t[n] = t[n-1]*(x/n) end check_trunc(t, y, "exp(10)"); check_full(t, y, "exp(10)"); x = -10.0 y = exp(x) t[0] = 1.0 for n in 1...N t[n] = t[n-1]*(x/n) end check_trunc(t, y, "exp(-10)"); check_full(t, y, "exp(-10)"); x = 0.5 y = -log(1-x) t[0] = x for n in 1...N t[n] = t[n-1]*(x*n)/(n + 1.0) end check_trunc(t, y, "-log(1/2)") check_full(t, y, "-log(1/2)") x = -1.0 y = -log(1-x) t[0] = x for n in 1...N t[n] = t[n-1]*(x*n)/(n + 1.0) end check_trunc(t, y, "-log(2)") check_full(t, y, "-log(2)") result = 0.192594048773 t[0] = 3.0 / (M_PI * M_PI) for n in 1...N t[n] = -t[n - 1] * (4.0 * (n + 1.0) - 1.0) / (M_PI * M_PI) end check_trunc(t, result, "asymptotic series") check_full(t, result, "asymptotic series") result = 0.5772156649015328606065120900824; t[0] = 1.0; for n in 1...N t[n] = 1/(n+1.0) + log(n/(n+1.0)) end check_trunc(t, result, "Euler's constant") check_full(t, result, "Euler's constant") result = 0.6048986434216305 for n in 0...N t[n] = (n%2 == 1 ? -1 : 1) * 1.0 /sqrt(n + 1.0) end check_trunc(t, result, "eta(1/2)") check_full(t, result, "eta(1/2)") gsl-1.15.3/tests/rng.rb0000755000175000017500000002013212220252463014220 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "rng/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math N = 1000 N2 = 20000 GSL::IEEE::env_setup() GSL::Rng::env_setup() def rng_test(type, seed, n, result) r = GSL::Rng.alloc(type) if seed != 0; r.set(seed); end for i in 0...n k = r.get end status = (k != result) ? 1 : 0 GSL::Test::test(status, "#{r.name}, #{n} steps (#{k} observed vs #{result} expected)") end def rng_float_test(type) ri = GSL::Rng.alloc(type) rf = GSL::Rng.alloc(type) k = 0 status = 0 begin k = ri.get u = rf.get end while k == 0 c = k/u for i in 0...N2 k = ri.get u = rf.get if (c*k != u) status = 1 break end end GSL::Test::test(status, "#{ri.name}, ratio of int to double (#{c} observed vs #{k/u} expected)") end def rng_state_test(type) r = GSL::Rng.alloc(type) r_save = GSL::Rng.alloc(type) for i in 0...N; r.get; end GSL::Rng.memcpy(r_save, r) test_a = GSL::Vector.alloc(N) test_b = GSL::Vector.alloc(N) for i in 0...N; test_a[i] = r.get; end GSL::Rng.memcpy(r, r_save) for i in 0...N; test_b[i] = r.get; end status = 0 for i in 0...N status |= (test_b[i] != test_a[i]) ? 1 : 0 end GSL::Test::test(status, "#{r.name}, random number state consistency") end def rng_parallel_state_test(type) r1 = GSL::Rng.alloc(type) r2 = GSL::Rng.alloc(type) test_a = GSL::Vector.alloc(N) test_b = GSL::Vector.alloc(N) test_c = GSL::Vector.alloc(N) test_d = GSL::Vector.alloc(N) test_e = GSL::Vector.alloc(N) test_f = GSL::Vector.alloc(N) for i in 0...N; r1.get; end GSL::Rng.memcpy(r2, r1) for i in 0...N test_a[i] = r1.get test_b[i] = r2.get test_c[i] = r1.uniform_int(1234) test_d[i] = r2.uniform_int(1234) test_e[i] = r1.uniform test_f[i] = r2.uniform end status = 0 for i in 0...N status |= (test_b[i] != test_a[i]) ? 1 : 0 status |= (test_c[i] != test_d[i]) ? 1 : 0 status |= (test_e[i] != test_f[i]) ? 1 : 0 end GSL::Test::test(status, "#{r1.name}, parallel random number state consistency") end def rng_read_write_test(type) r = GSL::Rng.alloc(type) test_a = GSL::Vector.alloc(N) test_b = GSL::Vector.alloc(N) for i in 0...N; r.get; end r.fwrite("test.dat") for i in 0...N; test_a[i] = r.get; end r.fread("test.dat") for i in 0...N; test_b[i] = r.get; end status = 0 for i in 0...N status |= (test_b[i] != test_a[i]) ? 1 : 0 end GSL::Test::test(status, "#{r.name}, random number generator read and write") if FileTest.exist?("test.dat") File.delete("test.dat") end end def rng_max_test(r, ran_max) max = 0 for i in 0...N2 k = r.get if k > max; max = k; end end actual_uncovered = ran_max - max; expect_uncovered = ran_max.to_f / (N2.to_f); status = ((max > ran_max) || (actual_uncovered > 7 * expect_uncovered)) ? 1 : 0 return max, status; end def rng_min_test(r, ran_min, ran_max) min = 1000000000 for i in 0...N2 k = r.get if k < min; min = k; end end actual_uncovered = min - ran_min expect_uncovered = ran_max.to_f/(N2.to_f) status = ((min < ran_min) || (actual_uncovered > 7 * expect_uncovered)) ? 1 : 0 return min, status end def rng_sum_test(r) sum = 0.0 for i in 0...N2 x = r.uniform - 0.5 sum += x end sum = sum / (N2.to_f) sigma = sum*sqrt(12.0*N2) status = (sigma.abs > 3 || sigma.abs < 0.003) ? 1 : 0 if status == 1 fprintf(STDERR, "sum=%g, sigma=%g\n", sum. sigma) end return sigma, status end BINS = 17 EXTRA = 10 def rng_bin_test(r) count = GSL::Vector.calloc(BINS+EXTRA) chisq = 0.0 for i in 0...N2 j = r.uniform_int(BINS) count[j] = count[j] + 1 end for i in 0...BINS x = (N2.to_f)/(BINS) d = count[i] - x chisq += (d*d)/(x) end sigma = sqrt(chisq/(BINS)) status = (sigma.abs > 3 || sigma.abs < 0.003) ? 1 : 0 for i in BINS...EXTRA if count[i] != 0 status = 1 GSL::Test::test(status, "#{r.name}, wrote outside range in bin test (#{i} observed vs #{BINS-1} expected)") end end return sigma, status end def generic_rng_test(type) r = GSL::Rng.alloc(type) name = r.name kmax = 0 kmin = 1000 sigma = 0.0 ran_max = r.max ran_min = r.min kmax, status = rng_max_test(r, ran_max) GSL::Test::test(status, "#{name}, observed vs theoretical maximum (#{kmax} vs #{ran_max})") kmin, status = rng_min_test(r, ran_min, ran_max) GSL::Test::test(status, "#{name}, observed vs theoretical minimum (#{kmin} vs #{ran_min})") sigma, status = rng_sum_test(r) GSL::Test::test(status, "#{r.name}, sum test within acceptable sigma (observed #{sigma} sigma)") sigma, status = rng_bin_test(r) GSL::Test::test(status, "#{r.name}, bin test within acceptable chisq (observed #{sigma} sigma)") r.set(1) kmax, status = rng_max_test(r, ran_max) r.set(1) kmin, s = rng_min_test(r, ran_min, ran_max) status |= s r.set(1) sigma, s = rng_sum_test(r) status |= s r.set(12345) kmax, s = rng_max_test(r, ran_max) status |= s r.set(12345) kmin, s = rng_min_test(r, ran_min, ran_max) status |= s r.set(12345) sigma, s = rng_sum_test(r) status |= s GSL::Test::test(status, "#{r.name}, maximum and sum tests for non-default seeds") end rng_test("rand", 1, 10000, 1910041713); rng_test("randu", 1, 10000, 1623524161); rng_test("cmrg", 1, 10000, 719452880); rng_test("minstd", 1, 10000, 1043618065); rng_test("mrg", 1, 10000, 2064828650); rng_test("taus", 1, 10000, 2733957125); rng_test("taus113", 1, 1000, 1925420673); rng_test("transputer", 1, 10000, 1244127297); rng_test("vax", 1, 10000, 3051034865); rng_test("borosh13", 1, 10000, 2513433025); rng_test("fishman18", 1, 10000, 330402013); rng_test("fishman2x", 1, 10000, 540133597); rng_test("knuthran2", 1, 10000, 1084477620); rng_test("knuthran", 310952, 1009 * 2009 + 1, 461390032); rng_test("lecuyer21", 1, 10000, 2006618587); rng_test("waterman14", 1, 10000, 3776680385); rng_test("coveyou", 6, 10000, 1416754246); rng_test("fishman20", 6, 10000, 248127575); rng_test("ranlux", 314159265, 10000, 12077992); rng_test("ranlux389", 314159265, 10000, 165942); rng_test("ranlxs0", 1, 10000, 11904320); rng_test("ranlxs1", 1, 10000, 8734328); rng_test("ranlxs2", 1, 10000, 6843140); rng_test("ranlxd1", 1, 10000, 1998227290); rng_test("ranlxd2", 1, 10000, 3949287736); rng_test("slatec", 1, 10000, 45776); rng_test("uni", 1, 10000, 9214); rng_test("uni32", 1, 10000, 1155229825); rng_test("zuf", 1, 10000, 3970); rng_test("r250", 1, 10000, 1100653588); rng_test("mt19937", 4357, 1000, 1186927261); rng_test("mt19937_1999", 4357, 1000, 1030650439); rng_test("mt19937_1998", 4357, 1000, 1309179303); rng_test("tt800", 0, 10000, 2856609219); rng_test("ran0", 0, 10000, 1115320064); rng_test("ran1", 0, 10000, 1491066076); rng_test("ran2", 0, 10000, 1701364455); rng_test("ran3", 0, 10000, 186340785); rng_test("ranmar", 1, 10000, 14428370); rng_test("rand48", 0, 10000, 0xDE095043); rng_test("rand48", 1, 10000, 0xEDA54977); rng_test("random_glibc2", 0, 10000, 1908609430); rng_test("random8_glibc2", 0, 10000, 1910041713); rng_test("random32_glibc2", 0, 10000, 1587395585); rng_test("random64_glibc2", 0, 10000, 52848624); rng_test("random128_glibc2", 0, 10000, 1908609430); rng_test("random256_glibc2", 0, 10000, 179943260); rng_test("random_bsd", 0, 10000, 1457025928); rng_test("random8_bsd", 0, 10000, 1910041713); rng_test("random32_bsd", 0, 10000, 1663114331); rng_test("random64_bsd", 0, 10000, 864469165); rng_test("random128_bsd", 0, 10000, 1457025928); rng_test("random256_bsd", 0, 10000, 1216357476); rng_test("random_libc5", 0, 10000, 428084942); rng_test("random8_libc5", 0, 10000, 1910041713); rng_test("random32_libc5", 0, 10000, 1967452027); rng_test("random64_libc5", 0, 10000, 2106639801); rng_test("random128_libc5", 0, 10000, 428084942); rng_test("random256_libc5", 0, 10000, 116367984); rng_test("ranf", 0, 10000, 2152890433); rng_test("ranf", 2, 10000, 339327233); Rng.types.each do |type| rng_float_test(type) end Rng.types.each do |type| rng_state_test(type) end Rng.types.each do |type| rng_parallel_state_test(type) end Rng.types.each do |type| rng_read_write_test(type) end Rng.types.each do |type| generic_rng_test(type) end gsl-1.15.3/tests/narray/0000755000175000017500000000000012220252463014400 5ustar boutilboutilgsl-1.15.3/tests/narray/blas_dnrm2.rb0000755000175000017500000000104612220252463016754 0ustar boutilboutil#!/usr/bin/env ruby require 'rubygems' require 'narray' require 'gsl' require '../gsl_test.rb' include GSL::Test dbleps = 1e-6 expected = Math.sqrt((0..4).inject {|m,x| m+=x*x}) v = GSL::Vector.indgen(5) v_dnrm2 = GSL::Blas.dnrm2(v) GSL::Test.test_rel(v_dnrm2, expected, dbleps, "GSL::Blas.dnrm2(GSL::Vector)") na = NArray.float(5).indgen! na_dnrm2 = GSL::Blas.dnrm2(na) GSL::Test.test_rel(na_dnrm2, expected, dbleps, "GSL::Blas.dnrm2(NArray)") GSL::Test.test_rel(na_dnrm2, v_dnrm2, 0, "GSL::Blas.dnrm2(NArray) == GSL::Blas.dnrm2(GSL::Vector)") gsl-1.15.3/tests/stats_mt.rb0000644000175000017500000000044612220252463015273 0ustar boutilboutilrequire 'minitest/autorun' require 'gsl' class StatsTest < MiniTest::Unit::TestCase def test_variance_with_fixed_mean v = GSL::Vector[1..8] assert_raises(ArgumentError, 'check for no args') do # This exposes a segfault(!) v.variance_with_fixed_mean end end end gsl-1.15.3/tests/diff.rb0000755000175000017500000000463412220252463014353 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "diff/test.c" require("gsl") require("./gsl_test.rb") include GSL::Test include Math f1 = GSL::Function.alloc { |x| exp(x) } df1 = GSL::Function.alloc { |x| exp(x) } f2 = GSL::Function.alloc { |x| if x >= 0.0; x*sqrt(x); else; 0.0; end } df2 = GSL::Function.alloc { |x| if x >= 0.0; 1.5*sqrt(x); else; 0.0; end } f3 = GSL::Function.alloc { |x| if x != 0.0; sin(1.0/x); else; 0.0; end } df3 = GSL::Function.alloc { |x| if x != 0.0; -cos(1.0/x)/(x*x); else; 0.0; end } f4 = GSL::Function.alloc { |x| exp(-x*x) } df4 = GSL::Function.alloc { |x| -2.0*x*exp(-x*x) } f5 = GSL::Function.alloc { |x| x*x } df5 = GSL::Function.alloc { |x| 2.0*x } f6 = GSL::Function.alloc { |x| 1.0/x } df6 = GSL::Function.alloc { |x| -1.0/(x*x) } def test_diff(diff, f, df, x, desc) expected = df.eval(x) case diff when "central" result, abserr = f.diff_central(x) when "forward" result, abserr = f.diff_forward(x) when "backward" result, abserr = f.diff_backward(x) else raise("undefined operation") end GSL::Test::test_abs(result, expected, abserr, desc) desc2 = sprintf("%s, valid error estimate", desc) GSL::Test::test((result - expected).abs > abserr, desc2) end test_diff("central", f1, df1, 1.0, "exp(x), x=1, central diff") test_diff("forward", f1, df1, 1.0, "exp(x), x=1, forward diff") test_diff("backward", f1, df1, 1.0, "exp(x), x=1, backward diff") test_diff("central", f2, df2, 0.1, "x^(3/2), x=0.1, central diff") test_diff("forward", f2, df2, 0.1, "x^(3/2), x=0.1, forward diff") test_diff("backward", f2, df2, 0.1, "x^(3/2), x=0.1, backward diff") test_diff("central", f3, df3, 0.45, "sin(1/x), x=0.45, central diff") test_diff("forward", f3, df3, 0.45, "sin(1/x), x=0.45, forward diff") test_diff("backward", f3, df3, 0.45, "sin(1/x), x=0.45, backward diff") test_diff("central", f4, df4, 0.5, "exp(-x^2), x=0.5, central diff") test_diff("forward", f4, df4, 0.5, "exp(-x^2), x=0.5, forward diff") test_diff("backward", f4, df4, 0.5, "exp(-x^2), x=0.5, backward diff") test_diff("central", f5, df5, 0.0, "x^2, x=0, central diff") test_diff("forward", f5, df5, 0.0, "x^2, x=0, forward diff") test_diff("backward", f5, df5, 0.0, "x^2, x=0, backward diff") test_diff("central", f6, df6, 10.0, "1/x, x=10, central diff") test_diff("forward", f6, df6, 10.0, "1/x, x=10, forward diff") test_diff("backward", f6, df6, 10.0, "1/x, x=10, backward diff") gsl-1.15.3/tests/tensor.rb0000755000175000017500000002320412220252463014747 0ustar boutilboutil#!/usr/bin/env ruby # NOTE: gsl_tensor is not included in GSL: # It is distributed separately as an add-on package for GSL. # See http://sources.redhat.com/ml/gsl-discuss/2004-q4/msg00053.html. # require("gsl") require("./gsl_test2.rb") include GSL::Test exit unless GSL.const_defined?("Tensor") RANK = 3 DIMENSION = 5 t = GSL::Tensor.alloc(RANK, DIMENSION) Test::test2(t.rank == RANK, "#{t.class}.alloc returns valid rank") Test::test2(t.dimension == DIMENSION, "#{t.class}_alloc returns valid dimension") counter = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do counter += 1 t.set(i, j, k, counter) # t[i, j, k] = counter end end end status = 0 counter = 0 data = t.data # GSL::Vector::View for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do counter += 1 if data[DIMENSION*DIMENSION*i + DIMENSION*j + k] != counter status += 1 end end end end Test::test(status, "#{t.class}#set writes into array") status = 0 counter = 0 data = t.data for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do counter += 1 # if t.get(i, j, k) != counter if t[i, j, k] != counter status += 1 end end end end Test::test(status, "#{t.class}#get reads from array") t = Tensor.calloc(RANK, DIMENSION) counter = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do counter += 1 t.set(i, j, k, counter) end end end exp_max = t[0, 0, 0] exp_min = t[0, 0, 0] exp_imax = exp_jmax = exp_kmax = 0 exp_imin = exp_jmin = exp_kmin = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do value = t[i, j, k] if value > exp_max exp_max = value exp_imax = i; exp_jmax = j; exp_kmax = k end if value < exp_min exp_min = t[i, j, k] exp_imin = i; exp_jmin = j; exp_kmin = k end end end end max = t.max Test::test2(max == exp_max, "#{t.class}#max returns correct maximum value") min = t.min Test::test2(min == exp_min, "#{t.class}#min returns correct minimum value") min, max = t.minmax Test::test2(max == exp_max, "#{t.class}#minmax returns correct maximum value") Test::test2(min == exp_min, "#{t.class}#minmax returns correct minimum value") imax = t.max_index status = 0 if imax[0] != exp_imax; status += 1; end if imax[1] != exp_jmax; status += 1; end if imax[2] != exp_kmax; status += 1; end Test::test(status, "#{t.class}#max_index returns correct maximum indices") imin = t.min_index status = 0 if imin[0] != exp_imin; status += 1; end if imin[1] != exp_jmin; status += 1; end if imin[2] != exp_kmin; status += 1; end Test::test(status, "#{t.class}#min_index returns correct minimum indices") imin, imax = t.minmax_index status = 0 if imin[0] != exp_imin; status += 1; end if imin[1] != exp_jmin; status += 1; end if imin[2] != exp_kmin; status += 1; end if imax[0] != exp_imax; status += 1; end if imax[1] != exp_jmax; status += 1; end if imax[2] != exp_kmax; status += 1; end Test::test(status, "#{t.class}#minmax_index returns correct indices") ##### Operations a = Tensor.new(RANK, DIMENSION) b = Tensor.new(RANK, DIMENSION) for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do a[i, j, k] = 3 + i + 5 * j + 2 * k b[i, j, k] = 3 + 2 * i + 4 * j + k end end end # Addition c = a + b #c = a.add(b) status = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do r = c[i, j, k] x = a[i, j, k] y = b[i, j, k] z = x + y status += 1 if r != z end end end Test::test(status, "#{t.class}#add tensor addition") # Subtraction c = a - b # c = a.sub(b) status = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do r = c[i, j, k] x = a[i, j, k] y = b[i, j, k] z = x - y status += 1 if r != z end end end Test::test(status, "#{t.class}#sub tensor subtraction") # Element multiplication c = a.mul_elements(b) status = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do r = c[i, j, k] x = a[i, j, k] y = b[i, j, k] z = x * y status += 1 if r != z end end end Test::test(status, "#{t.class}#mul_elements element multiplication") # Element division c = a.div_elements(b) status = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do r = c[i, j, k] x = a[i, j, k] y = b[i, j, k] z = x / y if (r-z).abs > 2*GSL::FLT_EPSILON*z.abs; status += 1; end end end end Test::test(status, "#{t.class}#div_elements element division") ### Tensor product c = a*b status = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do for l in 0...DIMENSION do for m in 0...DIMENSION do for n in 0...DIMENSION do r = c[i, j, k, l, m, n] x = a[i, j, k] y = b[l, m, n] z = x*y if r != z; status += 1; end end end end end end end Test::test(status, "#{t.class}#product tensorial product") ### Index contraction tt = a.contract(0, 1) Test::test2(tt.rank == RANK-2, "#{t.class}.contract returns valid rank") Test::test2(tt.dimension == DIMENSION, "#{t.class}_contract returns valid dimension") ### Swap indices a_102 = a.swap_indices(0, 1) a_210 = a.swap_indices(0, 2) a_021 = a.swap_indices(1, 2) status = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do x = a[i, j, k] x_102 = a_102[j, i, k] x_210 = a_210[k, j, i] x_021 = a_021[i, k, j] if x != x_102 or x != x_210 or x != x_021; status += 1; end end end end Test::test(status, "#{t.class}#swap_indices swap indices") ### Test text IO file = "tensor_test.txt" t = Tensor.alloc(RANK, DIMENSION) counter = 0 for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do counter += 1 t[i, j, k] = counter end end end t.fprintf(file, "%g") tt = Tensor.alloc(RANK, DIMENSION) status = 0 tt.fscanf(file) counter = 0 data = tt.data for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do counter += 1 if data[DIMENSION*DIMENSION*i + DIMENSION*j + k] != counter status += 1 end end end end Test::test(status, "#{t.class}#fprintf and fscanf") File.delete(file) ### Test binary IO file = "tensor_test.dat" t.fwrite(file) tt = Tensor.alloc(RANK, DIMENSION) status = 0 tt.fread(file) counter = 0 data = tt.data for i in 0...DIMENSION do for j in 0...DIMENSION do for k in 0...DIMENSION do counter += 1 if data[DIMENSION*DIMENSION*i + DIMENSION*j + k] != counter status += 1 end end end end Test::test(status, "#{t.class}#fwrite and fread") File.delete(file) ### Trap i = j = k = 0 t = Tensor.calloc(RANK, DIMENSION) begin t[DIMENSION+1, 0, 0] = 1.2 rescue # if an exception occurred puts("PASS: #{t.class}#set traps 1st index above upper bound") end begin t[0, DIMENSION+1, 0] = 1.2 rescue puts("PASS: #{t.class}#set traps 2nd index above upper bound") end begin t[0, 0, DIMENSION+1] = 1.2 rescue puts("PASS: #{t.class}#set traps 3rd index above upper bound") end begin t[0, DIMENSION, 0] = 1.2 rescue puts("PASS: #{t.class}#set traps 2nd index at upper bound") end begin t[0, i-1, 0] = 1.2 rescue puts("PASS: #{t.class}#set traps 2nd index below lower bound") end begin x = t[DIMENSION+1, 0, 0] rescue puts("PASS: #{t.class}#get traps 1st index above upper bound") end begin x = t[0, DIMENSION+1, 0] rescue puts("PASS: #{t.class}#get traps 2nd index above upper bound") end begin x = t[0, 0, DIMENSION+1] rescue puts("PASS: #{t.class}#get traps 3rd index above upper bound") end begin x = t[0, DIMENSION, 0] rescue puts("PASS: #{t.class}#get traps 2nd index at upper bound") end begin x = t[0, i-1, 0] rescue puts("PASS: #{t.class}#get traps 2nd index below lower bound") end ##### # Vector and Tensor, subtensors #v = GSL::Vector.new(0...125) v = GSL::Vector.indgen(125) t = v.to_tensor(3, 5) Test::test2(t.rank == RANK, "#{v.class}.to_tensor(#{RANK}, #{DIMENSION}) returns valid rank") Test::test2(t.dimension == DIMENSION, "#{v.class}.to_tensor(#{RANK}, #{DIMENSION}) returns valid dimension") m0_exp = Matrix[0...25, 5, 5] m1_exp = Matrix[25...50, 5, 5] m2_exp = Matrix[50...75, 5, 5] m3_exp = Matrix[75...100, 5, 5] m4_exp = Matrix[100...125, 5, 5] # Create tensors of rank 2 t0 = t.subtensor(0) t1 = t[1] t2 = t.subtensor(2) t3 = t[3] t4 = t.subtensor(4) # 2-tensors can be compared directly with matrices Test::test2(t0 == m0_exp, "#{t.class}#subtensor(0) returns valid tensor") Test::test2(t1 == m1_exp, "#{t.class}#subtensor(1) returns valid tensor") Test::test2(t2 == m2_exp, "#{t.class}#subtensor(2) returns valid tensor") Test::test2(t3 == m3_exp, "#{t.class}#subtensor(3) returns valid tensor") Test::test2(t4 == m4_exp, "#{t.class}#subtensor(4) returns valid tensor") v0_exp = Vector[100...105] v1_exp = Vector[105...110] v2_exp = Vector[110...115] v3_exp = Vector[115...120] v4_exp = Vector[120...125] # Create tensors of rank1 v0 = t[4, 0] v1 = t[4][1] v2 = t.subtensor(4, 2) v3 = t4[3] v4 = t4.subtensor(4) # 1-tensors can be compared directly with vectors Test::test2(v0 == v0_exp, "#{t.class}#subtensor(4,0) returns valid tensor") Test::test2(v1 == v1_exp, "#{t.class}#subtensor(4,1) returns valid tensor") Test::test2(v2 == v2_exp, "#{t.class}#subtensor(4,2) returns valid tensor") Test::test2(v3 == v3_exp, "#{t.class}#subtensor(4,3) returns valid tensor") Test::test2(v4 == v4_exp, "#{t.class}#subtensor(4,4) returns valid tensor") gsl-1.15.3/tests/deriv.rb0000755000175000017500000000537312220252463014555 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "deriv/test.c" require("gsl") require("./gsl_test.rb") include GSL::Test include Math f1 = GSL::Function.alloc { |x| exp(x) } df1 = GSL::Function.alloc { |x| exp(x) } f2 = GSL::Function.alloc { |x| if x >= 0.0; x*sqrt(x); else; 0.0; end } df2 = GSL::Function.alloc { |x| if x >= 0.0; 1.5*sqrt(x); else; 0.0; end } f3 = GSL::Function.alloc { |x| if x != 0.0; sin(1.0/x); else; 0.0; end } df3 = GSL::Function.alloc { |x| if x != 0.0; -cos(1.0/x)/(x*x); else; 0.0; end } f4 = GSL::Function.alloc { |x| exp(-x*x) } df4 = GSL::Function.alloc { |x| -2.0*x*exp(-x*x) } f5 = GSL::Function.alloc { |x| x*x } df5 = GSL::Function.alloc { |x| 2.0*x } f6 = GSL::Function.alloc { |x| 1.0/x } df6 = GSL::Function.alloc { |x| -1.0/(x*x) } def test_deriv(deriv, f, df, x, desc) expected = df.eval(x) h = 1e-4 case deriv when "central" result, abserr = f.deriv_central(x, h) when "forward" result, abserr = f.deriv_forward(x, h) when "backward" result, abserr = f.deriv_backward(x, h) else raise("undefined operation") end GSL::Test::test_abs(result, expected, GSL::MIN(h, expected.abs) + GSL::DBL_EPSILON, desc) if abserr < (result - expected).abs GSL::Test::test_factor(abserr, (result - expected).abs, 2, desc + " error estimate") elsif result == expected or expected == 0.0 GSL::Test::test_abs(abserr, 0.0, 1e-6, desc + " abserr") else d = (result - expected).abs GSL::Test::test_abs(abserr, (result - expected).abs, 1e6*d, desc + " abserr") end end test_deriv("central", f1, df1, 1.0, "exp(x), x=1, central deriv") test_deriv("forward", f1, df1, 1.0, "exp(x), x=1, forward deriv") test_deriv("backward", f1, df1, 1.0, "exp(x), x=1, backward deriv") test_deriv("central", f2, df2, 0.1, "x^(3/2), x=0.1, central deriv") test_deriv("forward", f2, df2, 0.1, "x^(3/2), x=0.1, forward deriv") test_deriv("backward", f2, df2, 0.1, "x^(3/2), x=0.1, backward deriv") test_deriv("central", f3, df3, 0.45, "sin(1/x), x=0.45, central deriv") test_deriv("forward", f3, df3, 0.45, "sin(1/x), x=0.45, forward deriv") test_deriv("backward", f3, df3, 0.45, "sin(1/x), x=0.45, backward deriv") test_deriv("central", f4, df4, 0.5, "exp(-x^2), x=0.5, central deriv") test_deriv("forward", f4, df4, 0.5, "exp(-x^2), x=0.5, forward deriv") test_deriv("backward", f4, df4, 0.5, "exp(-x^2), x=0.5, backward deriv") test_deriv("central", f5, df5, 0.0, "x^2, x=0, central deriv") test_deriv("forward", f5, df5, 0.0, "x^2, x=0, forward deriv") test_deriv("backward", f5, df5, 0.0, "x^2, x=0, backward deriv") test_deriv("central", f6, df6, 10.0, "1/x, x=10, central deriv") test_deriv("forward", f6, df6, 10.0, "1/x, x=10, forward deriv") test_deriv("backward", f6, df6, 10.0, "1/x, x=10, backward deriv") gsl-1.15.3/tests/multimin.rb0000755000175000017500000000733412220252463015301 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "multimin/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math def test_fdf(desc, f, initpt, type) x = eval("#{initpt}") step_size = 0.1*Blas.dnrm2(x) s = GSL::MultiMin::FdfMinimizer.alloc(type, f.n) s.set(f, x, step_size, 0.1) iter = 0 begin iter += 1 status = s.iterate status = GSL::MultiMin.test_gradient(s.gradient, 1e-3) end while iter < 5000 and status == GSL::CONTINUE status |= s.f.abs > 1e-5 ? 1 : 0 GSL::Test::test(status, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.f}") end def test_f(desc, f, initpt) x = eval("#{initpt}") step_size = GSL::Vector.alloc(f.n) for i in 0...f.n step_size[i] = 1 end s = GSL::MultiMin::FMinimizer.alloc("nmsimplex", f.n) s.set(f, x, step_size) iter = 0 begin status = s.iterate status = GSL::MultiMin.test_size(s.size, 1e-3) end while iter < 5000 and status == GSL::CONTINUE status |= s.fval.abs > 1e-5 ? 1 : 0 GSL::Test::test(status, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.fval}") s = GSL::MultiMin::FMinimizer.alloc("nmsimplex2rand", f.n) s.set(f, x, step_size) iter = 0 begin status = s.iterate status = GSL::MultiMin.test_size(s.size, 1e-3) end while iter < 5000 and status == GSL::CONTINUE status |= s.fval.abs > 1e-5 ? 1 : 0 GSL::Test::test(status, "#{s.name}, on #{desc}: #{iter} iterations, f(x)=#{s.fval}") end def roth_initpt return GSL::Vector.alloc(4.5, 3.5) end def wood_initpt return GSL::Vector.alloc(-3.0, -1.0, -3.0, -1.0) end def rosenbrock_initpt return GSL::Vector.alloc(-1.2, 1.0) end Roth_f = Proc.new { |x| u = x[0] v = x[1] a = -13.0 + u + ((5.0 - v)*v - 2.0)*v; b = -29.0 + u + ((v + 1.0)*v - 14.0)*v; a * a + b * b; } Roth_df = Proc.new { |x, df| u = x[0] v = x[1] a = -13.0 + u + ((5.0 - v)*v - 2.0)*v b = -29.0 + u + ((v + 1.0)*v - 14.0)*v c = -2 + v * (10 - 3 * v) d = -14 + v * (2 + 3 * v) df[0] = 2 * a + 2 * b df[1] = 2 * a * c + 2 * b * d } Wood_f = Proc.new { |x| u1 = x[0]; u2 = x[1]; u3 = x[2]; u4 = x[3] t1 = u1*u1 - u2 t2 = u3*u3 - u4 100 * t1 * t1 + (1 - u1) * (1 - u1) + 90 * t2 * t2 + (1 - u3) * (1 - u3) + 10.1 * ( (1 - u2) * (1 - u2) + (1 - u4) * (1 - u4) ) + 19.8 * (1 - u2) * (1 - u4) } Wood_df = Proc.new { |x, df| u1 = x[0]; u2 = x[1]; u3 = x[2]; u4 = x[3] t1 = u1*u1 - u2 t2 = u3*u3 - u4 df[0] = 400 * u1 * t1 - 2 * (1 - u1) df[1] = -200 * t1 - 20.2 * (1 - u2) - 19.8 * (1 - u4) df[2] = 360 * u3 * t2 - 2 * (1 - u3) df[3] = -180 * t2 - 20.2 * (1 - u4) - 19.8 * (1 - u2) } Rosenbrock_f = Proc.new { |x| u = x[0]; v = x[1] a = u - 1 b = u*u - v a*a + 10.0*b*b } Rosenbrock_df = Proc.new { |x, df| u = x[0]; v = x[1] a = u - 1 b = u*u - v df[0] = 2 * (u - 1) + 40 * u * b df[1] = -20 * b } if GSL::GSL_VERSION >= "1.8.90" fdfminimizers = ["steepest_descent", "conjugate_pr", "conjugate_fr", "vector_bfgs", "vector_bfgs2"] else fdfminimizers = ["steepest_descent", "conjugate_pr", "conjugate_fr", "vector_bfgs"] end Rothdf = GSL::MultiMin::Function_fdf.alloc(Roth_f, Roth_df, 2) Wooddf = GSL::MultiMin::Function_fdf.alloc(Wood_f, Wood_df, 4) Rosenbrockdf = GSL::MultiMin::Function_fdf.alloc(Rosenbrock_f, Rosenbrock_df, 2) fdfminimizers.each do |t| test_fdf("Roth", Rothdf, "roth_initpt", t) test_fdf("Wood", Wooddf, "wood_initpt", t) test_fdf("Rosenbrock", Rosenbrockdf, "rosenbrock_initpt", t) end rothf = GSL::MultiMin::Function.alloc(Roth_f, 2) test_f("Roth", rothf, "roth_initpt") woodf = GSL::MultiMin::Function.alloc(Wood_f, 4) test_f("Wood", woodf, "wood_initpt") rosenbrockf = GSL::MultiMin::Function.alloc(Rosenbrock_f, 2) test_f("Rosenbrock", rosenbrockf, "rosenbrock_initpt") gsl-1.15.3/tests/cdf.rb0000755000175000017500000036761512220252463014212 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("./gsl_test.rb") include GSL::Test include Math TEST_TOL0 = 2.0*GSL::DBL_EPSILON TEST_TOL1 = 16.0*GSL::DBL_EPSILON TEST_TOL2 = 256.0*GSL::DBL_EPSILON TEST_TOL3 = 2048.0*GSL::DBL_EPSILON TEST_TOL4 = 16384.0*GSL::DBL_EPSILON TEST_TOL5 = 131072.0*GSL::DBL_EPSILON TEST_TOL6 = 1048576.0*GSL::DBL_EPSILON def TEST(func, args, value, tol) res = eval("#{func}#{args}") GSL::Test::test_rel(res, value, tol, func+args) end TEST("GSL::Cdf::ugaussian_P", "(0.0)", 0.5, TEST_TOL0) TEST("GSL::Cdf::ugaussian_P", "(1e-32)", 0.5, TEST_TOL0) TEST("GSL::Cdf::ugaussian_P", "(0.5)", 0.6914624612740131036377046105, TEST_TOL0) TEST("GSL::Cdf::ugaussian_P", "(0.7)", 0.7580363477769269852506495717, TEST_TOL0) TEST("GSL::Cdf::ugaussian_Q", "(0.0)", 0.5, TEST_TOL0) TEST("GSL::Cdf::ugaussian_Q", "(1e-32)", 0.5, TEST_TOL0) TEST("GSL::Cdf::ugaussian_Q", "(0.5)", 0.3085375387259868963622953894, TEST_TOL0) TEST("GSL::Cdf::ugaussian_Q", "(0.7)", 0.2419636522230730147493504282, TEST_TOL0) TEST("GSL::Cdf::ugaussian_Q", "(5.0)", 0.0000002866515718791939116737523329, TEST_TOL0) TEST("GSL::Cdf::ugaussian_Pinv", "(0.9999997133)", 5.0, 1e-4) TEST("GSL::Cdf::ugaussian_Pinv", "(0.539827837277029)", 0.1, 1e-4) TEST("GSL::Cdf::ugaussian_Qinv", "(2.86648e-7)", 5.0, 1e-4) TEST("GSL::Cdf::ugaussian_Qinv", "(2.2750131948179e-2)", 2.0, 1e-14) TEST("GSL::Cdf::ugaussian_Qinv", "(4.60172162722971e-1)", 0.1, TEST_TOL1) TEST("GSL::Cdf::exponential_P", "(0.1, 0.7)", 1.33122100249818372e-1, TEST_TOL0) TEST("GSL::Cdf::exponential_Q", "(0.1, 0.7)", 8.66877899750181628e-1, TEST_TOL0) TEST("GSL::Cdf::exponential_Pinv", "(0.13, 0.7)", 9.74834471334553546e-2, TEST_TOL0) TEST("GSL::Cdf::exponential_Qinv", "(0.86, 0.7)", 1.05576022814208545e-1, TEST_TOL0) TEST("GSL::Cdf::tdist_P", "(0.0, 1.0)", 0.5, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(0.325, 1.0)", 6.00023120032852123e-1, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(10000.0, 1.0)", 9.99968169011487724e-1, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(0.0, 1.0)", 0.5, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(0.325, 1.0)", 3.99976879967147876e-1, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(0.325, 2.0)", 6.11985772746873767e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(0.325, 2.0)", 3.88014227253126233e-1, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(0.325, 1.2, 1.3)", 3.14130045246195449e-1, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(0.325, 1.2, 1.3)", 6.85869954753804551e-1, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(0.325, 1.0, 1.0)", 2.77472646357927811e-1, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(0.325, 1.0, 1.0)", 7.22527353642072189e-1, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(10.0, 13.0)", 3.06065632019251110e-1, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(10.0, 13.0)", 6.93934367980748890e-1, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(0.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000000e-10,1.3,2.7)", 3.329258013904e-13, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000001e-09,1.3,2.7)", 6.642743046207e-12, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000000e-08,1.3,2.7)", 1.325401475350e-10, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(9.9999999999999995e-08,1.3,2.7)", 2.644523387276e-09, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(9.9999999999999995e-07,1.3,2.7)", 5.276513292646e-08, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000001e-05,1.3,2.7)", 1.052793708285e-06, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000000e-04,1.3,2.7)", 2.100417958505e-05, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000000e-03,1.3,2.7)", 4.187261218400e-04, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000000e-02,1.3,2.7)", 8.282559388393e-03, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000001e-01,1.3,2.7)", 1.512194578010e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(2.0000000000000001e-01,1.3,2.7)", 3.358123280407e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(2.9999999999999999e-01,1.3,2.7)", 5.104163996495e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(4.0000000000000002e-01,1.3,2.7)", 6.620682399410e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(5.0000000000000000e-01,1.3,2.7)", 7.852786981833e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(5.9999999999999998e-01,1.3,2.7)", 8.784005878950e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(8.0000000000000004e-01,1.3,2.7)", 9.801824171406e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(9.0000000000000002e-01,1.3,2.7)", 9.968736852365e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(9.8999999999999999e-01,1.3,2.7)", 9.999936324464e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(9.9900000000000000e-01,1.3,2.7)", 9.999999872699e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(9.9990000000000001e-01,1.3,2.7)", 9.999999999746e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(9.9999000000000005e-01,1.3,2.7)", 9.999999999999e-01, TEST_TOL6) TEST("GSL::Cdf::beta_P", "(1.0000000000000000e+00,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(9.9999000000000005e-01,1.3,2.7)", 5.069044353228e-14, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(9.9990000000000001e-01,1.3,2.7)", 2.540490259443e-11, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(9.9900000000000000e-01,1.3,2.7)", 1.273010336738e-08, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(9.8999999999999999e-01,1.3,2.7)", 6.367553598351e-06, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(9.0000000000000002e-01,1.3,2.7)", 3.126314763488e-03, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(8.0000000000000004e-01,1.3,2.7)", 1.981758285937e-02, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(5.9999999999999998e-01,1.3,2.7)", 1.215994121050e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(5.0000000000000000e-01,1.3,2.7)", 2.147213018167e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(4.0000000000000002e-01,1.3,2.7)", 3.379317600590e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(2.9999999999999999e-01,1.3,2.7)", 4.895836003505e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(2.0000000000000001e-01,1.3,2.7)", 6.641876719593e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000001e-01,1.3,2.7)", 8.487805421990e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000000e-02,1.3,2.7)", 9.917174406116e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000000e-03,1.3,2.7)", 9.995812738782e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000000e-04,1.3,2.7)", 9.999789958204e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000001e-05,1.3,2.7)", 9.999989472063e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(9.9999999999999995e-07,1.3,2.7)", 9.999999472349e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(9.9999999999999995e-08,1.3,2.7)", 9.999999973555e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000000e-08,1.3,2.7)", 9.999999998675e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000001e-09,1.3,2.7)", 9.999999999934e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(1.0000000000000000e-10,1.3,2.7)", 9.999999999997e-01, TEST_TOL6) TEST("GSL::Cdf::beta_Q", "(0.0000000000000000e+00,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(0.0000000000000000e+00,5.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e-10,5.3,2.7)", 3.231380663090e-26, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000001e-09,5.3,2.7)", 1.443404714791e-23, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e-08,5.3,2.7)", 6.447451698511e-21, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(9.9999999999999995e-08,5.3,2.7)", 2.879969407315e-18, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(9.9999999999999995e-07,5.3,2.7)", 1.286428479993e-15, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000001e-05,5.3,2.7)", 5.745970138195e-13, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e-04,5.3,2.7)", 2.565314230632e-10, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e-03,5.3,2.7)", 1.140026203760e-07, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e-02,5.3,2.7)", 4.840333162527e-05, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000001e-01,5.3,2.7)", 1.360698992545e-02, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+00,5.3,2.7)", 4.532720490874e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+01,5.3,2.7)", 9.461328174717e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+02,5.3,2.7)", 9.973356976994e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+03,5.3,2.7)", 9.998797338050e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+04,5.3,2.7)", 9.999946222456e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+05,5.3,2.7)", 9.999997597592e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+06,5.3,2.7)", 9.999999892687e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+07,5.3,2.7)", 9.999999995207e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+08,5.3,2.7)", 9.999999999786e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+09,5.3,2.7)", 9.999999999990e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_P", "(1.0000000000000000e+10,5.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+10,5.3,2.7)", 4.272202262298e-14, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+09,5.3,2.7)", 9.564269502770e-13, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+08,5.3,2.7)", 2.141173208523e-11, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+07,5.3,2.7)", 4.793489218238e-10, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+06,5.3,2.7)", 1.073127433440e-08, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+05,5.3,2.7)", 2.402407758939e-07, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+04,5.3,2.7)", 5.377754447932e-06, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+03,5.3,2.7)", 1.202661950234e-04, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+02,5.3,2.7)", 2.664302300604e-03, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+01,5.3,2.7)", 5.386718252832e-02, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e+00,5.3,2.7)", 5.467279509126e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000001e-01,5.3,2.7)", 9.863930100746e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e-02,5.3,2.7)", 9.999515966684e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e-03,5.3,2.7)", 9.999998859974e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e-04,5.3,2.7)", 9.999999997435e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000001e-05,5.3,2.7)", 9.999999999994e-01, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(9.9999999999999995e-07,5.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(9.9999999999999995e-08,5.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e-08,5.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000001e-09,5.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(1.0000000000000000e-10,5.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::fdist_Q", "(0.0000000000000000e+00,5.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+10,1.3)", 4.138028520389e-11, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380285203892783e-11,1.3)", -1.000000000000e+10, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+09,1.3)", 4.138028520389e-10, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380285203892792e-10,1.3)", -1.000000000000e+09, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+08,1.3)", 4.138028520389e-09, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380285203892787e-09,1.3)", -1.000000000000e+08, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+07,1.3)", 4.138028520389e-08, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380285203892555e-08,1.3)", -1.000000000000e+07, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+06,1.3)", 4.138028520387e-07, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380285203869488e-07,1.3)", -1.000000000000e+06, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+05,1.3)", 4.138028520156e-06, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380285201561693e-06,1.3)", -1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+04,1.3)", 4.138028497078e-05, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380284970783855e-05,1.3)", -1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+03,1.3)", 4.138026189302e-04, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1380261893022424e-04,1.3)", -1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+02,1.3)", 4.137795435084e-03, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1377954350836910e-03,1.3)", -1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+01,1.3)", 4.114951182497e-02, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.1149511824973506e-02,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e+00,1.3)", 2.912855998398e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(2.9128559983984725e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000001e-01,1.3)", 4.755627480278e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.7556274802780252e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e-02,1.3)", 4.975515107069e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.9755151070688325e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e-03,1.3)", 4.997551462897e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(4.9975514628969159e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e-04,1.3)", 4.999755146242e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000001e-05,1.3)", 4.999975514624e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-9.9999999999999995e-07,1.3)", 4.999997551462e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-9.9999999999999995e-08,1.3)", 4.999999755146e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e-08,1.3)", 4.999999975515e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000001e-09,1.3)", 4.999999997551e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(-1.0000000000000000e-10,1.3)", 4.999999999755e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(5.0000000000000011e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e-10,1.3)", 5.000000000245e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000001e-09,1.3)", 5.000000002449e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e-08,1.3)", 5.000000024485e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(9.9999999999999995e-08,1.3)", 5.000000244854e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(9.9999999999999995e-07,1.3)", 5.000002448538e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000001e-05,1.3)", 5.000024485376e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e-04,1.3)", 5.000244853758e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e-03,1.3)", 5.002448537103e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(5.0024485371030836e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e-02,1.3)", 5.024484892931e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(5.0244848929311670e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000001e-01,1.3)", 5.244372519722e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(5.2443725197219748e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+00,1.3)", 7.087144001602e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(7.0871440016015275e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+01,1.3)", 9.588504881750e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(9.5885048817502649e-01,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+02,1.3)", 9.958622045649e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(9.9586220456491636e-01,1.3)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+03,1.3)", 9.995861973811e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Pinv", "(9.9958619738106980e-01,1.3)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+04,1.3)", 9.999586197150e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+05,1.3)", 9.999958619715e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+06,1.3)", 9.999995861971e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+07,1.3)", 9.999999586197e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+08,1.3)", 9.999999958620e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+09,1.3)", 9.999999995862e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_P", "(1.0000000000000000e+10,1.3)", 9.999999999586e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+10,1.3)", 4.138028520389e-11, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380285203892783e-11,1.3)", 1.000000000000e+10, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+09,1.3)", 4.138028520389e-10, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380285203892792e-10,1.3)", 1.000000000000e+09, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+08,1.3)", 4.138028520389e-09, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380285203892787e-09,1.3)", 1.000000000000e+08, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+07,1.3)", 4.138028520389e-08, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380285203892555e-08,1.3)", 1.000000000000e+07, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+06,1.3)", 4.138028520387e-07, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380285203869488e-07,1.3)", 1.000000000000e+06, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+05,1.3)", 4.138028520156e-06, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380285201561693e-06,1.3)", 1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+04,1.3)", 4.138028497078e-05, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380284970783855e-05,1.3)", 1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+03,1.3)", 4.138026189302e-04, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1380261893022424e-04,1.3)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+02,1.3)", 4.137795435084e-03, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1377954350836910e-03,1.3)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+01,1.3)", 4.114951182497e-02, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.1149511824973506e-02,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e+00,1.3)", 2.912855998398e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(2.9128559983984725e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000001e-01,1.3)", 4.755627480278e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.7556274802780252e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e-02,1.3)", 4.975515107069e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.9755151070688325e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e-03,1.3)", 4.997551462897e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(4.9975514628969159e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e-04,1.3)", 4.999755146242e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000001e-05,1.3)", 4.999975514624e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(9.9999999999999995e-07,1.3)", 4.999997551462e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(9.9999999999999995e-08,1.3)", 4.999999755146e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e-08,1.3)", 4.999999975515e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000001e-09,1.3)", 4.999999997551e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(1.0000000000000000e-10,1.3)", 4.999999999755e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(5.0000000000000011e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e-10,1.3)", 5.000000000245e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000001e-09,1.3)", 5.000000002449e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e-08,1.3)", 5.000000024485e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-9.9999999999999995e-08,1.3)", 5.000000244854e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-9.9999999999999995e-07,1.3)", 5.000002448538e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000001e-05,1.3)", 5.000024485376e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e-04,1.3)", 5.000244853758e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e-03,1.3)", 5.002448537103e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(5.0024485371030836e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e-02,1.3)", 5.024484892931e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(5.0244848929311670e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000001e-01,1.3)", 5.244372519722e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(5.2443725197219748e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+00,1.3)", 7.087144001602e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(7.0871440016015275e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+01,1.3)", 9.588504881750e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(9.5885048817502649e-01,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+02,1.3)", 9.958622045649e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(9.9586220456491636e-01,1.3)", -1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+03,1.3)", 9.995861973811e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Qinv", "(9.9958619738106980e-01,1.3)", -1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+04,1.3)", 9.999586197150e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+05,1.3)", 9.999958619715e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+06,1.3)", 9.999995861971e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+07,1.3)", 9.999999586197e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+08,1.3)", 9.999999958620e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+09,1.3)", 9.999999995862e-01, TEST_TOL6) TEST("GSL::Cdf::cauchy_Q", "(-1.0000000000000000e+10,1.3)", 9.999999999586e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+03,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+02,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+01,1.3)", 7.225229227927e-15, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(7.2252292279265077e-15,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e+00,1.3)", 2.208781637125e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(2.2087816371245972e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000001e-01,1.3)", 4.693423696034e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(4.6934236960338749e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e-02,1.3)", 4.969312434916e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(4.9693124349158196e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e-03,1.3)", 4.996931213530e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(4.9969312135303229e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e-04,1.3)", 4.999693121323e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000001e-05,1.3)", 4.999969312132e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-9.9999999999999995e-07,1.3)", 4.999996931213e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-9.9999999999999995e-08,1.3)", 4.999999693121e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e-08,1.3)", 4.999999969312e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000001e-09,1.3)", 4.999999996931e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(-1.0000000000000000e-10,1.3)", 4.999999999693e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(5.0000000000000000e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e-10,1.3)", 5.000000000307e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000001e-09,1.3)", 5.000000003069e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e-08,1.3)", 5.000000030688e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(9.9999999999999995e-08,1.3)", 5.000000306879e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(9.9999999999999995e-07,1.3)", 5.000003068787e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000001e-05,1.3)", 5.000030687868e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e-04,1.3)", 5.000306878677e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e-03,1.3)", 5.003068786470e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(5.0030687864696777e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e-02,1.3)", 5.030687565084e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(5.0306875650841798e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000001e-01,1.3)", 5.306576303966e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(5.3065763039661251e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+00,1.3)", 7.791218362875e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Pinv", "(7.7912183628754028e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+01,1.3)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_P", "(1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+03,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+02,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+01,1.3)", 7.225229227927e-15, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(7.2252292279265077e-15,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e+00,1.3)", 2.208781637125e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(2.2087816371245972e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000001e-01,1.3)", 4.693423696034e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(4.6934236960338749e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e-02,1.3)", 4.969312434916e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(4.9693124349158196e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e-03,1.3)", 4.996931213530e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(4.9969312135303229e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e-04,1.3)", 4.999693121323e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000001e-05,1.3)", 4.999969312132e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(9.9999999999999995e-07,1.3)", 4.999996931213e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(9.9999999999999995e-08,1.3)", 4.999999693121e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e-08,1.3)", 4.999999969312e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000001e-09,1.3)", 4.999999996931e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(1.0000000000000000e-10,1.3)", 4.999999999693e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(5.0000000000000000e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e-10,1.3)", 5.000000000307e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000001e-09,1.3)", 5.000000003069e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e-08,1.3)", 5.000000030688e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-9.9999999999999995e-08,1.3)", 5.000000306879e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-9.9999999999999995e-07,1.3)", 5.000003068787e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000001e-05,1.3)", 5.000030687868e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e-04,1.3)", 5.000306878677e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e-03,1.3)", 5.003068786470e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(5.0030687864696777e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e-02,1.3)", 5.030687565084e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(5.0306875650841798e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000001e-01,1.3)", 5.306576303966e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(5.3065763039661251e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+00,1.3)", 7.791218362875e-01, TEST_TOL6) TEST("GSL::Cdf::gaussian_Qinv", "(7.7912183628754028e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+01,1.3)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gaussian_Q", "(-1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+03,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+02,1.3)", 1.957501779912e-34, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(1.9575017799122328e-34,1.3)", -1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+01,1.3)", 2.281619502905e-04, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(2.2816195029051560e-04,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e+00,1.3)", 2.316846846156e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(2.3168468461558764e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000001e-01,1.3)", 4.629805393212e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(4.6298053932115801e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e-02,1.3)", 4.961686011956e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(4.9616860119557432e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e-03,1.3)", 4.996155325065e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(4.9961553250645546e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e-04,1.3)", 4.999615399408e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000001e-05,1.3)", 4.999961538609e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-9.9999999999999995e-07,1.3)", 4.999996153848e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-9.9999999999999995e-08,1.3)", 4.999999615385e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e-08,1.3)", 4.999999961538e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000001e-09,1.3)", 4.999999996154e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(-1.0000000000000000e-10,1.3)", 4.999999999615e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(5.0000000000000000e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e-10,1.3)", 5.000000000385e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000001e-09,1.3)", 5.000000003846e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e-08,1.3)", 5.000000038462e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(9.9999999999999995e-08,1.3)", 5.000000384615e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(9.9999999999999995e-07,1.3)", 5.000003846152e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000001e-05,1.3)", 5.000038461391e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e-04,1.3)", 5.000384600592e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e-03,1.3)", 5.003844674935e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(5.0038446749354448e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e-02,1.3)", 5.038313988044e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(5.0383139880442562e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000001e-01,1.3)", 5.370194606788e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(5.3701946067884199e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+00,1.3)", 7.683153153844e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(7.6831531538441233e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+01,1.3)", 9.997718380497e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Pinv", "(9.9977183804970948e-01,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_P", "(1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+03,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+02,1.3)", 1.957501779912e-34, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(1.9575017799122328e-34,1.3)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+01,1.3)", 2.281619502905e-04, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(2.2816195029051560e-04,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e+00,1.3)", 2.316846846156e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(2.3168468461558764e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000001e-01,1.3)", 4.629805393212e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(4.6298053932115801e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e-02,1.3)", 4.961686011956e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(4.9616860119557432e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e-03,1.3)", 4.996155325065e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(4.9961553250645546e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e-04,1.3)", 4.999615399408e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000001e-05,1.3)", 4.999961538609e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(9.9999999999999995e-07,1.3)", 4.999996153848e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(9.9999999999999995e-08,1.3)", 4.999999615385e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e-08,1.3)", 4.999999961538e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000001e-09,1.3)", 4.999999996154e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(1.0000000000000000e-10,1.3)", 4.999999999615e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(5.0000000000000000e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e-10,1.3)", 5.000000000385e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000001e-09,1.3)", 5.000000003846e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e-08,1.3)", 5.000000038462e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-9.9999999999999995e-08,1.3)", 5.000000384615e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-9.9999999999999995e-07,1.3)", 5.000003846152e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000001e-05,1.3)", 5.000038461391e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e-04,1.3)", 5.000384600592e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e-03,1.3)", 5.003844674935e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(5.0038446749354448e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e-02,1.3)", 5.038313988044e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(5.0383139880442562e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000001e-01,1.3)", 5.370194606788e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(5.3701946067884199e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+00,1.3)", 7.683153153844e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(7.6831531538441233e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+01,1.3)", 9.997718380497e-01, TEST_TOL6) TEST("GSL::Cdf::laplace_Qinv", "(9.9977183804970948e-01,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::laplace_Q", "(-1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(0.0000000000000000e+00,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e-10,1.3)", 2.958579881657e-21, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585798816568050e-21,1.3)", 1.000000000000e-10, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000001e-09,1.3)", 2.958579881657e-19, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585798816568049e-19,1.3)", 1.000000000000e-09, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e-08,1.3)", 2.958579881657e-17, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585798816568048e-17,1.3)", 1.000000000000e-08, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(9.9999999999999995e-08,1.3)", 2.958579881657e-15, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585798816568001e-15,1.3)", 1.000000000000e-07, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(9.9999999999999995e-07,1.3)", 2.958579881656e-13, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585798816563665e-13,1.3)", 1.000000000000e-06, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000001e-05,1.3)", 2.958579881613e-11, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585798816130393e-11,1.3)", 1.000000000000e-05, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e-04,1.3)", 2.958579877280e-09, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585798772802076e-09,1.3)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e-03,1.3)", 2.958579443997e-07, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585794439971025e-07,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e-02,1.3)", 2.958536116114e-05, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9585361161138382e-05,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000001e-01,1.3)", 2.954207597179e-03, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.9542075971792496e-03,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+00,1.3)", 2.561069378624e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Pinv", "(2.5610693786235361e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+01,1.3)", 9.999999999999e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_P", "(1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+03,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+02,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+01,1.3)", 1.415959498849e-13, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Qinv", "(1.4159594988487832e-13,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e+00,1.3)", 7.438930621376e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Qinv", "(7.4389306213764639e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000001e-01,1.3)", 9.970457924028e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Qinv", "(9.9704579240282076e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e-02,1.3)", 9.999704146388e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e-03,1.3)", 9.999997041421e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e-04,1.3)", 9.999999970414e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000001e-05,1.3)", 9.999999999704e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(9.9999999999999995e-07,1.3)", 9.999999999997e-01, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(9.9999999999999995e-08,1.3)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e-08,1.3)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000001e-09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(1.0000000000000000e-10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::rayleigh_Q", "(0.0000000000000000e+00,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(0.0000000000000000e+00,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e-10,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000001e-09,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e-08,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(9.9999999999999995e-08,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(9.9999999999999995e-07,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000001e-05,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e-04,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e-03,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e-02,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000001e-01,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+00,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+01,1.3,750.0)", 1.162014157874e-02, TEST_TOL6) TEST("GSL::Cdf::flat_Pinv", "(1.1620141578738545e-02,1.3,750.0)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+02,1.3,750.0)", 1.318285027381e-01, TEST_TOL6) TEST("GSL::Cdf::flat_Pinv", "(1.3182850273808142e-01,1.3,750.0)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+03,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+04,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+05,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+06,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+07,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+08,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+09,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_P", "(1.0000000000000000e+10,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+10,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+09,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+08,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+07,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+06,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+05,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+04,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+03,1.3,750.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+02,1.3,750.0)", 8.681714972619e-01, TEST_TOL6) TEST("GSL::Cdf::flat_Qinv", "(8.6817149726190368e-01,1.3,750.0)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+01,1.3,750.0)", 9.883798584213e-01, TEST_TOL6) TEST("GSL::Cdf::flat_Qinv", "(9.8837985842125353e-01,1.3,750.0)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e+00,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000001e-01,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e-02,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e-03,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e-04,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000001e-05,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(9.9999999999999995e-07,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(9.9999999999999995e-08,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e-08,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000001e-09,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(1.0000000000000000e-10,1.3,750.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::flat_Q", "(0.0000000000000000e+00,1.3,750.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(0.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e-10,1.3,2.7)", 1.034288276012e-19, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(1.0342882760115472e-19,1.3,2.7)", 1.000000000000e-10, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000001e-09,1.3,2.7)", 1.720583234428e-16, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(1.7205832344275183e-16,1.3,2.7)", 1.000000000000e-09, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e-08,1.3,2.7)", 1.397140696550e-13, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(1.3971406965496307e-13,1.3,2.7)", 1.000000000000e-08, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(9.9999999999999995e-08,1.3,2.7)", 5.550354890102e-11, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(5.5503548901015757e-11,1.3,2.7)", 1.000000000000e-07, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(9.9999999999999995e-07,1.3,2.7)", 1.082087222875e-08, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(1.0820872228749844e-08,1.3,2.7)", 1.000000000000e-06, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000001e-05,1.3,2.7)", 1.039815967490e-06, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(1.0398159674903829e-06,1.3,2.7)", 1.000000000000e-05, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e-04,1.3,2.7)", 4.956354352667e-05, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(4.9563543526667839e-05,1.3,2.7)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e-03,1.3,2.7)", 1.183246775456e-03, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(1.1832467754562060e-03,1.3,2.7)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e-02,1.3,2.7)", 1.436760981041e-02, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(1.4367609810406523e-02,1.3,2.7)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000001e-01,1.3,2.7)", 9.105428982941e-02, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(9.1054289829405582e-02,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+00,1.3,2.7)", 3.150871690838e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(3.1508716908375517e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+01,1.3,2.7)", 6.448033073717e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(6.4480330737174019e-01,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+02,1.3,2.7)", 8.895497448370e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(8.8954974483702642e-01,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+03,1.3,2.7)", 9.810967467052e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(9.8109674670518154e-01,1.3,2.7)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+04,1.3,2.7)", 9.983038570318e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(9.9830385703184354e-01,1.3,2.7)", 1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+05,1.3,2.7)", 9.999223897251e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Pinv", "(9.9992238972508574e-01,1.3,2.7)", 1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+06,1.3,2.7)", 9.999982185389e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+07,1.3,2.7)", 9.999999796956e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+08,1.3,2.7)", 9.999999998859e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+09,1.3,2.7)", 9.999999999997e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_P", "(1.0000000000000000e+10,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+10,1.3,2.7)", 4.255893513650e-16, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(4.2558935136502785e-16,1.3,2.7)", 1.000000000000e+10, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+09,1.3,2.7)", 3.150574023842e-13, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(3.1505740238418296e-13,1.3,2.7)", 1.000000000000e+09, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+08,1.3,2.7)", 1.141445550080e-10, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(1.1414455500802107e-10,1.3,2.7)", 1.000000000000e+08, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+07,1.3,2.7)", 2.030439602858e-08, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(2.0304396028576915e-08,1.3,2.7)", 1.000000000000e+07, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+06,1.3,2.7)", 1.781461076603e-06, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(1.7814610766031938e-06,1.3,2.7)", 1.000000000000e+06, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+05,1.3,2.7)", 7.761027491429e-05, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(7.7610274914290006e-05,1.3,2.7)", 1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+04,1.3,2.7)", 1.696142968157e-03, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(1.6961429681565346e-03,1.3,2.7)", 1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+03,1.3,2.7)", 1.890325329482e-02, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(1.8903253294818529e-02,1.3,2.7)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+02,1.3,2.7)", 1.104502551630e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(1.1045025516297369e-01,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+01,1.3,2.7)", 3.551966926283e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(3.5519669262825992e-01,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e+00,1.3,2.7)", 6.849128309162e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(6.8491283091624500e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000001e-01,1.3,2.7)", 9.089457101706e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(9.0894571017059467e-01,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e-02,1.3,2.7)", 9.856323901896e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(9.8563239018959370e-01,1.3,2.7)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e-03,1.3,2.7)", 9.988167532245e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Qinv", "(9.9881675322454400e-01,1.3,2.7)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e-04,1.3,2.7)", 9.999504364565e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000001e-05,1.3,2.7)", 9.999989601840e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(9.9999999999999995e-07,1.3,2.7)", 9.999999891791e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(9.9999999999999995e-08,1.3,2.7)", 9.999999999445e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e-08,1.3,2.7)", 9.999999999999e-01, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000001e-09,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(1.0000000000000000e-10,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::lognormal_Q", "(0.0000000000000000e+00,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(0.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-10,1.3,2.7)", 2.356478475164e-14, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(2.3564784751638661e-14,1.3,2.7)", 1.000000000000e-10, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000001e-09,1.3,2.7)", 4.701792696644e-13, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(4.7017926966439445e-13,1.3,2.7)", 1.000000000000e-09, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-08,1.3,2.7)", 9.381309762735e-12, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(9.3813097627346386e-12,1.3,2.7)", 1.000000000000e-08, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(9.9999999999999995e-08,1.3,2.7)", 1.871817348197e-10, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.8718173481972823e-10,1.3,2.7)", 1.000000000000e-07, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(9.9999999999999995e-07,1.3,2.7)", 3.734765911711e-09, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(3.7347659117114240e-09,1.3,2.7)", 1.000000000000e-06, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000001e-05,1.3,2.7)", 7.451823639191e-08, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(7.4518236391910116e-08,1.3,2.7)", 1.000000000000e-05, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-04,1.3,2.7)", 1.486806276026e-06, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.4868062760263472e-06,1.3,2.7)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-03,1.3,2.7)", 2.966009681152e-05, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(2.9660096811518665e-05,1.3,2.7)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-02,1.3,2.7)", 5.906831032950e-04, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(5.9068310329499826e-04,1.3,2.7)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000001e-01,1.3,2.7)", 1.156629233128e-02, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.1566292331279586e-02,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+00,1.3,2.7)", 1.921237769663e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.9212377696630473e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+01,1.3,2.7)", 9.565035356115e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(9.5650353561153789e-01,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+02,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+03,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+04,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+05,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+06,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+07,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+08,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+09,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+10,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+10,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+09,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+07,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+06,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+05,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+04,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+03,1.3,2.7)", 9.292091038794e-161, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(9.2920910387939860e-161,1.3,2.7)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+02,1.3,2.7)", 2.729167976527e-16, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(2.7291679765273174e-16,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+01,1.3,2.7)", 4.349646438846e-02, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(4.3496464388462192e-02,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+00,1.3,2.7)", 8.078762230337e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(8.0787622303369533e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000001e-01,1.3,2.7)", 9.884337076687e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(9.8843370766872041e-01,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-02,1.3,2.7)", 9.994093168967e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(9.9940931689670498e-01,1.3,2.7)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-03,1.3,2.7)", 9.999703399032e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-04,1.3,2.7)", 9.999985131937e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000001e-05,1.3,2.7)", 9.999999254818e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(9.9999999999999995e-07,1.3,2.7)", 9.999999962652e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(9.9999999999999995e-08,1.3,2.7)", 9.999999998128e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-08,1.3,2.7)", 9.999999999906e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000001e-09,1.3,2.7)", 9.999999999995e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-10,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(0.0000000000000000e+00,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(0.0000000000000000e+00,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e-10,1.3)", 2.238884178785e-07, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(2.2388841787852728e-07,1.3)", 1.000000000000e-10, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000001e-09,1.3)", 1.000072827212e-06, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(1.0000728272124926e-06,1.3)", 1.000000000000e-09, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e-08,1.3)", 4.467161220799e-06, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(4.4671612207994108e-06,1.3)", 1.000000000000e-08, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(9.9999999999999995e-08,1.3)", 1.995407585451e-05, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(1.9954075854510294e-05,1.3)", 1.000000000000e-07, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(9.9999999999999995e-07,1.3)", 8.913156700686e-05, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(8.9131567006858211e-05,1.3)", 1.000000000000e-06, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000001e-05,1.3)", 3.981353794611e-04, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(3.9813537946105002e-04,1.3)", 1.000000000000e-05, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e-04,1.3)", 1.778373888800e-03, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(1.7783738888003920e-03,1.3)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e-03,1.3)", 7.942296379590e-03, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(7.9422963795896199e-03,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e-02,1.3)", 3.541413902540e-02, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(3.5414139025402407e-02,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000001e-01,1.3)", 1.554268895840e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(1.5542688958403586e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+00,1.3)", 5.878620132779e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(5.8786201327788579e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+01,1.3)", 9.973867890205e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Pinv", "(9.9738678902053046e-01,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_P", "(1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+03,1.3)", 5.840240518729e-219, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(5.8402405187288964e-219,1.3)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+02,1.3)", 3.517864771108e-23, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(3.5178647711076648e-23,1.3)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+01,1.3)", 2.613210979470e-03, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(2.6132109794696230e-03,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e+00,1.3)", 4.121379867221e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(4.1213798672211427e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000001e-01,1.3)", 8.445731104160e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(8.4457311041596417e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e-02,1.3)", 9.645858609746e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(9.6458586097459775e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e-03,1.3)", 9.920577036204e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(9.9205770362041057e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e-04,1.3)", 9.982216261112e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(9.9822162611119969e-01,1.3)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000001e-05,1.3)", 9.996018646205e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Qinv", "(9.9960186462053913e-01,1.3)", 1.000000000000e-05, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(9.9999999999999995e-07,1.3)", 9.999108684330e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(9.9999999999999995e-08,1.3)", 9.999800459241e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e-08,1.3)", 9.999955328388e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000001e-09,1.3)", 9.999989999272e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(1.0000000000000000e-10,1.3)", 9.999997761116e-01, TEST_TOL6) TEST("GSL::Cdf::chisq_Q", "(0.0000000000000000e+00,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+10,1.3)", 3.467848111850e-14, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(3.4678481118500305e-14,1.3)", -1.000000000000e+10, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+09,1.3)", 6.919266651610e-13, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(6.9192666516103524e-13,1.3)", -1.000000000000e+09, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+08,1.3)", 1.380575199718e-11, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(1.3805751997179027e-11,1.3)", -1.000000000000e+08, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+07,1.3)", 2.754609668978e-10, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(2.7546096689777484e-10,1.3)", -1.000000000000e+07, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+06,1.3)", 5.496168864957e-09, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(5.4961688649569980e-09,1.3)", -1.000000000000e+06, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+05,1.3)", 1.096629861231e-07, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(1.0966298612314582e-07,1.3)", -1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+04,1.3)", 2.188064222827e-06, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(2.1880642228271703e-06,1.3)", -1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+03,1.3)", 4.365759541083e-05, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(4.3657595410833571e-05,1.3)", -1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+02,1.3)", 8.710327647608e-04, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(8.7103276476079201e-04,1.3)", -1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+01,1.3)", 1.727893386820e-02, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(1.7278933868204446e-02,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e+00,1.3)", 2.336211937932e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(2.3362119379322516e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000001e-01,1.3)", 4.667575980083e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(4.6675759800826139e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e-02,1.3)", 4.966660755117e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(4.9666607551169606e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e-03,1.3)", 4.996665978189e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(4.9966659781887629e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e-04,1.3)", 4.999666597722e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000001e-05,1.3)", 4.999966659772e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-9.9999999999999995e-07,1.3)", 4.999996665977e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-9.9999999999999995e-08,1.3)", 4.999999666598e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e-08,1.3)", 4.999999966660e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000001e-09,1.3)", 4.999999996666e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(-1.0000000000000000e-10,1.3)", 4.999999999667e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(4.9999999999999900e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e-10,1.3)", 5.000000000333e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000001e-09,1.3)", 5.000000003334e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e-08,1.3)", 5.000000033340e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(9.9999999999999995e-08,1.3)", 5.000000333402e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(9.9999999999999995e-07,1.3)", 5.000003334023e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000001e-05,1.3)", 5.000033340228e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e-04,1.3)", 5.000333402278e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e-03,1.3)", 5.003334021811e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(5.0033340218112365e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e-02,1.3)", 5.033339244883e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(5.0333392448830394e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000001e-01,1.3)", 5.332424019917e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(5.3324240199173856e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+00,1.3)", 7.663788062068e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(7.6637880620677490e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+01,1.3)", 9.827210661318e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(9.8272106613179555e-01,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+02,1.3)", 9.991289672352e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Pinv", "(9.9912896723523925e-01,1.3)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+03,1.3)", 9.999563424046e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+04,1.3)", 9.999978119358e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+05,1.3)", 9.999998903370e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+06,1.3)", 9.999999945038e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+07,1.3)", 9.999999997245e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+08,1.3)", 9.999999999862e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+09,1.3)", 9.999999999993e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_P", "(1.0000000000000000e+10,1.3)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+10,1.3)", 3.467848111850e-14, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(3.4678481118500305e-14,1.3)", 1.000000000000e+10, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+09,1.3)", 6.919266651610e-13, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(6.9192666516103524e-13,1.3)", 1.000000000000e+09, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+08,1.3)", 1.380575199718e-11, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(1.3805751997179027e-11,1.3)", 1.000000000000e+08, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+07,1.3)", 2.754609668978e-10, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(2.7546096689777484e-10,1.3)", 1.000000000000e+07, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+06,1.3)", 5.496168864957e-09, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(5.4961688649569980e-09,1.3)", 1.000000000000e+06, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+05,1.3)", 1.096629861231e-07, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(1.0966298612314582e-07,1.3)", 1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+04,1.3)", 2.188064222827e-06, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(2.1880642228271703e-06,1.3)", 1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+03,1.3)", 4.365759541083e-05, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(4.3657595410833571e-05,1.3)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+02,1.3)", 8.710327647608e-04, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(8.7103276476079201e-04,1.3)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+01,1.3)", 1.727893386820e-02, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(1.7278933868204446e-02,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e+00,1.3)", 2.336211937932e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(2.3362119379322516e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000001e-01,1.3)", 4.667575980083e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(4.6675759800826139e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e-02,1.3)", 4.966660755117e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(4.9666607551169606e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e-03,1.3)", 4.996665978189e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(4.9966659781887629e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e-04,1.3)", 4.999666597722e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000001e-05,1.3)", 4.999966659772e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(9.9999999999999995e-07,1.3)", 4.999996665977e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(9.9999999999999995e-08,1.3)", 4.999999666598e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e-08,1.3)", 4.999999966660e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000001e-09,1.3)", 4.999999996666e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(1.0000000000000000e-10,1.3)", 4.999999999667e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(4.9999999999999900e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e-10,1.3)", 5.000000000333e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000001e-09,1.3)", 5.000000003334e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e-08,1.3)", 5.000000033340e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-9.9999999999999995e-08,1.3)", 5.000000333402e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-9.9999999999999995e-07,1.3)", 5.000003334023e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000001e-05,1.3)", 5.000033340228e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e-04,1.3)", 5.000333402278e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e-03,1.3)", 5.003334021811e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(5.0033340218112365e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e-02,1.3)", 5.033339244883e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(5.0333392448830394e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000001e-01,1.3)", 5.332424019917e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(5.3324240199173856e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+00,1.3)", 7.663788062068e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(7.6637880620677490e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+01,1.3)", 9.827210661318e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(9.8272106613179555e-01,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+02,1.3)", 9.991289672352e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Qinv", "(9.9912896723523925e-01,1.3)", -1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+03,1.3)", 9.999563424046e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+04,1.3)", 9.999978119358e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+05,1.3)", 9.999998903370e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+06,1.3)", 9.999999945038e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+07,1.3)", 9.999999997245e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+08,1.3)", 9.999999999862e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+09,1.3)", 9.999999999993e-01, TEST_TOL6) TEST("GSL::Cdf::tdist_Q", "(-1.0000000000000000e+10,1.3)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+10,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+09,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+07,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+06,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+05,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+04,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+03,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+02,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+01,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e+00,1.3,2.7)", 4.981965353092e-05, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(4.9819653530918237e-05,1.3,2.7)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000001e-01,1.3,2.7)", 4.619717476780e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(4.6197174767798083e-02,1.3,2.7)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e-02,1.3,2.7)", 6.487265128366e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(6.4872651283663055e-02,1.3,2.7)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e-03,1.3,2.7)", 6.696988203722e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(6.6969882037217598e-02,1.3,2.7)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e-04,1.3,2.7)", 6.718192621136e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(6.7181926211364873e-02,1.3,2.7)", -1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000001e-05,1.3,2.7)", 6.720315385232e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-9.9999999999999995e-07,1.3,2.7)", 6.720527684866e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-9.9999999999999995e-08,1.3,2.7)", 6.720548915062e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e-08,1.3,2.7)", 6.720551038084e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000001e-09,1.3,2.7)", 6.720551250386e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(-1.0000000000000000e-10,1.3,2.7)", 6.720551271616e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(0.0000000000000000e+00,1.3,2.7)", 6.720551273975e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(6.7205512739749951e-02,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e-10,1.3,2.7)", 6.720551276334e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000001e-09,1.3,2.7)", 6.720551297564e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e-08,1.3,2.7)", 6.720551509866e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(9.9999999999999995e-08,1.3,2.7)", 6.720553632889e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(9.9999999999999995e-07,1.3,2.7)", 6.720574863136e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000001e-05,1.3,2.7)", 6.720787167931e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e-04,1.3,2.7)", 6.722910448133e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(6.7229104481333457e-02,1.3,2.7)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e-03,1.3,2.7)", 6.744166476190e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(6.7441664761898834e-02,1.3,2.7)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e-02,1.3,2.7)", 6.959050352518e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(6.9590503525179814e-02,1.3,2.7)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000001e-01,1.3,2.7)", 9.340058564429e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(9.3400585644290435e-02,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+00,1.3,2.7)", 4.791048360125e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Pinv", "(4.7910483601248477e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+01,1.3,2.7)", 9.999938971292e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+02,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+03,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+04,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+05,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+06,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+07,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+08,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+09,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_P", "(1.0000000000000000e+10,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+10,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+09,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+07,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+06,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+05,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+04,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+03,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+02,1.3,2.7)", 9.398988467742e-57, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.3989884677416057e-57,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+01,1.3,2.7)", 6.102870776257e-06, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(6.1028707762572197e-06,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e+00,1.3,2.7)", 5.208951639875e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(5.2089516398751523e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000001e-01,1.3,2.7)", 9.065994143557e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.0659941435570957e-01,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e-02,1.3,2.7)", 9.304094964748e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.3040949647482019e-01,1.3,2.7)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e-03,1.3,2.7)", 9.325583352381e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.3255833523810117e-01,1.3,2.7)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e-04,1.3,2.7)", 9.327708955187e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000001e-05,1.3,2.7)", 9.327921283207e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(9.9999999999999995e-07,1.3,2.7)", 9.327942513686e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(9.9999999999999995e-08,1.3,2.7)", 9.327944636711e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e-08,1.3,2.7)", 9.327944849013e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000001e-09,1.3,2.7)", 9.327944870244e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(1.0000000000000000e-10,1.3,2.7)", 9.327944872367e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(0.0000000000000000e+00,1.3,2.7)", 9.327944872603e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.3279448726025027e-01,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e-10,1.3,2.7)", 9.327944872838e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000001e-09,1.3,2.7)", 9.327944874961e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e-08,1.3,2.7)", 9.327944896192e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-9.9999999999999995e-08,1.3,2.7)", 9.327945108494e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-9.9999999999999995e-07,1.3,2.7)", 9.327947231513e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000001e-05,1.3,2.7)", 9.327968461477e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e-04,1.3,2.7)", 9.328180737886e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e-03,1.3,2.7)", 9.330301179628e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.3303011796278246e-01,1.3,2.7)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e-02,1.3,2.7)", 9.351273487163e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.3512734871633696e-01,1.3,2.7)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000001e-01,1.3,2.7)", 9.538028252322e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.5380282523220195e-01,1.3,2.7)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+00,1.3,2.7)", 9.999501803465e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Qinv", "(9.9995018034646910e-01,1.3,2.7)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+02,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+03,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+04,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+05,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+06,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+07,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+08,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+09,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel1_Q", "(-1.0000000000000000e+10,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(0.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e-10,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000001e-09,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e-08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(9.9999999999999995e-08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(9.9999999999999995e-07,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000001e-05,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e-04,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e-03,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e-02,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000001e-01,1.3,2.7)", 4.014688368993e-24, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Pinv", "(4.0146883689934746e-24,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+00,1.3,2.7)", 6.720551273975e-02, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Pinv", "(6.7205512739749743e-02,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+01,1.3,2.7)", 8.734358842463e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Pinv", "(8.7343588424628138e-01,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+02,1.3,2.7)", 9.932408531257e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Pinv", "(9.9324085312574451e-01,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+03,1.3,2.7)", 9.996601479016e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Pinv", "(9.9966014790162783e-01,1.3,2.7)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+04,1.3,2.7)", 9.999829642968e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+05,1.3,2.7)", 9.999991461854e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+06,1.3,2.7)", 9.999999572079e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+07,1.3,2.7)", 9.999999978553e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+08,1.3,2.7)", 9.999999998925e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+09,1.3,2.7)", 9.999999999946e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_P", "(1.0000000000000000e+10,1.3,2.7)", 9.999999999997e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+10,1.3,2.7)", 2.700000000000e-13, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(2.6999999999996492e-13,1.3,2.7)", 1.000000000000e+10, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+09,1.3,2.7)", 5.387208250401e-12, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(5.3872082504014914e-12,1.3,2.7)", 1.000000000000e+09, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+08,1.3,2.7)", 1.074889360437e-10, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(1.0748893604366781e-10,1.3,2.7)", 1.000000000000e+08, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+07,1.3,2.7)", 2.144686231456e-09, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(2.1446862314557286e-09,1.3,2.7)", 1.000000000000e+07, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+06,1.3,2.7)", 4.279211528087e-08, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(4.2792115280867646e-08,1.3,2.7)", 1.000000000000e+06, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+05,1.3,2.7)", 8.538146037456e-07, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(8.5381460374556900e-07,1.3,2.7)", 1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+04,1.3,2.7)", 1.703570319173e-05, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(1.7035703191725618e-05,1.3,2.7)", 1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+03,1.3,2.7)", 3.398520983725e-04, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(3.3985209837246249e-04,1.3,2.7)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+02,1.3,2.7)", 6.759146874256e-03, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(6.7591468742558315e-03,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+01,1.3,2.7)", 1.265641157537e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(1.2656411575371904e-01,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e+00,1.3,2.7)", 9.327944872603e-01, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Qinv", "(9.3279448726025116e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000001e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e-02,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e-03,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e-04,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000001e-05,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(9.9999999999999995e-07,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(9.9999999999999995e-08,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e-08,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000001e-09,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(1.0000000000000000e-10,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gumbel2_Q", "(0.0000000000000000e+00,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(0.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e-10,1.3,2.7)", 4.924395760785e-28, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(4.9243957607852698e-28,1.3,2.7)", 1.000000000000e-10, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000001e-09,1.3,2.7)", 2.468044288634e-25, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(2.4680442886338381e-25,1.3,2.7)", 1.000000000000e-09, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e-08,1.3,2.7)", 1.236952289490e-22, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(1.2369522894899823e-22,1.3,2.7)", 1.000000000000e-08, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(9.9999999999999995e-08,1.3,2.7)", 6.199446960984e-20, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(6.1994469609840516e-20,1.3,2.7)", 1.000000000000e-07, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(9.9999999999999995e-07,1.3,2.7)", 3.107083672395e-17, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(3.1070836723945982e-17,1.3,2.7)", 1.000000000000e-06, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000001e-05,1.3,2.7)", 1.557230670416e-14, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(1.5572306704159031e-14,1.3,2.7)", 1.000000000000e-05, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e-04,1.3,2.7)", 7.804641318223e-12, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(7.8046413182225018e-12,1.3,2.7)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e-03,1.3,2.7)", 3.911586584098e-09, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(3.9115865840980536e-09,1.3,2.7)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e-02,1.3,2.7)", 1.960435341356e-06, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(1.9604353413559907e-06,1.3,2.7)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000001e-01,1.3,2.7)", 9.820635881537e-04, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(9.8206358815371392e-04,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+00,1.3,2.7)", 3.888663329609e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_Pinv", "(3.8886633296085954e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+02,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+03,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+04,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+05,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+06,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+07,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+08,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+09,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_P", "(1.0000000000000000e+10,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+10,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+09,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+07,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+06,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+05,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+04,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+03,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+02,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+01,1.3,2.7)", 6.519262004070e-108, TEST_TOL6) TEST("GSL::Cdf::weibull_Qinv", "(6.5192620040698617e-108,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e+00,1.3,2.7)", 6.111336670391e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_Qinv", "(6.1113366703914040e-01,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000001e-01,1.3,2.7)", 9.990179364118e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_Qinv", "(9.9901793641184633e-01,1.3,2.7)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e-02,1.3,2.7)", 9.999980395647e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e-03,1.3,2.7)", 9.999999960884e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e-04,1.3,2.7)", 9.999999999922e-01, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000001e-05,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(9.9999999999999995e-07,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(9.9999999999999995e-08,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e-08,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000001e-09,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(1.0000000000000000e-10,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::weibull_Q", "(0.0000000000000000e+00,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(0.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e-10,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000001e-09,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e-08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(9.9999999999999995e-08,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(9.9999999999999995e-07,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000001e-05,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e-04,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e-03,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e-02,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000001e-01,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+00,1.3,2.7)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+01,1.3,2.7)", 8.177057822240e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_Pinv", "(8.1770578222395374e-01,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+02,1.3,2.7)", 9.908636465287e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_Pinv", "(9.9086364652869807e-01,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+03,1.3,2.7)", 9.995420976279e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_Pinv", "(9.9954209762786816e-01,1.3,2.7)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+04,1.3,2.7)", 9.999770505177e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+05,1.3,2.7)", 9.999988498013e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+06,1.3,2.7)", 9.999999423535e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+07,1.3,2.7)", 9.999999971109e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+08,1.3,2.7)", 9.999999998552e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+09,1.3,2.7)", 9.999999999928e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_P", "(1.0000000000000000e+10,1.3,2.7)", 9.999999999997e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+10,1.3,2.7)", 3.637247829654e-13, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(3.6372478296536173e-13,1.3,2.7)", 1.000000000000e+10, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+09,1.3,2.7)", 7.257263524710e-12, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(7.2572635247102111e-12,1.3,2.7)", 1.000000000000e+09, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+08,1.3,2.7)", 1.448014442065e-10, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(1.4480144420652496e-10,1.3,2.7)", 1.000000000000e+08, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+07,1.3,2.7)", 2.889168647783e-09, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(2.8891686477834784e-09,1.3,2.7)", 1.000000000000e+07, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+06,1.3,2.7)", 5.764649324512e-08, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(5.7646493245119715e-08,1.3,2.7)", 1.000000000000e+06, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+05,1.3,2.7)", 1.150198755621e-06, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(1.1501987556209536e-06,1.3,2.7)", 1.000000000000e+05, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+04,1.3,2.7)", 2.294948231815e-05, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(2.2949482318145872e-05,1.3,2.7)", 1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+03,1.3,2.7)", 4.579023721744e-04, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(4.5790237217441070e-04,1.3,2.7)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+02,1.3,2.7)", 9.136353471345e-03, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(9.1363534713445622e-03,1.3,2.7)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+01,1.3,2.7)", 1.822942177761e-01, TEST_TOL6) TEST("GSL::Cdf::pareto_Qinv", "(1.8229421777608898e-01,1.3,2.7)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e+00,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000001e-01,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e-02,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e-03,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e-04,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000001e-05,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(9.9999999999999995e-07,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(9.9999999999999995e-08,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e-08,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000001e-09,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(1.0000000000000000e-10,1.3,2.7)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::pareto_Q", "(0.0000000000000000e+00,1.3,2.7)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+03,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+02,1.3)", 3.915003559824e-34, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(3.9150035598244656e-34,1.3)", -1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+01,1.3)", 4.561157640565e-04, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(4.5611576405646045e-04,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e+00,1.3)", 3.166455298122e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(3.1664552981221700e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000001e-01,1.3)", 4.807787077894e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(4.8077870778939180e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e-02,1.3)", 4.980769325595e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(4.9807693255949481e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e-03,1.3)", 4.998076923172e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(4.9980769231717492e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e-04,1.3)", 4.999807692308e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000001e-05,1.3)", 4.999980769231e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-9.9999999999999995e-07,1.3)", 4.999998076923e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-9.9999999999999995e-08,1.3)", 4.999999807692e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e-08,1.3)", 4.999999980769e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000001e-09,1.3)", 4.999999998077e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(-1.0000000000000000e-10,1.3)", 4.999999999808e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(5.0000000000000000e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e-10,1.3)", 5.000000000192e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000001e-09,1.3)", 5.000000001923e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e-08,1.3)", 5.000000019231e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(9.9999999999999995e-08,1.3)", 5.000000192308e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(9.9999999999999995e-07,1.3)", 5.000001923077e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000001e-05,1.3)", 5.000019230769e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e-04,1.3)", 5.000192307692e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e-03,1.3)", 5.001923076828e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(5.0019230768282508e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e-02,1.3)", 5.019230674405e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(5.0192306744050519e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000001e-01,1.3)", 5.192212922106e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(5.1922129221060820e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+00,1.3)", 6.833544701878e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(6.8335447018778295e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+01,1.3)", 9.995438842359e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Pinv", "(9.9954388423594354e-01,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_P", "(1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+10,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+09,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+08,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+07,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+06,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+05,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+04,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+03,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+02,1.3)", 3.915003559824e-34, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(3.9150035598244656e-34,1.3)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+01,1.3)", 4.561157640565e-04, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(4.5611576405646045e-04,1.3)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e+00,1.3)", 3.166455298122e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(3.1664552981221700e-01,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000001e-01,1.3)", 4.807787077894e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(4.8077870778939180e-01,1.3)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e-02,1.3)", 4.980769325595e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(4.9807693255949481e-01,1.3)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e-03,1.3)", 4.998076923172e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(4.9980769231717492e-01,1.3)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e-04,1.3)", 4.999807692308e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000001e-05,1.3)", 4.999980769231e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(9.9999999999999995e-07,1.3)", 4.999998076923e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(9.9999999999999995e-08,1.3)", 4.999999807692e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e-08,1.3)", 4.999999980769e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000001e-09,1.3)", 4.999999998077e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(1.0000000000000000e-10,1.3)", 4.999999999808e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(0.0000000000000000e+00,1.3)", 5.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(5.0000000000000000e-01,1.3)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e-10,1.3)", 5.000000000192e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000001e-09,1.3)", 5.000000001923e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e-08,1.3)", 5.000000019231e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-9.9999999999999995e-08,1.3)", 5.000000192308e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-9.9999999999999995e-07,1.3)", 5.000001923077e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000001e-05,1.3)", 5.000019230769e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e-04,1.3)", 5.000192307692e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e-03,1.3)", 5.001923076828e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(5.0019230768282508e-01,1.3)", -1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e-02,1.3)", 5.019230674405e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(5.0192306744050519e-01,1.3)", -1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000001e-01,1.3)", 5.192212922106e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(5.1922129221060820e-01,1.3)", -1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+00,1.3)", 6.833544701878e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(6.8335447018778295e-01,1.3)", -1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+01,1.3)", 9.995438842359e-01, TEST_TOL6) TEST("GSL::Cdf::logistic_Qinv", "(9.9954388423594354e-01,1.3)", -1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+02,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+03,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+04,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+05,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+06,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+07,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+08,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+09,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::logistic_Q", "(-1.0000000000000000e+10,1.3)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(0.0000000000000000e+00,1.3,123.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-10,1.3,123.0)", 1.644976604681e-16, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.6449766046812008e-16,1.3,123.0)", 1.000000000000e-10, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000001e-09,1.3,123.0)", 3.282159828312e-15, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(3.2821598283122862e-15,1.3,123.0)", 1.000000000000e-09, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-08,1.3,123.0)", 6.548769816865e-14, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(6.5487698168653935e-14,1.3,123.0)", 1.000000000000e-08, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(9.9999999999999995e-08,1.3,123.0)", 1.306651361959e-12, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.3066513619593202e-12,1.3,123.0)", 1.000000000000e-07, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(9.9999999999999995e-07,1.3,123.0)", 2.607112210538e-11, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(2.6071122105378624e-11,1.3,123.0)", 1.000000000000e-06, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000001e-05,1.3,123.0)", 5.201872529446e-10, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(5.2018725294456393e-10,1.3,123.0)", 1.000000000000e-05, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-04,1.3,123.0)", 1.037909593275e-08, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.0379095932752980e-08,1.3,123.0)", 1.000000000000e-04, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-03,1.3,123.0)", 2.070893333124e-07, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(2.0708933331240137e-07,1.3,123.0)", 1.000000000000e-03, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e-02,1.3,123.0)", 4.131804542806e-06, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(4.1318045428061286e-06,1.3,123.0)", 1.000000000000e-02, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000001e-01,1.3,123.0)", 8.240625287202e-05, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(8.2406252872017186e-05,1.3,123.0)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+00,1.3,123.0)", 1.637438876041e-03, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(1.6374388760411608e-03,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+01,1.3,123.0)", 3.135521671622e-02, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(3.1355216716223523e-02,1.3,123.0)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+02,1.3,123.0)", 4.240385705334e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(4.2403857053338523e-01,1.3,123.0)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+03,1.3,123.0)", 9.993635318324e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Pinv", "(9.9936353183235616e-01,1.3,123.0)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+04,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+05,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+06,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+07,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+08,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+09,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_P", "(1.0000000000000000e+10,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+10,1.3,123.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+09,1.3,123.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+08,1.3,123.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+07,1.3,123.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+06,1.3,123.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+05,1.3,123.0)", 0.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+04,1.3,123.0)", 2.056363344745e-35, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(2.0563633447452943e-35,1.3,123.0)", 1.000000000000e+04, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+03,1.3,123.0)", 6.364681676440e-04, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(6.3646816764395531e-04,1.3,123.0)", 1.000000000000e+03, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+02,1.3,123.0)", 5.759614294666e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(5.7596142946661488e-01,1.3,123.0)", 1.000000000000e+02, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+01,1.3,123.0)", 9.686447832838e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(9.6864478328377646e-01,1.3,123.0)", 1.000000000000e+01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e+00,1.3,123.0)", 9.983625611240e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(9.9836256112395882e-01,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000001e-01,1.3,123.0)", 9.999175937471e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Qinv", "(9.9991759374712796e-01,1.3,123.0)", 1.000000000000e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-02,1.3,123.0)", 9.999958681955e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-03,1.3,123.0)", 9.999997929107e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-04,1.3,123.0)", 9.999999896209e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000001e-05,1.3,123.0)", 9.999999994798e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(9.9999999999999995e-07,1.3,123.0)", 9.999999999739e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(9.9999999999999995e-08,1.3,123.0)", 9.999999999987e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-08,1.3,123.0)", 9.999999999999e-01, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000001e-09,1.3,123.0)", 1.000000000000e-00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(1.0000000000000000e-10,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) TEST("GSL::Cdf::gamma_Q", "(0.0000000000000000e+00,1.3,123.0)", 1.000000000000e+00, TEST_TOL6) gsl-1.15.3/tests/complex.rb0000755000175000017500000000072612220252463015110 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("./gsl_test.rb") include GSL::Test include Math for i in 0...10 r = (i - 5.0)*0.3 t = 2.0*M_PI*i/5.0 x = r*cos(t) y = r*sin(t) z = GSL::Complex.polar(r, t) desc = sprintf("gsl_complex_polar real part at (r=%g,t=%g)", r, t) GSL::Test.test_rel(z.real, x, 10*GSL::DBL_EPSILON, desc) desc = sprintf("gsl_complex_polar imag part at (r=%g,t=%g)", r, t) GSL::Test.test_rel(z.imag, y, 10*GSL::DBL_EPSILON, desc) end gsl-1.15.3/tests/randist.rb0000755000175000017500000000704312220252463015104 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "randist/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math include GSL::Ran N = 100000 MULTI_DIM = 10 GSL::IEEE::env_setup() GSL::Rng::env_setup() R_global = GSL::Rng.alloc() def test_shuffle() n = 10 status = 0 count = GSL::Matrix.calloc(n, n) x = GSL::Permutation.alloc(n) for i in 0...N for j in 0...n x[j] = j end GSL::Ran.shuffle(R_global, x) for j in 0...n count.set(x[j], j, count[x[j],j]+1) end end for i in 0...n for j in 0...n expected = N/10.0 d = (count[i,j] - expected).abs sigma = d/sqrt(expected) if sigma > 5 and d > 1 status = 1 GSL::Test::test(status, "gsl_ran_shuffle #{i},#{j} (#{count[i,j]/N} observed vs 0.1 expected)") end end end test(status, "gsl_ran_shuffle on {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}") end def testMoments(name, a, b, pp) count = 0 for i in 0...N r = eval("R_global.#{name}") if r < b and r > a; count += 1; end end expected = pp*N sigma = (count - expected).abs/sqrt(expected) status = (sigma > 3) ? 1 : 0 GSL::Test::test(status, "#{name} [#{a},#{b}] (#{count.to_f/N} observed vs #{pp} expected)") end BINS = 100 STEPS = 100 def testPDF(name, args) a = -5.0 b = +5.0 dx = (b - a)/BINS status = 0 status_i = 0 count = GSL::Vector.calloc(BINS) pp = GSL::Vector.calloc(BINS) for i in 0...N r = eval("R_global.#{name}(#{args})") if r < b and r > a j = ((r - a)/dx).to_i count[j] = count[j] + 1; end end for i in 0...BINS x = a + i*dx sum = 0.0 if x.abs < 1e-10; x = 0.0; end for j in 1...STEPS sum += eval("GSL::Ran::#{name}_pdf(#{x+j*dx/STEPS}, #{args})") end pp[i] = 0.5*(eval("GSL::Ran::#{name}_pdf(#{x}, #{args})") + 2*sum + eval("GSL::Ran::#{name}_pdf(#{x+dx-1e-7}, #{args})"))*dx/STEPS end for i in 0...BINS x = a + i*dx d = (count[i] - N*pp[i]) if pp[i] != 0 s = d/sqrt(N*pp[i]) status_i = ((s > 5) && (d > 1)) ? 1 : 0 else status_i = (count[i] != 0) ? 1 : 0 end status |= status_i if status_i == 1 GSL::Test::test(status_i, "#{name} [#{x},#{x+dx}) (#{count[i]}/#{N}=#{count.to_f/N} observed vs #{pp[i]} expected)") end end if status == 0 GSL::Test::test(status, "#{name}, sampling against pdf over range [#{a},#{b})") end end testMoments("ugaussian", 0.0, 100.0, 0.5) testMoments("ugaussian", -1.0, 1.0, 0.6826895); testMoments("ugaussian", 3.0, 3.5, 0.0011172689); testMoments("ugaussian_tail(3.0)", 3.0, 3.5, 0.0011172689 / 0.0013498981); testMoments("exponential(2.0)", 0.0, 1.0, 1 - exp(-0.5)); testMoments("cauchy(2.0)", 0.0, 10000.0, 0.5); testMoments("discrete(GSL::Ran::Discrete.alloc(GSL::Vector.alloc(0.59, 0.4, 0.01)))", -0.5, 0.5, 0.59); testMoments("discrete(GSL::Ran::Discrete.alloc(GSL::Vector.alloc(0.59, 0.4, 0.01)))", 0.5, 1.5, 0.40); testMoments("discrete(GSL::Ran::Discrete.alloc(GSL::Vector.alloc(0.59, 0.4, 0.01)))", 1.5, 3.5, 0.01); testMoments("discrete(GSL::Ran::Discrete.alloc(GSL::Vector.alloc(1, 9, 3, 4, 5, 8, 6, 7, 2, 0)))", -0.5, 0.5, 1.0/45.0 ); testMoments("discrete(GSL::Ran::Discrete.alloc(GSL::Vector.alloc(1, 9, 3, 4, 5, 8, 6, 7, 2, 0)))", 8.5, 9.5, 0 ); testPDF("beta", "2.0, 3.0") testPDF("cauchy", "2.0") testPDF("chisq", "2.0") testPDF("exponential", "2.0") testPDF("exppow", "3.7, 0.3") testPDF("fdist", "3.0, 4.0") testPDF("flat", "3.0, 4.0") testPDF("gamma", "2.5, 2.17") testPDF("gaussian", "3.0") testPDF("ugaussian_tail", "0.1, 2.0") gsl-1.15.3/tests/stats.rb0000755000175000017500000001403212220252463014572 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("gsl_test.rb") include GSL::Test lew = GSL::Vector.alloc( -213, -564, -35, -15, 141, 115, -420, -360, 203, -338, -431, 194, -220, -513, 154, -125, -559, 92, -21, -579, -52, 99, -543, -175, 162, -457, -346, 204, -300, -474, 164, -107, -572, -8, 83, -541, -224, 180, -420, -374, 201, -236, -531, 83, 27, -564, -112, 131, -507, -254, 199, -311, -495, 143, -46, -579, -90, 136, -472, -338, 202, -287, -477, 169, -124, -568, 17, 48, -568, -135, 162, -430, -422, 172, -74, -577, -13, 92, -534, -243, 194, -355, -465, 156, -81, -578, -64, 139, -449, -384, 193, -198, -538, 110, -44, -577, -6, 66, -552, -164, 161, -460, -344, 205, -281, -504, 134, -28, -576, -118, 156, -437, -381, 200, -220, -540, 83, 11, -568, -160, 172, -414, -408, 188, -125, -572, -32, 139, -492, -321, 205, -262, -504, 142, -83, -574, 0, 48, -571, -106, 137, -501, -266, 190, -391, -406, 194, -186, -553, 83, -13, -577, -49, 103, -515, -280, 201, 300, -506, 131, -45, -578, -80, 138, -462, -361, 201, -211, -554, 32, 74, -533, -235, 187, -372, -442, 182, -147, -566, 25, 68, -535, -244, 194, -351, -463, 174, -125, -570, 15, 72, -550, -190, 172, -424, -385, 198, -218, -536, 96 ) expected_mean = -177.435000000000; expected_sd = 277.332168044316; expected_lag1 = -0.307304800605679; mean = lew.mean() sd = lew.sd() lag1 = lew.lag1_autocorrelation() GSL::Test::test_rel(mean, expected_mean, 1e-15, "lew gsl_stats_mean") ; GSL::Test::test_rel(sd, expected_sd, 1e-15, "lew gsl_stats_sd") ; GSL::Test::test_rel(lag1, expected_lag1, 1e-14, "lew autocorrelation") ; rel = 1e-10 rawa = GSL::Vector.alloc(0.0421, 0.0941, 0.1064, 0.0242, 0.1331,0.0773, 0.0243, 0.0815, 0.1186, 0.0356,0.0728, 0.0999, 0.0614, 0.0479) rawb = GSL::Vector.alloc(0.1081, 0.0986, 0.1566, 0.1961, 0.1125, 0.1942, 0.1079, 0.1021, 0.1583, 0.1673, 0.1675, 0.1856, 0.1688, 0.1512) raww = GSL::Vector.alloc(0.0000, 0.0000, 0.0000, 3.000, 0.0000, 1.000, 1.000, 1.000, 0.000, 0.5000, 7.000, 5.000, 4.000, 0.123) mean = rawa.mean expected = 0.0728 GSL::Test::test_rel(mean, expected, rel, "gsl_stats_mean") var = rawa.variance_with_fixed_mean(mean) expected = 0.00113837428571429 GSL::Test::test_rel(var, expected, rel, "gsl_stats_variance_with_fixed_mean") sd = rawa.sd_with_fixed_mean(mean) expected = 0.0337398026922845 GSL::Test::test_rel(sd, expected, rel, "gsl_stats_sd_with_fixed_mean") var = rawb.variance() expected = 0.00124956615384615 GSL::Test::test_rel(var, expected, rel, "gsl_stats_variance") sd = rawa.sd() expected = 0.0350134479659107 GSL::Test::test_rel(sd, expected, rel, "gsl_stats_sd") absdev = rawa.absdev() expected = 0.0287571428571429 GSL::Test::test_rel(absdev, expected, rel, "gsl_stats_absdev") skew = rawa.skew() expected = 0.0954642051479004 GSL::Test::test_rel(skew, expected, rel, "gsl_stats_skew") kurtosis = rawa.kurtosis() expected = -1.38583851548909 GSL::Test::test_rel(kurtosis, expected, rel, "gsl_stats_kurtosis") wmean = rawa.wmean(raww) expected = 0.0678111523670601 GSL::Test::test_rel(wmean, expected, rel, "gsl_stats_wmean") wvariance = rawa.wvariance(raww) expected = 0.000769562962860317 GSL::Test::test_rel(wvariance, expected, rel, "gsl_stats_wvariance") wsd = rawa.wsd(raww) expected = 0.0277409978706664 GSL::Test::test_rel(wsd, expected, rel, "gsl_stats_wsd") wabsdev = rawa.wabsdev(raww) expected = 0.0193205027504008 GSL::Test::test_rel(wabsdev, expected, rel, "gsl_stats_wabsdev") wskew = rawa.wskew(raww) expected = -0.373631000307076 GSL::Test::test_rel(wskew, expected, rel, "gsl_stats_wskew") wkurtosis = rawa.wkurtosis(raww) expected = -1.48114233353963 GSL::Test::test_rel(wkurtosis, expected, rel, "gsl_stats_wkurtosis") c = GSL::Stats::covariance(rawa, rawb) expected = -0.000139021538461539 GSL::Test::test_rel(c, expected, rel, "gsl_stats_covariance") if GSL_VERSION >= "1.9.90" r = GSL::Stats::correlation(rawa, rawb) expected = -0.112322712666074171 GSL::Test::test_rel(r, expected, rel, "gsl_stats_correlation") pv = GSL::Stats::pvariance(rawa, rawb) expected = 0.00123775384615385 GSL::Test::test_rel(pv, expected, rel, "gsl_stats_pvariance") t = GSL::Stats::ttest(rawa, rawb) expected = -5.67026326985851 GSL::Test::test_rel(t, expected, rel, "gsl_stats_ttest") end expected = 0.1331 GSL::Test::test_rel(rawa.max, expected, rel, "gsl_stats_max") expected = 0.0242 GSL::Test::test_rel(rawa.min, expected, rel, "gsl_stats_min") min, max = rawa.minmax expected = 0.1331 GSL::Test::test_rel(max, expected, rel, "gsl_stats_minmax: max") expected = 0.0242 GSL::Test::test_rel(min, expected, rel, "gsl_stats_minmax: min") expected = 4 max_index = rawa.max_index GSL::Test::test(max_index != expected, "gsl_stats_max_index") expected = 3 min_index = rawa.min_index GSL::Test::test(min_index != expected, "gsl_stats_min_index") min_index, max_index = rawa.minmax_index expected = 4 GSL::Test::test(max_index != expected, "gsl_stats_minmax_index: max") expected = 3 GSL::Test::test(min_index != expected, "gsl_stats_minmax_index: min") rawa.sort! median = rawa.median_from_sorted_data() expected = 0.07505 GSL::Test::test_rel(median, expected, rel, "gsl_stats_median_from_sorted_data") median = rawa.subvector(0, rawa.size-1).median_from_sorted_data() expected = 0.0728 GSL::Test::test_rel(median, expected, rel, "gsl_stats_median_from_sorted_data") quantile = rawa.quantile_from_sorted_data(0.0) expected = 0.0242 GSL::Test::test_rel(quantile, expected, rel, "gsl_stats_quantile_from_sorted_data") quantile = rawa.quantile_from_sorted_data(1.0) expected = 0.1331 GSL::Test::test_rel(quantile, expected, rel, "gsl_stats_quantile_from_sorted_data (100)") quantile = rawa.quantile_from_sorted_data(0.5) expected = 0.07505 GSL::Test::test_rel(quantile, expected, rel, "gsl_stats_quantile_from_sorted_data (50even)") quantile = rawa.subvector(0, rawa.size-1).quantile_from_sorted_data(0.5) expected = 0.0728 GSL::Test::test_rel(quantile, expected, rel, "gsl_stats_quantile_from_sorted_data (50odd)") gsl-1.15.3/tests/poly/0000755000175000017500000000000012220252463014067 5ustar boutilboutilgsl-1.15.3/tests/poly/poly.rb0000755000175000017500000003041712220252463015407 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Math eps = 100.0 * GSL::DBL_EPSILON GSL::IEEE::env_setup() c = GSL::Poly.alloc(1.0, 0.5, 0.3) x = 0.5 y = c.eval(x) GSL::Test::test_rel(y, 1 + 0.5 * x + 0.3 * x * x, eps, "gsl_poly_eval({1, 0.5, 0.3}, 0.5)") d = GSL::Poly.alloc( 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1) x = 1.0 #y = d.eval(x) y = GSL::Poly.eval(d, x) #y = GSL::Poly.eval(d, 11, x) GSL::Test::test_rel(y, 1.0, eps, "gsl_poly_eval({1,-1, 1, -1, 1, -1, 1, -1, 1, -1, 1}, 1.0)") x0, x1 = GSL::Poly.solve_quadratic(4.0, -20.0, 25.0).to_a GSL::Test::test_rel(x0, 2.5, 1e-9, "x0, (2x - 5)^2 = 0") GSL::Test::test_rel(x1, 2.5, 1e-9, "x1, (2x - 5)^2 = 0") x0, x1 = GSL::Poly.solve_quadratic(4.0, 7.0, 0.0).to_a GSL::Test::test_rel(x0, -1.75, 1e-9, "x0, x(4x + 7) = 0") GSL::Test::test_rel(x1, 0.0, 1e-9, "x1, x(4x + 7) = 0") x0, x1 = GSL::Poly.solve_quadratic(5.0, 0.0, -20.0).to_a test_rel(x0, -2.0, 1e-9, "x0, 5 x^2 = 20") test_rel(x1, 2.0, 1e-9, "x1, 5 x^2 = 20") # Quadratic single real root (technically not a quadratic) x0, x1 = GSL::Poly.solve_quadratic(0.0, 1.0, 0.0).to_a test_rel(x0, 0.0, 0, "x0, x = 0") test2(x1.nil?, "x1, x = 0 is nil") # Quadratic no real root x0, x1 = GSL::Poly.solve_quadratic(1.0, 0.0, 1.0).to_a test2(x0.nil?, "x0, x^2 = -1 is nil") test2(x1.nil?, "x1, x^2 = -1 is nil") x0, x1, x2 = GSL::Poly.solve_cubic(0.0, 0.0, -27.0).to_a test_rel(x0, 3.0, 1e-9, "x0, x^3 = 27") # Cubic triple real root x0, x1, x2 = GSL::Poly.solve_cubic(-51.0, 867.0, -4913.0).to_a test_rel(x0, 17.0, 1e-9, "x0, (x-17)^3=0") test_rel(x1, 17.0, 1e-9, "x1, (x-17)^3=0") test_rel(x2, 17.0, 1e-9, "x2, (x-17)^3=0") # Cubic double real root plus single real root x0, x1, x2 = GSL::Poly.solve_cubic(-57.0, 1071.0, -6647.0).to_a test_rel(x0, 17.0, 1e-9, "x0, (x-17)(x-17)(x-23)=0") test_rel(x1, 17.0, 1e-9, "x1, (x-17)(x-17)(x-23)=0") test_rel(x2, 23.0, 1e-9, "x2, (x-17)(x-17)(x-23)=0") x0, x1, x2 = GSL::Poly.solve_cubic(-11.0, -493.0, +6647.0).to_a test_rel(x0, -23.0, 1e-9, "x0, (x+23)(x-17)(x-17)=0") test_rel(x1, 17.0, 1e-9, "x1, (x+23)(x-17)(x-17)=0") test_rel(x2, 17.0, 1e-9, "x2, (x+23)(x-17)(x-17)=0") x0, x1, x2 = GSL::Poly.solve_cubic(-143.0, 5087.0, -50065.0).to_a test_rel(x0, 17.0, 1e-9, "x0, (x-17)(x-31)(x-95)=0") test_rel(x1, 31.0, 1e-9, "x1, (x-17)(x-31)(x-95)=0") test_rel(x2, 95.0, 1e-9, "x2, (x-17)(x-31)(x-95)=0") x0, x1, x2 = GSL::Poly.solve_cubic(-109.0, 803.0, 50065.0).to_a test_rel(x0, -17.0, 1e-9, "x0, (x+17)(x-31)(x-95)=0") test_rel(x1, 31.0, 1e-9, "x1, (x+17)(x-31)(x-95)=0") test_rel(x2, 95.0, 1e-9, "x2, (x+17)(x-31)(x-95)=0") # Cubic double real root only is impossible # Cubic single real root (and two complex roots, not returned) x0, x1, x2 = GSL::Poly.solve_cubic(0.0, 0.0, -1.0).to_a test_rel(x0, 1.0, 1e-9, "x0, x^3 = 1") test2(x1.nil?, "x1, x^3 = 1 is nil") test2(x2.nil?, "x2, x^3 = 1 is nil") # Cubic no real root is impossible #z0, z1 = GSL::Poly.complex_solve_quadratic(4.0, -20.0, 26.0).to_a r = GSL::Poly::Complex.solve_quadratic(4.0, -20.0, 26.0) z0 = r[0] z1 = r[1] test_rel(z0.re, 2.5, 1e-9, "z0.real, (2x - 5)^2 = -1") test_rel(z0.im, -0.5, 1e-9, "z0.imag, (2x - 5)^2 = -1") test_rel(z1.re, 2.5, 1e-9, "z1.real, (2x - 5)^2 = -1") test_rel(z1.im, 0.5, 1e-9, "z1.imag, (2x - 5)^2 = -1") z = GSL::Poly.complex_solve_quadratic(4.0, -20.0, 25.0) test_rel(z[0].re, 2.5, 1e-9, "z0.real, (2x - 5)^2 = 0") test_rel(z[0].im, 0.0, 1e-9, "z0.imag (2x - 5)^2 = 0") test_rel(z[1].re, 2.5, 1e-9, "z1.real, (2x - 5)^2 = 0") test_rel(z[1].im, 0.0, 1e-9, "z1.imag (2x - 5)^2 = 0") test(z[0].re != z[1].re ? 1 : 0, "z0.real == z1.real, (2x - 5)^2 = 0") test(z[1].im != z[1].im ? 1 : 0, "z0.imag == z1.imag, (2x - 5)^2 = 0") z = GSL::Poly.complex_solve_quadratic(4.0, -20.0, 21.0) test_rel(z[0].re, 1.5, 1e-9, "z0.real, (2x - 5)^2 = 4") test_rel(z[0].im, 0.0, 1e-9, "z0.imag, (2x - 5)^2 = 4") test_rel(z[1].re, 3.5, 1e-9, "z1.real, (2x - 5)^2 = 4") test_rel(z[1].im, 0.0, 1e-9, "z1.imag, (2x - 5)^2 = 4") z = GSL::Poly.complex_solve_quadratic(4.0, 7.0, 0.0) test_rel(z[0].re, -1.75, 1e-9, "z[0].real, x(4x + 7) = 0") test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, x(4x + 7) = 0") test_rel(z[1].re, 0.0, 1e-9, "z[1].real, x(4x + 7) = 0") test_rel(z[1].im, 0.0, 1e-9, "z[1].imag, x(4x + 7) = 0") z =GSL::Poly.complex_solve_quadratic(5.0, 0.0, -20.0) test_rel(z[0].re, -2.0, 1e-9, "z[0].real, 5 x^2 = 20") test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, 5 x^2 = 20") test_rel(z[1].re, 2.0, 1e-9, "z[1].real, 5 x^2 = 20") test_rel(z[1].im, 0.0, 1e-9, "z[1].imag, 5 x^2 = 20") z = GSL::Poly.complex_solve_quadratic(5.0, 0.0, 20.0) test_rel(z[0].re, 0.0, 1e-9, "z[0].real, 5 x^2 = -20") test_rel(z[0].im, -2.0, 1e-9, "z[0].imag, 5 x^2 = -20") test_rel(z[1].re, 0.0, 1e-9, "z[1].real, 5 x^2 = -20") test_rel(z[1].im, 2.0, 1e-9, "z[1].imag, 5 x^2 = -20") # Quadratic single complex root (technically not quadratic and root not # complex since imaginary component is 0, but the data type is complex) z = GSL::Poly.complex_solve_quadratic(0.0, 1.0, -1.0) test_rel(z[0].re, 1.0, 1e-9, "z[0].real, x = 1 (complex)") test_rel(z[0].im, 0.0, 0.0, "z[0].imag, x = 1 (complex)") test2(x1.nil?, "z[1], x = 0 is nil") # Quadratic no complex root (technically not quadratic) z = GSL::Poly.complex_solve_quadratic(0.0, 0.0, 1.0) test2(z[0].nil?, "z[0], 1 = 0 is nil") test2(z[1].nil?, "z[1], 1 = 0 is nil") z = GSL::Poly.complex_solve_cubic(0.0, 0.0, -27.0) test_rel(z[0].re, -1.5, 1e-9, "z[0].real, x^3 = 27"); test_rel(z[0].im, -1.5 * sqrt(3.0), 1e-9, "z[0].imag, x^3 = 27"); test_rel(z[1].re, -1.5, 1e-9, "z[1].real, x^3 = 27"); test_rel(z[1].im, 1.5 * sqrt(3.0), 1e-9, "z[1].imag, x^3 = 27"); test_rel(z[2].re, 3.0, 1e-9, "z[2].real, x^3 = 27"); test_rel(z[2].im, 0.0, 1e-9, "z[2].imag, x^3 = 27") z = GSL::Poly.complex_solve_cubic(-1.0, 1.0, 39.0) test_rel(z[0].re, -3.0, 1e-9, "z[0].real, (x+3)(x^2+1) = 0"); test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, (x+3)(x^2+1) = 0"); test_rel(z[1].re, 2.0, 1e-9, "z[1].real, (x+3)(x^2+1) = 0"); test_rel(z[1].im, -3.0, 1e-9, "z[1].imag, (x+3)(x^2+1) = 0"); test_rel(z[2].re, 2.0, 1e-9, "z[2].real, (x+3)(x^2+1) = 0"); test_rel(z[2].im, 3.0, 1e-9, "z[2].imag, (x+3)(x^2+1) = 0") z = GSL::Poly.complex_solve_cubic(-51.0, 867.0, -4913.0) test_rel(z[0].re, 17.0, 1e-9, "z[0].real, (x-17)^3=0"); test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, (x-17)^3=0"); test_rel(z[1].re, 17.0, 1e-9, "z[1].real, (x-17)^3=0"); test_rel(z[1].im, 0.0, 1e-9, "z[1].imag, (x-17)^3=0"); test_rel(z[2].re, 17.0, 1e-9, "z[2].real, (x-17)^3=0"); test_rel(z[2].im, 0.0, 1e-9, "z[2].imag, (x-17)^3=0") z = GSL::Poly.complex_solve_cubic(-57.0, 1071.0, -6647.0) test_rel(z[0].re, 17.0, 1e-9, "z[0].real, (x-17)(x-17)(x-23)=0"); test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, (x-17)(x-17)(x-23)=0"); test_rel(z[1].re, 17.0, 1e-9, "z[1].real, (x-17)(x-17)(x-23)=0"); test_rel(z[1].im, 0.0, 1e-9, "z[1].imag, (x-17)(x-17)(x-23)=0"); test_rel(z[2].re, 23.0, 1e-9, "z[2].real, (x-17)(x-17)(x-23)=0"); test_rel(z[2].im, 0.0, 1e-9, "z[2].imag, (x-17)(x-17)(x-23)=0") z = GSL::Poly.complex_solve_cubic(-11.0, -493.0, +6647.0) test_rel(z[0].re, -23.0, 1e-9, "z[0].real, (x+23)(x-17)(x-17)=0"); test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, (x+23)(x-17)(x-17)=0"); test_rel(z[1].re, 17.0, 1e-9, "z[1].real, (x+23)(x-17)(x-17)=0"); test_rel(z[1].im, 0.0, 1e-9, "z[1].imag, (x+23)(x-17)(x-17)=0"); test_rel(z[2].re, 17.0, 1e-9, "z[2].real, (x+23)(x-17)(x-17)=0"); test_rel(z[2].im, 0.0, 1e-9, "z[2].imag, (x+23)(x-17)(x-17)=0"); z = GSL::Poly.complex_solve_cubic(-143.0, 5087.0, -50065.0) test_rel(z[0].re, 17.0, 1e-9, "z[0].real, (x-17)(x-31)(x-95)=0"); test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, (x-17)(x-31)(x-95)=0"); test_rel(z[1].re, 31.0, 1e-9, "z[1].real, (x-17)(x-31)(x-95)=0"); test_rel(z[1].im, 0.0, 1e-9, "z[1].imag, (x-17)(x-31)(x-95)=0"); test_rel(z[2].re, 95.0, 1e-9, "z[2].real, (x-17)(x-31)(x-95)=0"); test_rel(z[2].im, 0.0, 1e-9, "z[2].imag, (x-17)(x-31)(x-95)=0") a = GSL::Poly.alloc(-120, 274, -225, 85, -15, 1) w = GSL::Poly::Complex::Workspace.alloc(a.size) z = GSL::Poly.complex_solve(a, 6, w) #z = GSL::Poly.complex_solve(a, w) #z = GSL::Poly.complex_solve(a) test_rel(z[0].re, 1.0, 1e-9, "z[0].real, 5th-order polynomial"); test_rel(z[0].im, 0.0, 1e-9, "z[0].imag, 5th-order polynomial"); test_rel(z[1].re, 2.0, 1e-9, "z[1].real, 5th-order polynomial"); test_rel(z[1].im, 0.0, 1e-9, "z[1].imag, 5th-order polynomial"); test_rel(z[2].re, 3.0, 1e-9, "z[2].real, 5th-order polynomial"); test_rel(z[2].im, 0.0, 1e-9, "z[2].imag, 5th-order polynomial"); test_rel(z[3].re, 4.0, 1e-9, "z3.real, 5th-order polynomial"); test_rel(z[3].im, 0.0, 1e-9, "z3.imag, 5th-order polynomial"); test_rel(z[4].re, 5.0, 1e-9, "z4.real, 5th-order polynomial"); test_rel(z[4].im, 0.0, 1e-9, "z4.imag, 5th-order polynomial") a = GSL::Poly.alloc(1, 0, 0, 0, 1, 0, 0, 0, 1) w = GSL::Poly::Complex::Workspace.alloc(a.size) c = 0.5 s = sqrt(3)/2 z = GSL::Poly.complex_solve(a, w) test_rel(z[0].re, -s, 1e-9, "z[0].real, 8th-order polynomial"); test_rel(z[0].im, c, 1e-9, "z[0].imag, 8th-order polynomial"); test_rel(z[1].re, -s, 1e-9, "z[1].real, 8th-order polynomial"); test_rel(z[1].im, -c, 1e-9, "z[1].imag, 8th-order polynomial"); test_rel(z[2].re, -c, 1e-9, "z[2].real, 8th-order polynomial"); test_rel(z[2].im, s, 1e-9, "z[2].imag, 8th-order polynomial"); test_rel(z[3].re, -c, 1e-9, "z3.real, 8th-order polynomial"); test_rel(z[3].im, -s, 1e-9, "z3.imag, 8th-order polynomial"); test_rel(z[4].re, c, 1e-9, "z4.real, 8th-order polynomial"); test_rel(z[4].im, s, 1e-9, "z4.imag, 8th-order polynomial"); test_rel(z[5].re, c, 1e-9, "z5.real, 8th-order polynomial"); test_rel(z[5].im, -s, 1e-9, "z5.imag, 8th-order polynomial"); test_rel(z[6].re, s, 1e-9, "z6.real, 8th-order polynomial"); test_rel(z[6].im, c, 1e-9, "z6.imag, 8th-order polynomial"); test_rel(z[7].re, s, 1e-9, "z7.real, 8th-order polynomial"); test_rel(z[7].im, -c, 1e-9, "z7.imag, 8th-order polynomial"); xa = GSL::Poly.alloc(0.16, 0.97, 1.94, 2.74, 3.58, 3.73, 4.70) ya = GSL::Poly.alloc(0.73, 1.11, 1.49, 1.84, 2.30, 2.41, 3.07) dd_expected = GSL::Vector.alloc(7.30000000000000e-01, 4.69135802469136e-01, -4.34737219941284e-02, 2.68681098870099e-02, -3.22937056934996e-03, 6.12763259971375e-03, -6.45402453527083e-03) dd = GSL::Poly.dd_init(xa, ya) for i in 0...7 GSL::Test::test_rel(dd[i], dd_expected[i], 1e-10, "divided difference dd[#{i}]") end #p dd.class for i in 0...7 y = dd.eval(xa, xa[i]); test_rel(y, ya[i], 1e-10, "divided difference y[#{i}]"); end coeff = dd.taylor(1.5, xa) #coeff = dd.taylor(1.5, 7, GSL::Vector.alloc(7)) #coeff = dd.taylor(1.5, 7) #coeff = dd.taylor(1.5, GSL::Vector.alloc(7)) #p coeff.class for i in 0...7 y = coeff.eval(xa[i] - 1.5) test_rel(y, ya[i], 1e-10, "taylor expansion about 1.5 y[#{i}]"); end # Added GSL-1.12.90 (gsl-1.13) # gsl_poly_eval_derivs() exit unless GSL::Poly.method_defined?("eval_derivs") c = GSL::Vector.alloc([1.0, -2.0, +3.0, -4.0, +5.0, -6.0]) x = -0.5 dc = GSL::Poly.eval_derivs(c, x) test_rel(dc[0], c[0] + c[1]*x + c[2]*x*x + c[3]*x*x*x + c[4]*x*x*x*x + c[5]*x*x*x*x*x , eps, "eval_derivs({+1, -2, +3, -4, +5, -6}, 3.75)"); test_rel(dc[1], c[1] + 2.0*c[2]*x + 3.0*c[3]*x*x + 4.0*c[4]*x*x*x + 5.0*c[5]*x*x*x*x , eps, "eval_derivs({+1, -2, +3, -4, +5, -6} deriv 1, -12.375)"); test_rel(dc[2], 2.0*c[2] + 3.0*2.0*c[3]*x + 4.0*3.0*c[4]*x*x + 5.0*4.0*c[5]*x*x*x , eps, "eval_derivs({+1, -2, +3, -4, +5, -6} deriv 2, +48.0)"); test_rel(dc[3], 3.0*2.0*c[3] + 4.0*3.0*2.0*c[4]*x + 5.0*4.0*3.0*c[5]*x*x , eps,"eval_derivs({+1, -2, +3, -4, +5, -6} deriv 3, -174.0)"); test_rel(dc[4], 4.0*3.0*2.0*c[4] + 5.0*4.0*3.0*2.0*c[5]*x, eps, "eval_derivs({+1, -2, +3, -4, +5, -6} deriv 4, +480.0)"); test_rel(dc[5], 5.0*4.0*3.0*2.0*c[5] , eps, "eval_derivs({+1, -2, +3, -4, +5, -6} deriv 5, -720.0)"); # Test Poly::fit and Poly::wfit x = GSL::Vector[0, 2, 2] y = GSL::Vector[0, 1, -1] coef, cov, chisq, status = Poly.fit(x, y, 1) test_rel(coef[0], 0.0, 1e-9, "y intercept == 0") test_rel(coef[1], 0.0, 1e-9, "slope == 0") test_rel(chisq, 2.0, 1e-9, "chisq == 2") w = GSL::Vector[1, 1, 0] coef, cov, chisq, status = Poly.wfit(x, w, y, 1) test_rel(coef[0], 0.0, 1e-9, "y intercept == 0") test_rel(coef[1], 0.5, 1e-9, "slope == 0.5") test_rel(chisq, 0.0, 1e-9, "chisq == 0") gsl-1.15.3/tests/poly/special.rb0000755000175000017500000000410712220252463016041 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("../gsl_test2.rb") include GSL::Test include Math eps = 100.0 * GSL::DBL_EPSILON GSL::IEEE::env_setup() HermitPoly = Array[7] HermitPoly[0] = GSL::Poly::Int[1] HermitPoly[0][0] = 1 HermitPoly[1] = GSL::Poly::Int[0, 2] HermitPoly[2] = GSL::Poly::Int[-2, 0, 4] HermitPoly[3] = GSL::Poly::Int[0, -12, 0, 8] HermitPoly[4] = GSL::Poly::Int[12, 0, -48, 0, 16] HermitPoly[5] = GSL::Poly::Int[0, 120, 0, -160, 0, 32] HermitPoly[6] = GSL::Poly::Int[-120, 0, 720, 0, -480, 0, 64] for n in 0...6 do hn = GSL::Poly.hermite(n) GSL::Test::test2(hn == HermitPoly[n], "Hermite polynomial, n = #{n}") end LaguerrePoly = Array[7] LaguerrePoly[0] = GSL::Poly::Int[1] LaguerrePoly[0][0] = 1 LaguerrePoly[1] = GSL::Poly::Int[1, -1] LaguerrePoly[2] = GSL::Poly::Int[2, -4, 1] LaguerrePoly[3] = GSL::Poly::Int[6, -18, 9, -1] LaguerrePoly[4] = GSL::Poly::Int[24, -96, 72, -16, 1] LaguerrePoly[5] = GSL::Poly::Int[120, -600, 600, -200, 25, -1] LaguerrePoly[6] = GSL::Poly::Int[720, -4320, 5400, -2400, 450, -36, 1] for n in 0...7 do hn = GSL::Poly.laguerre(n) GSL::Test::test2(hn == LaguerrePoly[n], "Laguerre polynomial, n = #{n}") end ChebPoly = Array[7] ChebPoly[0] = GSL::Poly::Int[1] ChebPoly[0][0] = 1 ChebPoly[1] = GSL::Poly::Int[0, 1] ChebPoly[2] = GSL::Poly::Int[-1, 0, 2] ChebPoly[3] = GSL::Poly::Int[0, -3, 0, 4] ChebPoly[4] = GSL::Poly::Int[1, 0, -8, 0, 8] ChebPoly[5] = GSL::Poly::Int[0, 5, 0, -20, 0, 16] ChebPoly[6] = GSL::Poly::Int[-1, 0, 18, 0, -48, 0, 32] for n in 0...7 do hn = GSL::Poly.cheb(n) GSL::Test::test2(hn == ChebPoly[n], "Chebyshev polynomial, n = #{n}") end Cheb_IIPoly = Array[7] Cheb_IIPoly[0] = GSL::Poly::Int[1] Cheb_IIPoly[0][0] = 1 Cheb_IIPoly[1] = GSL::Poly::Int[0, 2] Cheb_IIPoly[2] = GSL::Poly::Int[-1, 0, 4] Cheb_IIPoly[3] = GSL::Poly::Int[0, -4, 0, 8] Cheb_IIPoly[4] = GSL::Poly::Int[1, 0, -12, 0, 16] Cheb_IIPoly[5] = GSL::Poly::Int[0, 6, 0, -32, 0, 32] Cheb_IIPoly[6] = GSL::Poly::Int[-1, 0, 24, 0, -80, 0, 64] for n in 0...7 do hn = GSL::Poly.cheb_II(n) GSL::Test::test2(hn == Cheb_IIPoly[n], "Chebyshev II polynomial, n = #{n}") end gsl-1.15.3/tests/min.rb0000755000175000017500000000555712220252463014233 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "min/test.c" require("gsl") require("./gsl_test2.rb") include GSL::Test include Math GSL::IEEE::env_setup() EPSABS = 0.001 EPSREL = 0.001 MAX_ITERATIONS = 100 def within_tol(a, b, epsrel, epsabs) (a - b).abs < (epsrel*GSL::MIN(a.abs, b.abs) + epsabs) end def test_f(type, desc, f, lower, mid, upper, min) x_lower = lower x_upper = upper s = GSL::Min::FMinimizer.alloc(type) s.set(f, mid, x_lower, x_upper) iterations = 0 begin iterations += 1 status = s.iterate m = s.x_minimum a = s.x_lower b = s.x_upper if a > b desc2 = sprintf("interval is invalid (%g,%g)", a, b) GSL::Test::test(GSL::FAILURE, desc2) end if m < a or m > b desc2 = sprintf("m lies outside interval %g (%g,%g)", m, a, b) GSL::Test::test(GSL::FAILURE, desc2) end if status == 1; break; end status = GSL::Min.test_interval(a, b, EPSABS, EPSREL) end while status == GSL::CONTINUE and iterations < MAX_ITERATIONS desc2 = sprintf("%s, %s (%g obs vs %g expected) ", s.name, desc, s.x_minimum, min) GSL::Test::test(status, desc2) if !within_tol(m, min, EPSREL, EPSABS) desc2 = sprintf("incorrect precision (%g obs vs %g expected)", m, min) GSL::Test::test(GSL::FAILURE, desc2) end end def test_f_e(type, desc, f, lower, mid, upper, min) x_lower = lower x_upper = upper s = GSL::Min::FMinimizer.alloc(type) status = nil begin status = s.set(f, mid, x_lower, x_upper) rescue end if status != GSL::SUCCESS desc2 = sprintf("%s, %s", s.name, desc) GSL::Test::test(status == GSL::SUCCESS ? 1 : 0, desc2) end iterations = 0 begin iterations += 1 status = s.iterate m = s.x_minimum a = s.x_lower b = s.x_upper status = GSL::Min.test_interval(a, b, EPSABS, EPSREL) rescue end while status == GSL::CONTINUE and iterations < MAX_ITERATIONS # desc2 = sprintf("%s, %s", s.name, desc) # GSL::Test::test(status == 0 ? 0 : 1, desc2) end F_cos = GSL::Function.alloc { |x| cos(x) } Func1 = GSL::Function.alloc { |x| pow(x, 4.0) - 1 } Func2 = GSL::Function.alloc { |x| sqrt(x.abs) } Func3 = GSL::Function.alloc { |x| if x < 1.0 1 else -exp(-x) end } Func4 = GSL::Function.alloc { |x| x - 30.0/(1.0 + 1e5*pow(x - 0.8, 2.0)) } types = ["goldensection", "brent", "quad_golden"] types.each do |t| test_f(t, "cos(x) [0 (3) 6]", F_cos, 0.0, 3.0, 6.0, M_PI) test_f(t, "x^4 - 1 [-3 (-1) 17]", Func1, -3.0, -1.0, 17.0, 0.0); test_f(t, "sqrt(|x|) [-2 (-1) 1.5]", Func2, -2.0, -1.0, 1.5, 0.0); test_f(t, "func3(x) [-2 (3) 4]", Func3, -2.0, 3.0, 4.0, 1.0); test_f(t, "func4(x) [0 (0.782) 1]", Func4, 0, 0.782, 1.0, 0.8); test_f_e(t, "invalid range check [4, 0]", F_cos, 4.0, 3.0, 0.0, M_PI); test_f_e(t, "invalid range check [1, 1]", F_cos, 1.0, 1.0, 1.0, M_PI); test_f_e(t, "invalid range check [-1, 1]", F_cos, -1.0, 0.0, 1.0, M_PI) end gsl-1.15.3/tests/dht/0000755000175000017500000000000012220252463013663 5ustar boutilboutilgsl-1.15.3/tests/dht/dht2.rb0000755000175000017500000000064612220252463015062 0ustar boutilboutil#!/usr/bin/env ruby # Test gsl/dht/test.c: test_dht_simple() # Expected results: # vout[0]=4.00 # vout[5]=1.84 # vout[10]=1.27 # vout[35]=0.352 # vout[100]=0.0237 require("gsl") N = 128 t = GSL::Dht.alloc(N, 0.0, 100.0) vin = GSL::Vector.alloc(N) for n in 0...N do x = t.x_sample(n) vin[n] = 1.0/(1.0 + x*x) end vout = t.apply(vin) printf("%e %e %e %e %e\n", vout[0], vout[5], vout[10], vout[35], vout[100]) gsl-1.15.3/tests/dht/dht4.rb0000755000175000017500000000067412220252463015065 0ustar boutilboutil#!/usr/bin/env ruby # Test gsl/dht/test.c: test_dht_poly1() # Expected results: # vout[0]=0.057274214 # vout[5]=-0.000190850 # vout[10]=0.000024342 # vout[35]=-4.04e-07 # vout[100]=1.0e-08 require("gsl") N = 128 t = GSL::Dht.alloc(N, 1.0, 1.0) vin = GSL::Vector.alloc(N) for n in 0...N do x = t.x_sample(n) vin[n] = x*(1.0 - x*x) end vout = t.apply(vin) printf("%e %e %e %e %e\n", vout[0], vout[5], vout[10], vout[35], vout[100]) gsl-1.15.3/tests/dht/dht1.rb0000755000175000017500000000054612220252463015060 0ustar boutilboutil#!/usr/bin/env ruby # Test gsl/dht/test.c: test_dht_exact() # Expected results: # vout[0]=0.375254649407520 # vout[1]=(-0.133507872695560 # vout[2]=0.044679925143840 require("gsl") vin = GSL::Vector.alloc(1, 2, 3) t = GSL::Dht.alloc(3, 1.0, 1.0) vout = t.apply(vin) p vout vin2 = t.apply(vout) vin2.scale!(13.323691936314223*13.323691936314223) p vin2 gsl-1.15.3/tests/dht/dht3.rb0000755000175000017500000000064612220252463015063 0ustar boutilboutil#!/usr/bin/env ruby # Test gsl/dht/test.c: test_dht_exp1() # Expected results: # vout[0]=0.181 # vout[5]=0.357 # vout[10]=0.211 # vout[35]=0.0289 # vout[100]=0.00221 require("gsl") N = 128 t = GSL::Dht.alloc(N, 1.0, 20.0) vin = GSL::Vector.alloc(N) for n in 0...N do x = t.x_sample(n) vin[n] = Math::exp(-x) end vout = t.apply(vin) printf("%e %e %e %e %e\n", vout[0], vout[5], vout[10], vout[35], vout[100]) gsl-1.15.3/tests/bspline.rb0000755000175000017500000000231312220252463015067 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") require("./gsl_test.rb") include GSL::Test def test_bspline(bw) n = 100 ncoeffs = bw.ncoeffs order = bw.order nbreak = bw.nbreak a = bw.breakpoint(0) b = bw.breakpoint(nbreak - 1) for i in 0...n do xi = a + (b - a)*(i/(n-1)) sum = 0.0 bb = bw.eval(xi) for j in 0...ncoeffs do bj = bb[j] s = bj < 0 or bj > 1 GSL::Test::test(s, "basis-spline coefficient #{j} is in range [0,1] for x=#{xi}") sum += bj end GSL::Test::test_rel(sum, 1.0, order*GSL::DBL_EPSILON, "basis-spline coefficient #{order} is in range [0,1] for x=#{xi}") end end NMAX = 10 BMAX = 100 for order in 1..NMAX do for breakpoints in 2..BMAX do a = -1.23*order b = 45.6*order bw = GSL::BSpline.alloc(order, breakpoints) knots = bw.knots_uniform(a, b) test_bspline(bw) end end for order in 1..NMAX do for breakpoints in 2..BMAX do a = -1.23*order b = 45.6*order bw = GSL::BSpline.alloc(order, breakpoints) k = GSL::Vector.alloc(breakpoints) for i in 0...breakpoints do f = Math.sqrt(i.to_f/(breakpoints - 1.0)) k[i] = (1 - f)*a + f*b end knots = bw.knots(k) test_bspline(bw) end end gsl-1.15.3/tests/gsl_test.rb0000755000175000017500000000631112220252463015261 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") include GSL module GSL module Test Verbose = true $tests = 0 $passed = 0 $failed = 0 def test(status, desc) $tests += 1 if !status $passed += 1 printf("PASS: #{desc}\n") else $failed += 1 printf("FAIL: #{desc}\n") end end def test_factor(result, expected, factor, desc) status = nil if result == expected status = false elsif expected == 0.0 status = (result > expected or result < expected) else u = result/expected status = (u > factor or u < 1.0/factor) end $tests += 1 if !status $passed += 1 printf("PASS: #{desc} (%g observed vs %g expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) end end def test_factor2(result, expected, factor, desc) status = nil if result == expected status = false elsif expected == 0.0 status = (result > expected or result < expected) else u = result/expected status = (u > factor or u < 1.0/factor) end $tests += 1 if !status $passed += 1 printf("PASS: #{desc} (%.18g observed vs %g expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) end end def test_rel(result, expected, relerr, desc) status = nil if isnan?(result) or isnan?(expected) status = isnan?(result) != isnan?(expected) elsif isinf?(result) or isinf?(expected) status = isinf?(result) != isinf?(expected) elsif expected.to_f != 0.0 status = (result - expected).abs/expected.abs > relerr else status = result.abs > relerr end $tests += 1 if !status $passed += 1 printf("PASS: #{desc} (%.18g observed vs %g expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) end end def test_abs(result, expected, abserr, desc) status = nil if isnan?(result) or isnan?(expected) status = isnan?(result) != isnan?(expected) elsif isinf?(result) or isinf?(expected) status = isinf?(result) != isinf?(expected) else status = (result - expected).abs > abserr end $tests += 1 if !status $passed += 1 # printf("PASS: #{desc} (%g observed vs %g expected)\n", result, expected) printf("PASS: #{desc} (%.18g observed vs %g expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) end end def test_int(result, expected, desc) status = (result != expected) $tests += 1 if !status $passed += 1 printf("PASS: #{desc} (%d observed vs %d expected)\n", result, expected) else $failed += 1 printf("FAIL: #{desc} (%d observed vs %d expected)\n", result, expected) end end end end gsl-1.15.3/tests/histo.rb0000755000175000017500000000016512220252463014564 0ustar boutilboutil#!/usr/bin/env ruby require("gsl") h = GSL::Histogram.alloc(10, [0, 10]) p h p h.get_range(2) p h.range p h.bin gsl-1.15.3/tests/combination.rb0000755000175000017500000000536112220252463015743 0ustar boutilboutil#!/usr/bin/env ruby # Ruby/GSL implementation of GSL "combination/test.c" require("gsl") require("./gsl_test.rb") include GSL::Test c63 = GSL::Matrix.alloc([0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5], [0, 2, 3], [0, 2, 4], [0, 2, 5], [0, 3, 4], [0, 3, 5], [0, 4, 5], [1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 3, 5], [1, 4, 5], [2, 3, 4], [2, 3, 5], [2, 4, 5], [3, 4, 5]) GSL::IEEE.env_setup() status = false c = GSL::Combination.alloc(6, 3) c.init_first i = 0 begin if i >= 20 status = true break end for j in 0...3 status |= (c.data[j] != c63[i,j]) end s1 = c.valid? desc = sprintf("GSL::Combination#valid\(%u\)", i) GSL::Test.test(s1, desc) i += 1 end while c.next == GSL::SUCCESS GSL::Test.test(status, "GSL::Combination#next, 6 choose 3 combination, 20 steps") c.next c.next c.next for j in 0...3 status |= (c.data[j] != c63[19,j]) end GSL::Test.test(status, "GSL::Combination#next on the last combination") s1 = c.valid? GSL::Test.test(s1, "GSL::Combination#valid on the last combination") d = GSL::Combination.alloc(6, 3) GSL::Combination.memcpy(d, c) status = false for j in 0...3 status |= (d.data[j] != c.data[j]) end GSL::Test.test(status, "GSL::Combination.memcpy, 6 choose 3 combination") c.init_last i = 20 begin if i == 0 status = true break; end i -= 1 for j in 0...3 status |= (c.data[j] != c63[i,j]) end s1 = c.valid? desc = sprintf("GSL::Combination#valid\(%u\)", i) GSL::Test.test(s1, desc) end while c.prev == GSL::SUCCESS GSL::Test.test(status, "GSL::Combination#prev, 6 choose 3 combination, 20 steps") c.prev c.prev c.prev for j in 0...3 status |= (c.data[j] != c63[0,j]) end GSL::Test.test(status, "GSL::Combination#prev on the first combination") s1 = c.valid? GSL::Test.test(s1, "GSL::Combination#valid on the first combination") d = GSL::Combination.alloc(6, 3) GSL::Combination.memcpy(d, c) status = false for j in 0...3 status |= (d.data[j] != c.data[j]) end GSL::Test.test(status, "GSL::Combination.memcpy, 6 choose 3 combination") c = GSL::Combination.calloc(7, 0) status |= (c.next != GSL::FAILURE) status |= (c.next != GSL::FAILURE) status |= (c.prev != GSL::FAILURE) status |= (c.prev != GSL::FAILURE) GSL::Test.test(status, "GSL::Combination 7 choose 0") c = GSL::Combination.calloc(7, 7) for j in 0...7 status |= (c.get(j) != j) end status |= (c.next != GSL::FAILURE) for j in 0...7 status |= (c.get(j) != j) end status |= (c.next != GSL::FAILURE) for j in 0...7 status |= (c.get(j) != j) end status |= (c.next != GSL::FAILURE) for j in 0...7 status |= (c.get(j) != j) end GSL::Test.test(status, "GSL::Combination 7 choose 7") gsl-1.15.3/lib/0000755000175000017500000000000012220252463012510 5ustar boutilboutilgsl-1.15.3/lib/rbgsl.rb0000644000175000017500000000007312220252463014146 0ustar boutilboutilrequire('narray') require('rb_gsl') require('gsl/oper.rb') gsl-1.15.3/lib/ool.rb0000644000175000017500000000143512220252463013631 0ustar boutilboutil module OOL module Conmin class Pgrad_parameters < Array attr_accessor :fmin, :tol, :alpha, :sigma1, :sigma2 end class Spg_parameters < Array attr_accessor :fmin, :tol, :M, :alphamin, :alphamax, :gamma attr_accessor :sigma1, :sigma2 end class Gencan_parameters < Array attr_accessor :epsgpen, :epsgpsn, :fmin, :udelta0 attr_accessor :ucgmia, :ucgmib attr_accessor :cg_scre, :cg_gpnf, :cg_epsi, :cg_epsf attr_accessor :cg_epsnqmp, :cg_maxitnqmp, :nearlyq attr_accessor :nint, :next, :mininterp, :maxextrap attr_accessor :trtype, :eta, :deltamin, :lspgmi, :lspgma attr_accessor :theta, :gamma, :beta, :sigma1, :sigma2 attr_accessor :epsrel, :epsabs, :infrel, :infabs end end end gsl-1.15.3/lib/gsl/0000755000175000017500000000000012220252463013275 5ustar boutilboutilgsl-1.15.3/lib/gsl/gnuplot.rb0000644000175000017500000000173112220252463015314 0ustar boutilboutilrequire("gnuplot") class Array def to_gplot if ( self[0].kind_of? Array ) then tmp = self[0].zip( *self[1..-1] ) tmp.collect { |a| a.join(" ") }.join("\n") + "\ne" elsif ( self[0].kind_of? Numeric ) then s = "" self.length.times { |i| s << "#{self[i]}\n" } s elsif ( self[0].kind_of? GSL::Vector ) then tmp = self[0].zip( *self[1..-1] ) tmp.collect { |a| a.join(" ") }.join("\n") + "\ne" else self[0].zip( *self[1..-1] ).to_gplot end end def to_gsplot f = "" if ( self[0].kind_of? Array ) then x = self[0] y = self[1] d = self[2] x.each_with_index do |xv, i| y.each_with_index do |yv, j| f << [ xv, yv, d[i][j] ].join(" ") << "\n" end # f << "\n" end elsif ( self[0].kind_of? Numeric ) then self.length.times do |i| f << "#{self[i]}\n" end else self[0].zip( *self[1..-1] ).to_gsplot end f end end gsl-1.15.3/lib/gsl/oper.rb0000644000175000017500000000365112220252463014574 0ustar boutilboutilclass Fixnum alias :_orig_mul :* alias :_orig_div :/ def *(other) if other.kind_of?(GSL::Matrix) or other.kind_of?(GSL::Vector) or other.kind_of?(GSL::Matrix::Int) or other.kind_of?(GSL::Vector::Int) or other.kind_of?(GSL::Vector::Complex)or other.kind_of?(GSL::Matrix::Complex) other.scale(self) else if GSL.have_tensor? if other.kind_of?(GSL::Tensor) or other.kind_of?(GSL::Tensor::Int) other.scale(self) else self._orig_mul(other) end else self._orig_mul(other) end end end def /(other) if other.kind_of?(GSL::Poly) or other.kind_of?(GSL::Poly::Int) a = GSL::Poly[1]; a[0] = self GSL::Rational.new(a, other) elsif other.kind_of?(GSL::Vector::Col) other.scale(1.0/GSL::pow_2(other.dnrm2)) elsif other.kind_of?(GSL::Vector::Int::Col) v = other.to_f v.scale(1.0/GSL::pow_2(v.dnrm2)) else self._orig_div(other) end end end class Float alias :_orig_mul :* alias :_orig_div :/ def *(other) if other.kind_of?(GSL::Matrix) or other.kind_of?(GSL::Vector) or other.kind_of?(GSL::Matrix::Int) or other.kind_of?(GSL::Vector::Int) or other.kind_of?(GSL::Vector::Complex)or other.kind_of?(GSL::Matrix::Complex) other.scale(self) else if GSL.have_tensor? if other.kind_of?(GSL::Tensor) or other.kind_of?(GSL::Tensor::Int) other.scale(self) else self._orig_mul(other) end else self._orig_mul(other) end end end def /(other) if other.kind_of?(GSL::Poly) or other.kind_of?(GSL::Poly::Int) a = GSL::Poly[1]; a[0] = self GSL::Rational.new(a, other) elsif other.kind_of?(GSL::Vector::Col) other.scale(1.0/GSL::pow_2(other.dnrm2)) elsif other.kind_of?(GSL::Vector::Int::Col) v = other.to_f v.scale(1.0/GSL::pow_2(v.dnrm2)) else self._orig_div(other) end end end gsl-1.15.3/lib/ool/0000755000175000017500000000000012220252463013301 5ustar boutilboutilgsl-1.15.3/lib/ool/conmin.rb0000644000175000017500000000165712220252463015122 0ustar boutilboutil module OOL module Conmin class Minimizer class Pgrad class Parameters attr_accessor :fmin, :tol, :alpha, :sigma1, :sigma2 end end class Spg class Parameters attr_accessor :fmin, :tol, :M, :alphamin, :alphamax, :gamma attr_accessor :sigma1, :sigma2 end end class Gencan class Parameters attr_accessor :epsgpen, :epsgpsn, :fmin, :udelta0 attr_accessor :ucgmia, :ucgmib attr_accessor :cg_scre, :cg_gpnf, :cg_epsi, :cg_epsf attr_accessor :cg_epsnqmp, :cg_maxitnqmp, :nearlyq attr_accessor :nint, :next, :mininterp, :maxextrap attr_accessor :trtype, :eta, :deltamin, :lspgmi, :lspgma attr_accessor :theta, :gamma, :beta, :sigma1, :sigma2 attr_accessor :epsrel, :epsabs, :infrel, :infabs end end end end end gsl-1.15.3/lib/gsl.rb0000644000175000017500000000007312220252463013622 0ustar boutilboutilrequire('narray') require('rb_gsl') require('gsl/oper.rb') gsl-1.15.3/metadata.yml0000644000175000017500000004443112220252463014253 0ustar boutilboutil--- !ruby/object:Gem::Specification name: gsl version: !ruby/object:Gem::Version hash: 45 prerelease: segments: - 1 - 15 - 3 version: 1.15.3 platform: ruby authors: - Yoshiki Tsunesada - David MacMahon autorequire: bindir: bin cert_chain: [] date: 2013-03-04 00:00:00 Z dependencies: - !ruby/object:Gem::Dependency name: narray prerelease: false requirement: &id001 !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 25 segments: - 0 - 5 - 9 version: 0.5.9 type: :runtime version_requirements: *id001 description: Ruby/GSL is a Ruby interface to the GNU Scientific Library, for numerical computing with Ruby email: y-tsunesada@mm.em-net.ne.jp executables: [] extensions: - ext/extconf.rb extra_rdoc_files: - rdoc/alf.rdoc - rdoc/blas.rdoc - rdoc/bspline.rdoc - rdoc/changes.rdoc - rdoc/cheb.rdoc - rdoc/cholesky_complex.rdoc - rdoc/combi.rdoc - rdoc/complex.rdoc - rdoc/const.rdoc - rdoc/dht.rdoc - rdoc/diff.rdoc - rdoc/ehandling.rdoc - rdoc/eigen.rdoc - rdoc/fft.rdoc - rdoc/fit.rdoc - rdoc/function.rdoc - rdoc/graph.rdoc - rdoc/hist.rdoc - rdoc/hist2d.rdoc - rdoc/hist3d.rdoc - rdoc/index.rdoc - rdoc/integration.rdoc - rdoc/interp.rdoc - rdoc/intro.rdoc - rdoc/linalg.rdoc - rdoc/linalg_complex.rdoc - rdoc/math.rdoc - rdoc/matrix.rdoc - rdoc/min.rdoc - rdoc/monte.rdoc - rdoc/multimin.rdoc - rdoc/multiroot.rdoc - rdoc/narray.rdoc - rdoc/ndlinear.rdoc - rdoc/nonlinearfit.rdoc - rdoc/ntuple.rdoc - rdoc/odeiv.rdoc - rdoc/perm.rdoc - rdoc/poly.rdoc - rdoc/qrng.rdoc - rdoc/randist.rdoc - rdoc/ref.rdoc - rdoc/rng.rdoc - rdoc/rngextra.rdoc - rdoc/roots.rdoc - rdoc/screenshot.rdoc - rdoc/sf.rdoc - rdoc/siman.rdoc - rdoc/sort.rdoc - rdoc/start.rdoc - rdoc/stats.rdoc - rdoc/sum.rdoc - rdoc/tensor.rdoc - rdoc/tut.rdoc - rdoc/use.rdoc - rdoc/vector.rdoc - rdoc/vector_complex.rdoc - rdoc/wavelet.rdoc files: - AUTHORS - COPYING - ChangeLog - README - Rakefile - setup.rb - THANKS - VERSION - examples/alf/alf.gp - examples/alf/alf.rb - examples/blas/blas.rb - examples/blas/dnrm2.rb - examples/blas/level1.rb - examples/blas/level2.rb - examples/blas/level3.rb - examples/bspline.rb - examples/cdf.rb - examples/cheb.rb - examples/combination.rb - examples/complex/add.rb - examples/complex/coerce.rb - examples/complex/complex.rb - examples/complex/fpmi.rb - examples/complex/functions.rb - examples/complex/michelson.rb - examples/complex/mul.rb - examples/complex/oscillator.rb - examples/complex/RC-lpf.rb - examples/complex/set.rb - examples/const/physconst.rb - examples/const/travel.rb - examples/deriv/demo.rb - examples/deriv/deriv.rb - examples/deriv/diff.rb - examples/dht.rb - examples/dirac.rb - examples/eigen/eigen.rb - examples/eigen/herm.rb - examples/eigen/narray.rb - examples/eigen/nonsymm.rb - examples/eigen/nonsymmv.rb - examples/eigen/qhoscillator.gp - examples/eigen/qhoscillator.rb - examples/eigen/vander.rb - examples/fft/fft.rb - examples/fft/fft2.rb - examples/fft/forward.rb - examples/fft/forward2.rb - examples/fft/radix2.rb - examples/fft/real-halfcomplex.rb - examples/fft/real-halfcomplex2.rb - examples/fft/realradix2.rb - examples/fft/sunspot.dat - examples/fft/sunspot.rb - examples/fit/expdata.dat - examples/fit/expfit.rb - examples/fit/gaussfit.rb - examples/fit/gaussian_2peaks.rb - examples/fit/hillfit.rb - examples/fit/lognormal.rb - examples/fit/lorentzfit.rb - examples/fit/multifit.rb - examples/fit/ndlinear.rb - examples/fit/nonlinearfit.rb - examples/fit/plot.gp - examples/fit/polyfit.rb - examples/fit/powerfit.rb - examples/fit/sigmoidfit.rb - examples/fit/sinfit.rb - examples/fit/wlinear.rb - examples/fresnel.rb - examples/function/function.rb - examples/function/log.rb - examples/function/min.rb - examples/function/sin.rb - examples/function/synchrotron.rb - examples/gallery/butterfly.rb - examples/gallery/cayley.rb - examples/gallery/cornu.rb - examples/gallery/eight.rb - examples/gallery/koch.rb - examples/gallery/lemniscate.rb - examples/gallery/polar.rb - examples/gallery/rgplot/cossin.rb - examples/gallery/rgplot/rgplot.replaced - examples/gallery/rgplot/roesller.rb - examples/gallery/roesller.rb - examples/gallery/scarabaeus.rb - examples/histogram/cauchy.rb - examples/histogram/cauchy.sh - examples/histogram/exponential.rb - examples/histogram/gauss.rb - examples/histogram/gsl-histogram.rb - examples/histogram/histo2d.rb - examples/histogram/histo3d.rb - examples/histogram/histogram-pdf.rb - examples/histogram/histogram.rb - examples/histogram/integral.rb - examples/histogram/poisson.rb - examples/histogram/power.rb - examples/histogram/rebin.rb - examples/histogram/smp.dat - examples/histogram/xexp.rb - examples/integration/ahmed.rb - examples/integration/cosmology.rb - examples/integration/friedmann.gp - examples/integration/friedmann.rb - examples/integration/gamma-zeta.rb - examples/integration/integration.rb - examples/integration/qag.rb - examples/integration/qag2.rb - examples/integration/qag3.rb - examples/integration/qagi.rb - examples/integration/qagi2.rb - examples/integration/qagiu.rb - examples/integration/qagp.rb - examples/integration/qags.rb - examples/integration/qawc.rb - examples/integration/qawf.rb - examples/integration/qawo.rb - examples/integration/qaws.rb - examples/integration/qng.rb - examples/interp/demo.gp - examples/interp/demo.rb - examples/interp/interp.rb - examples/interp/points - examples/interp/spline.rb - examples/jacobi/deriv.rb - examples/jacobi/integrate.rb - examples/jacobi/interp.rb - examples/jacobi/jacobi.rb - examples/linalg/chol.rb - examples/linalg/chol_narray.rb - examples/linalg/complex.rb - examples/linalg/HH.rb - examples/linalg/HH_narray.rb - examples/linalg/invert_narray.rb - examples/linalg/LQ_solve.rb - examples/linalg/LU.rb - examples/linalg/LU2.rb - examples/linalg/LU_narray.rb - examples/linalg/PTLQ.rb - examples/linalg/QR.rb - examples/linalg/QR_solve.rb - examples/linalg/QR_solve_narray.rb - examples/linalg/QRPT.rb - examples/linalg/SV.rb - examples/linalg/SV_narray.rb - examples/linalg/SV_solve.rb - examples/math/const.rb - examples/math/elementary.rb - examples/math/functions.rb - examples/math/inf_nan.rb - examples/math/minmax.rb - examples/math/power.rb - examples/math/test.rb - examples/matrix/a.dat - examples/matrix/add.rb - examples/matrix/b.dat - examples/matrix/cat.rb - examples/matrix/colvectors.rb - examples/matrix/complex.rb - examples/matrix/det.rb - examples/matrix/diagonal.rb - examples/matrix/get_all.rb - examples/matrix/hilbert.rb - examples/matrix/iterator.rb - examples/matrix/matrix.rb - examples/matrix/minmax.rb - examples/matrix/mul.rb - examples/matrix/rand.rb - examples/matrix/read.rb - examples/matrix/rowcol.rb - examples/matrix/set.rb - examples/matrix/set_all.rb - examples/matrix/view.rb - examples/matrix/view_all.rb - examples/matrix/write.rb - examples/min.rb - examples/monte/miser.rb - examples/monte/monte.rb - examples/monte/plain.rb - examples/monte/vegas.rb - examples/multimin/bundle.rb - examples/multimin/cqp.rb - examples/multimin/fdfminimizer.rb - examples/multimin/fminimizer.rb - examples/multiroot/demo.rb - examples/multiroot/fdfsolver.rb - examples/multiroot/fsolver.rb - examples/multiroot/fsolver2.rb - examples/multiroot/fsolver3.rb - examples/narray/histogram.rb - examples/narray/mandel.rb - examples/narray/narray.rb - examples/narray/narray2.rb - examples/narray/sf.rb - examples/ntuple/create.rb - examples/ntuple/project.rb - examples/odeiv/binarysystem.gp - examples/odeiv/binarysystem.rb - examples/odeiv/demo.gp - examples/odeiv/demo.rb - examples/odeiv/demo2.gp - examples/odeiv/duffing.rb - examples/odeiv/frei1.rb - examples/odeiv/frei2.rb - examples/odeiv/legendre.rb - examples/odeiv/odeiv.rb - examples/odeiv/odeiv2.rb - examples/odeiv/oscillator.rb - examples/odeiv/sedov.rb - examples/odeiv/whitedwarf.gp - examples/odeiv/whitedwarf.rb - examples/ool/conmin.rb - examples/ool/gencan.rb - examples/ool/pgrad.rb - examples/ool/spg.rb - examples/pdf/bernoulli.rb - examples/pdf/beta.rb - examples/pdf/binomiral.rb - examples/pdf/cauchy.rb - examples/pdf/chisq.rb - examples/pdf/exponential.rb - examples/pdf/exppow.rb - examples/pdf/fdist.rb - examples/pdf/flat.rb - examples/pdf/gamma.rb - examples/pdf/gauss-tail.rb - examples/pdf/gauss.rb - examples/pdf/geometric.rb - examples/pdf/gumbel.rb - examples/pdf/hypergeometric.rb - examples/pdf/landau.rb - examples/pdf/laplace.rb - examples/pdf/logarithmic.rb - examples/pdf/logistic.rb - examples/pdf/lognormal.rb - examples/pdf/neg-binomiral.rb - examples/pdf/pareto.rb - examples/pdf/pascal.rb - examples/pdf/poisson.rb - examples/pdf/rayleigh-tail.rb - examples/pdf/rayleigh.rb - examples/pdf/tdist.rb - examples/pdf/weibull.rb - examples/permutation/ex1.rb - examples/permutation/permutation.rb - examples/poly/bell.rb - examples/poly/bessel.rb - examples/poly/cheb.rb - examples/poly/cheb_II.rb - examples/poly/cubic.rb - examples/poly/demo.rb - examples/poly/eval.rb - examples/poly/eval_derivs.rb - examples/poly/fit.rb - examples/poly/hermite.rb - examples/poly/poly.rb - examples/poly/quadratic.rb - examples/random/diffusion.rb - examples/random/gaussian.rb - examples/random/generator.rb - examples/random/hdsobol.rb - examples/random/poisson.rb - examples/random/qrng.rb - examples/random/randomwalk.rb - examples/random/randomwalk2d.rb - examples/random/rayleigh.rb - examples/random/rng.rb - examples/random/rngextra.rb - examples/roots/bisection.rb - examples/roots/brent.rb - examples/roots/demo.rb - examples/roots/newton.rb - examples/roots/recombination.gp - examples/roots/recombination.rb - examples/roots/steffenson.rb - examples/sf/airy_Ai.rb - examples/sf/airy_Bi.rb - examples/sf/bessel_IK.rb - examples/sf/bessel_JY.rb - examples/sf/beta_inc.rb - examples/sf/clausen.rb - examples/sf/dawson.rb - examples/sf/debye.rb - examples/sf/dilog.rb - examples/sf/ellint.rb - examples/sf/expint.rb - examples/sf/fermi.rb - examples/sf/gamma_inc_P.rb - examples/sf/gegenbauer.rb - examples/sf/hyperg.rb - examples/sf/laguerre.rb - examples/sf/lambertW.rb - examples/sf/legendre_P.rb - examples/sf/lngamma.rb - examples/sf/psi.rb - examples/sf/ShiChi.rb - examples/sf/SiCi.rb - examples/sf/sphbessel.gp - examples/sf/sphbessel.rb - examples/sf/synchrotron.rb - examples/sf/transport.rb - examples/sf/zetam1.rb - examples/siman.rb - examples/sort/heapsort.rb - examples/sort/heapsort_vector_complex.rb - examples/sort/sort.rb - examples/sort/sort2.rb - examples/stats/mean.rb - examples/stats/statistics.rb - examples/stats/test.rb - examples/sum.rb - examples/tamu_anova.rb - examples/vector/a.dat - examples/vector/add.rb - examples/vector/b.dat - examples/vector/c.dat - examples/vector/collect.rb - examples/vector/compare.rb - examples/vector/complex.rb - examples/vector/complex_get_all.rb - examples/vector/complex_set_all.rb - examples/vector/complex_view_all.rb - examples/vector/connect.rb - examples/vector/decimate.rb - examples/vector/diff.rb - examples/vector/filescan.rb - examples/vector/floor.rb - examples/vector/get_all.rb - examples/vector/gnuplot.rb - examples/vector/graph.rb - examples/vector/histogram.rb - examples/vector/linspace.rb - examples/vector/log.rb - examples/vector/logic.rb - examples/vector/logspace.rb - examples/vector/minmax.rb - examples/vector/mul.rb - examples/vector/narray.rb - examples/vector/read.rb - examples/vector/set.rb - examples/vector/set_all.rb - examples/vector/smpv.dat - examples/vector/test.rb - examples/vector/test_gslblock.rb - examples/vector/vector.rb - examples/vector/view.rb - examples/vector/view_all.rb - examples/vector/where.rb - examples/vector/write.rb - examples/vector/zip.rb - examples/wavelet/ecg.dat - examples/wavelet/wavelet1.rb - ext/extconf.rb - ext/alf.c - ext/array.c - ext/array_complex.c - ext/blas.c - ext/blas1.c - ext/blas2.c - ext/blas3.c - ext/block.c - ext/block_source.c - ext/bspline.c - ext/bundle.c - ext/cdf.c - ext/cheb.c - ext/combination.c - ext/common.c - ext/complex.c - ext/const.c - ext/const_additional.c - ext/cqp.c - ext/deriv.c - ext/dht.c - ext/diff.c - ext/dirac.c - ext/eigen.c - ext/error.c - ext/fcmp.c - ext/fft.c - ext/fit.c - ext/fresnel.c - ext/function.c - ext/geometry.c - ext/graph.c - ext/gsl.c - ext/gsl_narray.c - ext/histogram.c - ext/histogram2d.c - ext/histogram3d.c - ext/histogram3d_source.c - ext/histogram_find.c - ext/histogram_oper.c - ext/ieee.c - ext/integration.c - ext/interp.c - ext/jacobi.c - ext/linalg.c - ext/linalg_complex.c - ext/math.c - ext/matrix.c - ext/matrix_complex.c - ext/matrix_double.c - ext/matrix_int.c - ext/matrix_source.c - ext/min.c - ext/monte.c - ext/multifit.c - ext/multimin.c - ext/multimin_fsdf.c - ext/multiroots.c - ext/multiset.c - ext/ndlinear.c - ext/nmf.c - ext/nmf_wrap.c - ext/ntuple.c - ext/odeiv.c - ext/ool.c - ext/oper_complex_source.c - ext/permutation.c - ext/poly.c - ext/poly2.c - ext/poly_source.c - ext/qrng.c - ext/randist.c - ext/rational.c - ext/rng.c - ext/root.c - ext/sf.c - ext/sf_airy.c - ext/sf_bessel.c - ext/sf_clausen.c - ext/sf_coulomb.c - ext/sf_coupling.c - ext/sf_dawson.c - ext/sf_debye.c - ext/sf_dilog.c - ext/sf_elementary.c - ext/sf_ellint.c - ext/sf_elljac.c - ext/sf_erfc.c - ext/sf_exp.c - ext/sf_expint.c - ext/sf_fermi_dirac.c - ext/sf_gamma.c - ext/sf_gegenbauer.c - ext/sf_hyperg.c - ext/sf_laguerre.c - ext/sf_lambert.c - ext/sf_legendre.c - ext/sf_log.c - ext/sf_mathieu.c - ext/sf_power.c - ext/sf_psi.c - ext/sf_synchrotron.c - ext/sf_transport.c - ext/sf_trigonometric.c - ext/sf_zeta.c - ext/signal.c - ext/siman.c - ext/sort.c - ext/spline.c - ext/stats.c - ext/sum.c - ext/tamu_anova.c - ext/tensor.c - ext/tensor_source.c - ext/vector.c - ext/vector_complex.c - ext/vector_double.c - ext/vector_int.c - ext/vector_source.c - ext/wavelet.c - lib/gsl/gnuplot.rb - lib/gsl/oper.rb - lib/gsl.rb - lib/ool/conmin.rb - lib/ool.rb - lib/rbgsl.rb - include/rb_gsl.h - include/rb_gsl_array.h - include/rb_gsl_cheb.h - include/rb_gsl_common.h - include/rb_gsl_complex.h - include/rb_gsl_config.h - include/rb_gsl_const.h - include/rb_gsl_dirac.h - include/rb_gsl_eigen.h - include/rb_gsl_fft.h - include/rb_gsl_fit.h - include/rb_gsl_function.h - include/rb_gsl_graph.h - include/rb_gsl_histogram.h - include/rb_gsl_histogram3d.h - include/rb_gsl_integration.h - include/rb_gsl_interp.h - include/rb_gsl_linalg.h - include/rb_gsl_math.h - include/rb_gsl_odeiv.h - include/rb_gsl_poly.h - include/rb_gsl_rational.h - include/rb_gsl_rng.h - include/rb_gsl_root.h - include/rb_gsl_sf.h - include/rb_gsl_statistics.h - include/rb_gsl_tensor.h - include/rb_gsl_with_narray.h - include/templates_off.h - include/templates_on.h - rdoc/alf.rdoc - rdoc/blas.rdoc - rdoc/bspline.rdoc - rdoc/changes.rdoc - rdoc/cheb.rdoc - rdoc/cholesky_complex.rdoc - rdoc/combi.rdoc - rdoc/complex.rdoc - rdoc/const.rdoc - rdoc/dht.rdoc - rdoc/diff.rdoc - rdoc/ehandling.rdoc - rdoc/eigen.rdoc - rdoc/fft.rdoc - rdoc/fit.rdoc - rdoc/function.rdoc - rdoc/graph.rdoc - rdoc/hist.rdoc - rdoc/hist2d.rdoc - rdoc/hist3d.rdoc - rdoc/index.rdoc - rdoc/integration.rdoc - rdoc/interp.rdoc - rdoc/intro.rdoc - rdoc/linalg.rdoc - rdoc/linalg_complex.rdoc - rdoc/math.rdoc - rdoc/matrix.rdoc - rdoc/min.rdoc - rdoc/monte.rdoc - rdoc/multimin.rdoc - rdoc/multiroot.rdoc - rdoc/narray.rdoc - rdoc/ndlinear.rdoc - rdoc/nonlinearfit.rdoc - rdoc/ntuple.rdoc - rdoc/odeiv.rdoc - rdoc/perm.rdoc - rdoc/poly.rdoc - rdoc/qrng.rdoc - rdoc/randist.rdoc - rdoc/ref.rdoc - rdoc/rng.rdoc - rdoc/rngextra.rdoc - rdoc/roots.rdoc - rdoc/screenshot.rdoc - rdoc/sf.rdoc - rdoc/siman.rdoc - rdoc/sort.rdoc - rdoc/start.rdoc - rdoc/stats.rdoc - rdoc/sum.rdoc - rdoc/tensor.rdoc - rdoc/tut.rdoc - rdoc/use.rdoc - rdoc/vector.rdoc - rdoc/vector_complex.rdoc - rdoc/wavelet.rdoc - tests/blas/amax.rb - tests/blas/asum.rb - tests/blas/axpy.rb - tests/blas/copy.rb - tests/blas/dot.rb - tests/bspline.rb - tests/cdf.rb - tests/cheb.rb - tests/combination.rb - tests/complex.rb - tests/const.rb - tests/deriv.rb - tests/dht/dht1.rb - tests/dht/dht2.rb - tests/dht/dht3.rb - tests/dht/dht4.rb - tests/diff.rb - tests/eigen/eigen.rb - tests/eigen/gen.rb - tests/eigen/genherm.rb - tests/eigen/gensymm.rb - tests/eigen/nonsymm.rb - tests/eigen/nonsymmv.rb - tests/eigen/symm-herm.rb - tests/err.rb - tests/fit.rb - tests/gsl_test.rb - tests/gsl_test2.rb - tests/histo.rb - tests/integration/integration1.rb - tests/integration/integration2.rb - tests/integration/integration3.rb - tests/integration/integration4.rb - tests/interp.rb - tests/linalg/bidiag.rb - tests/linalg/cholesky.rb - tests/linalg/HH.rb - tests/linalg/linalg.rb - tests/linalg/LU.rb - tests/linalg/QR.rb - tests/linalg/SV.rb - tests/linalg/TDN.rb - tests/linalg/TDS.rb - tests/matrix/matrix_complex_test.rb - tests/matrix/matrix_nmf_test.rb - tests/matrix/matrix_test.rb - tests/min.rb - tests/monte/miser.rb - tests/monte/vegas.rb - tests/multifit/test_2dgauss.rb - tests/multifit/test_brown.rb - tests/multifit/test_enso.rb - tests/multifit/test_filip.rb - tests/multifit/test_gauss.rb - tests/multifit/test_longley.rb - tests/multifit/test_multifit.rb - tests/multimin.rb - tests/multiroot.rb - tests/multiset.rb - tests/narray/blas_dnrm2.rb - tests/odeiv.rb - tests/poly/poly.rb - tests/poly/special.rb - tests/qrng.rb - tests/quartic.rb - tests/randist.rb - tests/rng.rb - tests/roots.rb - tests/run-test.sh - tests/sf/gsl_test_sf.rb - tests/sf/test_airy.rb - tests/sf/test_bessel.rb - tests/sf/test_coulomb.rb - tests/sf/test_dilog.rb - tests/sf/test_gamma.rb - tests/sf/test_hyperg.rb - tests/sf/test_legendre.rb - tests/sf/test_mathieu.rb - tests/sf/test_mode.rb - tests/sf/test_sf.rb - tests/stats.rb - tests/stats_mt.rb - tests/sum.rb - tests/sys.rb - tests/tensor.rb - tests/vector/vector_complex_test.rb - tests/vector/vector_test.rb - tests/wavelet.rb homepage: http://rb-gsl.rubyforge.org/ licenses: [] post_install_message: rdoc_options: - --title - Ruby/GSL - --main - rdoc/index.rdoc - --exclude - ext/ - --exclude - include/ - --exclude - lib/ require_paths: - lib - lib/gsl - lib/ool - ext required_ruby_version: !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 53 segments: - 1 - 8 - 1 version: 1.8.1 required_rubygems_version: !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 3 segments: - 0 version: "0" requirements: - GSL (http://www.gnu.org/software/gsl/) rubyforge_project: rb-gsl rubygems_version: 1.8.24 signing_key: specification_version: 3 summary: Ruby interface to GNU Scientific Library test_files: [] gsl-1.15.3/AUTHORS0000644000175000017500000000013512220252463013011 0ustar boutilboutilYoshiki Tsunesada y-tsunesada@mm.em-net.ne.jp David MacMahon davidm@astro.berkeley.edu