# HG changeset patch # User David Grundberg # Date 1224237946 -7200 # Node ID 4da14cce089009b855f2b6139b7200cc9dfaa032 First launchpad.net check in. diff -r 000000000000 -r 4da14cce0890 AUTHORS --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/AUTHORS Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,3 @@ +-*- coding: utf-8; -*- +David Grundberg +HÃ¥kan Fors Nilsson diff -r 000000000000 -r 4da14cce0890 COPYING --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/COPYING Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + 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 + + 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) + + 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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) year 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. diff -r 000000000000 -r 4da14cce0890 ChangeLog diff -r 000000000000 -r 4da14cce0890 INSTALL --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/INSTALL Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,237 @@ +Installation Instructions +************************* + +Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free +Software Foundation, Inc. + +This file is free documentation; the Free Software Foundation gives +unlimited permission to copy, distribute and modify it. + +Basic Installation +================== + +These are generic installation instructions. See README for pytave +instructions. + + The `configure' shell script attempts to guess correct values for +various system-dependent variables used during compilation. It uses +those values to create a `Makefile' in each directory of the package. +It may also create one or more `.h' files containing system-dependent +definitions. Finally, it creates a shell script `config.status' that +you can run in the future to recreate the current configuration, and a +file `config.log' containing compiler output (useful mainly for +debugging `configure'). + + It can also use an optional file (typically called `config.cache' +and enabled with `--cache-file=config.cache' or simply `-C') that saves +the results of its tests to speed up reconfiguring. (Caching is +disabled by default to prevent problems with accidental use of stale +cache files.) + + If you need to do unusual things to compile the package, please try +to figure out how `configure' could check whether to do them, and mail +diffs or instructions to the address given in the `README' so they can +be considered for the next release. If you are using the cache, and at +some point `config.cache' contains results you don't want to keep, you +may remove or edit it. + + The file `configure.ac' (or `configure.in') is used to create +`configure' by a program called `autoconf'. You only need +`configure.ac' if you want to change it or regenerate `configure' using +a newer version of `autoconf'. + +The simplest way to compile this package is: + + 1. `cd' to the directory containing the package's source code and type + `./configure' to configure the package for your system. If you're + using `csh' on an old version of System V, you might need to type + `sh ./configure' instead to prevent `csh' from trying to execute + `configure' itself. + + Running `configure' takes awhile. While running, it prints some + messages telling which features it is checking for. + + 2. Type `make' to compile the package. + + 3. Optionally, type `make check' to run any self-tests that come with + the package. + + 4. Type `make install' to install the programs and any data files and + documentation. + + 5. You can remove the program binaries and object files from the + source code directory by typing `make clean'. To also remove the + files that `configure' created (so you can compile the package for + a different kind of computer), type `make distclean'. There is + also a `make maintainer-clean' target, but that is intended mainly + for the package's developers. If you use it, you may have to get + all sorts of other programs in order to regenerate files that came + with the distribution. + +Compilers and Options +===================== + +Some systems require unusual options for compilation or linking that the +`configure' script does not know about. Run `./configure --help' for +details on some of the pertinent environment variables. + + You can give `configure' initial values for configuration parameters +by setting variables in the command line or in the environment. Here +is an example: + + ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix + + *Note Defining Variables::, for more details. + +Compiling For Multiple Architectures +==================================== + +You can compile the package for more than one kind of computer at the +same time, by placing the object files for each architecture in their +own directory. To do this, you must use a version of `make' that +supports the `VPATH' variable, such as GNU `make'. `cd' to the +directory where you want the object files and executables to go and run +the `configure' script. `configure' automatically checks for the +source code in the directory that `configure' is in and in `..'. + + If you have to use a `make' that does not support the `VPATH' +variable, you have to compile the package for one architecture at a +time in the source code directory. After you have installed the +package for one architecture, use `make distclean' before reconfiguring +for another architecture. + +Installation Names +================== + +By default, `make install' installs the package's commands under +`/usr/local/bin', include files under `/usr/local/include', etc. You +can specify an installation prefix other than `/usr/local' by giving +`configure' the option `--prefix=PREFIX'. + + You can specify separate installation prefixes for +architecture-specific files and architecture-independent files. If you +pass the option `--exec-prefix=PREFIX' to `configure', the package uses +PREFIX as the prefix for installing programs and libraries. +Documentation and other data files still use the regular prefix. + + In addition, if you use an unusual directory layout you can give +options like `--bindir=DIR' to specify different values for particular +kinds of files. Run `configure --help' for a list of the directories +you can set and what kinds of files go in them. + + If the package supports it, you can cause programs to be installed +with an extra prefix or suffix on their names by giving `configure' the +option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. + +Optional Features +================= + +Some packages pay attention to `--enable-FEATURE' options to +`configure', where FEATURE indicates an optional part of the package. +They may also pay attention to `--with-PACKAGE' options, where PACKAGE +is something like `gnu-as' or `x' (for the X Window System). The +`README' should mention any `--enable-' and `--with-' options that the +package recognizes. + + For packages that use the X Window System, `configure' can usually +find the X include and library files automatically, but if it doesn't, +you can use the `configure' options `--x-includes=DIR' and +`--x-libraries=DIR' to specify their locations. + +Specifying the System Type +========================== + +There may be some features `configure' cannot figure out automatically, +but needs to determine by the type of machine the package will run on. +Usually, assuming the package is built to be run on the _same_ +architectures, `configure' can figure that out, but if it prints a +message saying it cannot guess the machine type, give it the +`--build=TYPE' option. TYPE can either be a short name for the system +type, such as `sun4', or a canonical name which has the form: + + CPU-COMPANY-SYSTEM + +where SYSTEM can have one of these forms: + + OS KERNEL-OS + + See the file `config.sub' for the possible values of each field. If +`config.sub' isn't included in this package, then this package doesn't +need to know the machine type. + + If you are _building_ compiler tools for cross-compiling, you should +use the option `--target=TYPE' to select the type of system they will +produce code for. + + If you want to _use_ a cross compiler, that generates code for a +platform different from the build platform, you should specify the +"host" platform (i.e., that on which the generated programs will +eventually be run) with `--host=TYPE'. + +Sharing Defaults +================ + +If you want to set default values for `configure' scripts to share, you +can create a site shell script called `config.site' that gives default +values for variables like `CC', `cache_file', and `prefix'. +`configure' looks for `PREFIX/share/config.site' if it exists, then +`PREFIX/etc/config.site' if it exists. Or, you can set the +`CONFIG_SITE' environment variable to the location of the site script. +A warning: not all `configure' scripts look for a site script. + +Defining Variables +================== + +Variables not defined in a site shell script can be set in the +environment passed to `configure'. However, some packages may run +configure again during the build, and the customized values of these +variables may be lost. In order to avoid this problem, you should set +them in the `configure' command line, using `VAR=value'. For example: + + ./configure CC=/usr/local2/bin/gcc + +causes the specified `gcc' to be used as the C compiler (unless it is +overridden in the site shell script). Here is a another example: + + /bin/bash ./configure CONFIG_SHELL=/bin/bash + +Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent +configuration-related scripts to be executed by `/bin/bash'. + +`configure' Invocation +====================== + +`configure' recognizes the following options to control how it operates. + +`--help' +`-h' + Print a summary of the options to `configure', and exit. + +`--version' +`-V' + Print the version of Autoconf used to generate the `configure' + script, and exit. + +`--cache-file=FILE' + Enable the cache: use and save the results of the tests in FILE, + traditionally `config.cache'. FILE defaults to `/dev/null' to + disable caching. + +`--config-cache' +`-C' + Alias for `--cache-file=config.cache'. + +`--quiet' +`--silent' +`-q' + Do not print messages saying which checks are being made. To + suppress all normal output, redirect it to `/dev/null' (any error + messages will still be shown). + +`--srcdir=DIR' + Look for the package's source code in directory DIR. Usually + `configure' can determine that directory automatically. + +`configure' also accepts some other, not widely useful, options. Run +`configure --help' for more details. + diff -r 000000000000 -r 4da14cce0890 Jamfile.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Jamfile.in Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,19 @@ +# @configure_input@ + +project py : + requirements + /usr/lib/lib@BOOST_PYTHON_LIB@.so + @JAM_LIBOCTAVE@ + @JAM_LIBCRUFT@ + @JAM_LIBOCTINTERP@ + @PYTHON_INCLUDE_DIR@ + @PYTAVE_OCTAVE_INCLUDE_PATH@ + @abs_srcdir@ + @abs_builddir@ + "HAVE_CONFIG_H" + "-Wl,-rpath -Wl,@PYTAVE_OCTAVE_RPATH@" + "-Wall" +; + +python-extension _pytave : @srcdir@/octave_to_python.cc @srcdir@/pytave.cc @srcdir@/exceptions.cc @srcdir@/python_to_octave.cc @srcdir@/arrayobjectdefs.h @srcdir@/config.h @srcdir@/octave_to_python.h @srcdir@/pytavedefs.h @srcdir@/pytave_exception.h @srcdir@/python_to_octave.h ; + diff -r 000000000000 -r 4da14cce0890 Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Makefile.am Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,16 @@ +ACLOCAL_AMFLAGS = -I m4 +EXTRA_lib_LTLIBRARIES = _pytave.la +EXTRA_DIST = test/test.py testfile.m project-root.jam \ +package/__init__.py package/pytave.py +EXTRA_libdir = @PYTAVE_MODULE_INSTALL_PATH@ + +_pytave_la_CPPFLAGS = -I@PYTAVE_OCTAVE_INCLUDE_PATH@ -I@PYTHON_INCLUDE_DIR@ + +# Having -module in LDFLAGS lets us use a non-standard library name +# (e.g. _pytave instead of libpytave) +_pytave_la_LDFLAGS = -module -L@PYTAVE_OCTAVE_RPATH@ -loctinterp -loctave \ +-lcruft -l@BOOST_PYTHON_LIB@ -R @PYTAVE_OCTAVE_RPATH@ + +_pytave_la_SOURCES = octave_to_python.cc pytave.cc python_to_octave.cc \ +arrayobjectdefs.h octave_to_python.h pytavedefs.h exceptions.h \ +exceptions.cc python_to_octave.h config.h diff -r 000000000000 -r 4da14cce0890 NEWS diff -r 000000000000 -r 4da14cce0890 README --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/README Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,141 @@ +pytave README +************* + +Building instructions +===================== + +You can use either Python distutils, GNU Automake or Boost BJam to +build pytave. The configure script outputs files for all these build +systems. Autoconf's VPATH is supported on all build systems. + + Use the configure script to set up Octave and Boost::Python +paths. Run `./configure --help' for more info. There are two custom +arguments that control building of pytave, `--with-octave' and +`--with-boost-python'. + +Dependencies +============ + +Configuring: + an sh shell capable of running `configure' + +Building: + Python's distutils or + make or + BJam + +Linked and tested with: + Python 2.4 + Boost::Python 1.33 + Octave 3.0.2 + +Autotools +========= + +The Autotools build system need not be installed to build the +module. You need `make' and all library dependencies though. + + 1. Create the `Makefile' by typing: + `./configure --prefix=/directory/where/you/want/the/module/file' + + 2. Type `make' to build the extention module. + + 3. To copy the pytave dynamic library to the prefix, type + `make install' + +BJam +==== + +BJam must be installed in order to build the module. You also need a +proper `user-config.jam' file in your home directory. + + 1. Create `Jamfile' and `project-root.jam' by typing `./configure' + + 2. Use your `bjam' command to build the extention module. + +user-config.jam +=============== + +For your convenience, here the content of a typical ~/user-config.jam +on a GNU/Linux system: + +using gcc ; +using python : 2.5 ; + +Distutils +========= + + 1. Create the `setup.py' file by typing `./configure' + + 2. Run `python setup.py build' to build and package the extention + module together with the pure Python files. + +Running from build directory +============================ + +Pytave is made up of three parts. The `pytave' package, the +`pytave/pytave' module and the `pytave/_pytave' extention. When the +user uses `import pytave', the pytave package __init__ script loads +both the module and the extention. It is important that they both can +be found. + + 1. Follow the Distutils build instructions. A complete Python + package directory called `pytave' is created in + `build/lib.something' + + 2. Start the Python interactive interpreter with + `PYTHONPATH=build/lib.linux-i686-2.4/ python' (with appropiate + changes for your system.) + + 3. In the interpreter you can now access Octave through Python: + +import pytave +import Numeric +pytave.feval(1, "cos", 0) +b = pytave.addpath(".") +pytave.feval(1, "testfile", 42) + + (Observe that there is a testfile.m file in the distribution.) + + Using BJam or Automake instead of Distutils, you load the +`pytave/pytave' module and the extention instead of the whole +package. Using `import pytave' now calls the module directly, but the +difference is transparent to the user. + + Basically all you want to do is load Python with shared library +for the pytave extention (called `pytave/_pytave') and the native +`pytave/pytave' module. BJam creates shared library in the +`bin/something/something' directory, while Autotools hide a working +shared library in the `.libs' directory. The contents of the `pytave' +package is stored in the directory `package' of the source +package. This is an example for an Autotools build. + + 1. Follow the Autotools build instructions. + + 2. Start the Python interpreter with a Python path set to a path + containing `_pytave.so' and the `package' directory. A common way + to do this with the bash shell is to execute this command: + `PYTHONPATH=.libs:package python'. + +Installing with distutils +========================= + + 1. Run `python setup.py install' + +Creating a source dist +====================== + + 1. Run `make distcheck' + +Hint about foreign systems +========================== + +If you are running on a system incapable of executing the configure +scripts (e.g. a Microsoft Windows system), you may want to try +installing the `MinGW' and `MSYS' packages, and build everything +inside that environment. This isn't for the faint of hearted though, +since you need/want to build Octave too. It is probably easier than +trying to build without configure scripts, that's all. There are no +guarentees that it will build at all, it has not been tested. + +EOF. \ No newline at end of file diff -r 000000000000 -r 4da14cce0890 arrayobjectdefs.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/arrayobjectdefs.h Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,42 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +/* If your extension does not reside in a single file, there is an + * additional step that is necessary. Be sure to define the symbol + * PY_ARRAY_UNIQUE_SYMBOL to some name (the same name in all the files + * comprising the extension), upstream from the include of + * arrayobject.h. Typically this would be in some header file that is + * included before arrayobject.h. + */ +#ifndef PYTAVE_DO_DECLARE_SYMBOL +#define NO_IMPORT_ARRAY +#endif +#define PY_ARRAY_UNIQUE_SYMBOL pytave_array_symbol +#include +#include + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 configure.ac --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/configure.ac Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,160 @@ +# -*- Autoconf -*- +# Process this file with autoconf to produce a configure script. + +AC_PREREQ(2.61) +AC_INIT(pytave, 0.1.1, c04dgg@cs.umu.se) + +# Some important programs. +AC_LANG(C++) +AC_PROG_CXX +AC_PROG_CPP +AC_PROG_CC + +# Load our custom m4 scripts (from the m4 directory) +AC_CONFIG_MACRO_DIR(m4) +AC_CONFIG_SRCDIR([pytave.cc]) +AC_CONFIG_HEADER([config.h]) + +AC_PRESERVE_HELP_ORDER + +# Look for Octave package +AC_MSG_CHECKING([for Octave package]) +AC_ARG_WITH([octave], + [AS_HELP_STRING([--with-octave], + [Optionally set Octave package to use. + @<:@default=check@:>@])], + [with_octave=$withval], + [with_octave=check]) + +AS_IF([test "x$with_octave" == xno], +[ + AC_MSG_FAILURE([--without-octave was given but Octave required]) +], []) + +AS_IF([test "x$with_octave" == xyes], +[ + with_octave=check +], []) + +AS_IF([test "x$with_octave" == xcheck], +[ + AC_PATH_TOOL(octaveconfig, octave-config, [eepnotfound]) +], +[ + AC_PATH_TOOL(octaveconfig, octave-config, [eepnotfound], $with_octave/bin) +]) + +AS_IF([test "x$octaveconfig" == "xeepnotfound"], +[ + AC_MSG_WARN([Could not find octave-config.]) +], +[ + + PYTAVE_OCTAVE_RPATH=`$octaveconfig -p OCTLIBDIR` + PYTAVE_OCTAVE_INCLUDE_PATH=`$octaveconfig -p OCTINCLUDEDIR` + AC_MSG_RESULT([ results of the Octave check:]) + AC_MSG_RESULT([ octave-config: $octaveconfig]) + AC_MSG_RESULT([ Library: $PYTAVE_OCTAVE_RPATH]) + AC_MSG_RESULT([ Include Dir: $PYTAVE_OCTAVE_INCLUDE_PATH]) + + # Try to compile and link against Octave libraries. + old_flags="$LDFLAGS" + LDFLAGS="-L$PYTAVE_OCTAVE_RPATH $LDFLAGS" + + old_cxx="$CPPFLAGS" + CPPFLAGS="-I$PYTAVE_OCTAVE_INCLUDE_PATH $CXXFLAGS" + + old_libs="$LIBS" + LIBS="-loctave -lcruft -loctinterp $LIBS" + + AC_CACHE_CHECK([whether linking to Octave library works], [my_cv_lib_octave], + [ + my_cv_lib_octave=no + AC_LANG_ASSERT(C++) + AC_LINK_IFELSE(AC_LANG_PROGRAM([[#include + #include ]], + [[MatrixType()]]), + [my_cv_lib_octave=yes], + [my_cv_lib_octave=no]) + ]) + + + LDFLAGS="$old_flags" + LIBS="$old_libs" + CPPFLAGS="$old_cpp" + + +]) + +# Look for boost::python +AX_PYTHON() +AX_BOOST_PYTHON() + +# Now check the two vital libs, if they have problems, halt. +pytave_fatal_errors=no + +AS_IF(test "x$my_cv_lib_octave" != "xyes", +[ + AC_MSG_WARN([Linking to Octave failed.]) + pytave_fatal_errors=yes +], []) + +# XXX: hohoho, this is ugly. +AS_IF(test "x$ac_cv_boost_python" != "xyes", +[ + AC_MSG_WARN([Boost::Python test failed.]) + pytave_fatal_errors=yes +], []) + + +AS_IF(test "x$pytave_fatal_errors" == "xyes", +[ + AC_MSG_ERROR([Configuration failed. Halt.]) +], []) + + +# Do some more initializations + +AM_INIT_AUTOMAKE() + +# Checks for programs. +AC_PROG_LIBTOOL +AC_PROG_RANLIB +AC_PROG_INSTALL +AC_PROG_LN_S +AC_PROG_MAKE_SET + +# Checks for libraries. + + +# Checks for header files. + +# Checks for typedefs, structures, and compiler characteristics. +AC_HEADER_STDBOOL +AC_C_CONST + +# Checks for library functions. + +# This needs a more usable, less unusual solution. +AS_IF(test "x${prefix}" == "xNONE", +[ + PYTAVE_MODULE_INSTALL_PATH=/../invalidpath, +], +[ + PYTAVE_MODULE_INSTALL_PATH=${prefix} +]) + +# Substitutes for the Makefile/Jamfile +AC_SUBST(PYTAVE_OCTAVE_INCLUDE_PATH) +AC_SUBST(PYTAVE_OCTAVE_RPATH) +AC_SUBST(PYTAVE_MODULE_INSTALL_PATH) + +# Substitutes for the Jamfile. XXX: Replace lib*.so with OS independent name. +AC_SUBST(JAM_LIBOCTAVE, $PYTAVE_OCTAVE_RPATH/liboctave.so) +AC_SUBST(JAM_LIBCRUFT, $PYTAVE_OCTAVE_RPATH/libcruft.so) +AC_SUBST(JAM_LIBOCTINTERP, $PYTAVE_OCTAVE_RPATH/liboctinterp.so) + +# Substitute in these files +AC_OUTPUT([Makefile Jamfile setup.py]) +# Copy project-root.jam to VPATH too +AC_OUTPUT([project-root.jam]) diff -r 000000000000 -r 4da14cce0890 exceptions.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/exceptions.cc Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,39 @@ +/* + * Copyright 2008 David Grundberg, Håkan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +#include +#include "exceptions.h" + +namespace pytave { + + PyObject *octave_error_exception::excclass = NULL; + PyObject *value_convert_exception::excclass = NULL; + PyObject *object_convert_exception::excclass = NULL; + +} + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 exceptions.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/exceptions.h Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,106 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +#ifndef PYTAVE_EXCEPTIONS_H +#define PYTAVE_EXCEPTIONS_H + +namespace pytave { + + class pytave_exception { + public: + static void translate_exception(pytave_exception const &py_ex) { + PyErr_SetString(PyExc_Exception, py_ex.error.c_str()); + } + + pytave_exception(std::string err) { error = err; }; + + private: + std::string error; + + }; + + class octave_error_exception { + public: + static bool init() { + excclass = PyErr_NewException("pytave.OctaveError", + PyExc_RuntimeError, NULL); + return excclass != NULL; + }; + static void translate_exception(octave_error_exception const &py_ex) { + PyErr_SetString(excclass, py_ex.error.c_str()); + } + static PyObject *excclass; + + octave_error_exception(std::string err) { error = err; }; + + private: + std::string error; + + }; + + class value_convert_exception { + public: + static bool init() { + excclass = PyErr_NewException("pytave.ValueConvertError", + PyExc_TypeError, NULL); + return excclass != NULL; + }; + static void translate_exception(value_convert_exception const &py_ex) { + PyErr_SetString(excclass, py_ex.error.c_str()); + } + static PyObject *excclass; + + value_convert_exception(std::string err) { error = err; }; + + private: + std::string error; + }; + + class object_convert_exception { + public: + static bool init() { + excclass = PyErr_NewException("pytave.ObjectConvertError", + PyExc_TypeError, NULL); + return excclass != NULL; + }; + static void translate_exception( + object_convert_exception const &py_ex) { + PyErr_SetString(excclass, py_ex.error.c_str()); + } + static PyObject *excclass; + + object_convert_exception(std::string err) { error = err; }; + + private: + std::string error; + }; + +} + +#endif /* PYTAVE_EXCEPTIONS_H */ + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 m4/ax_boost_python.m4 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/m4/ax_boost_python.m4 Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,90 @@ +# =========================================================================== +# http://autoconf-archive.cryp.to/ax_boost_python.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_BOOST_PYTHON +# +# DESCRIPTION +# +# This macro checks to see if the Boost.Python library is installed. It +# also attempts to guess the currect library name using several attempts. +# It tries to build the library name using a user supplied name or suffix +# and then just the raw library. +# +# If the library is found, HAVE_BOOST_PYTHON is defined and +# BOOST_PYTHON_LIB is set to the name of the library. +# +# This macro calls AC_SUBST(BOOST_PYTHON_LIB). +# +# In order to ensure that the Python headers are specified on the include +# path, this macro requires AX_PYTHON to be called. +# +# LAST MODIFICATION +# +# 2008-04-12 +# +# COPYLEFT +# +# Copyright (c) 2008 Michael Tindal +# +# 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, see . +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Macro Archive. When you make and +# distribute a modified version of the Autoconf Macro, you may extend this +# special exception to the GPL to apply to your modified version as well. + +AC_DEFUN([AX_BOOST_PYTHON], +[AC_REQUIRE([AX_PYTHON])dnl +AC_CACHE_CHECK(whether the Boost::Python library is available, +ac_cv_boost_python, +[AC_LANG_SAVE + AC_LANG_CPLUSPLUS + CPPFLAGS_SAVE=$CPPFLAGS + if test x$PYTHON_INCLUDE_DIR != x; then + CPPFLAGS=-I$PYTHON_INCLUDE_DIR $CPPFLAGS + fi + AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[ + #include + using namespace boost::python; + BOOST_PYTHON_MODULE(test) { throw "Boost::Python test."; }]], + [[return 0;]]), + ac_cv_boost_python=yes, ac_cv_boost_python=no) + AC_LANG_RESTORE + CPPFLAGS=$CPPFLAGS_SAVE +]) +if test "$ac_cv_boost_python" = "yes"; then + AC_DEFINE(HAVE_BOOST_PYTHON,,[define if the Boost::Python library is available]) + ax_python_lib=boost_python + AC_ARG_WITH([boost-python],AS_HELP_STRING([--with-boost-python],[specify the boost python library or suffix to use]), + [if test "x$with_boost_python" != "xno"; then + ax_python_lib=$with_boost_python + ax_boost_python_lib=boost_python-$with_boost_python + fi]) + for ax_lib in $ax_python_lib $ax_boost_python_lib boost_python; do + AC_CHECK_LIB($ax_lib, exit, [BOOST_PYTHON_LIB=$ax_lib break]) + done + AC_SUBST(BOOST_PYTHON_LIB) +fi +])dnl diff -r 000000000000 -r 4da14cce0890 m4/ax_python.m4 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/m4/ax_python.m4 Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,99 @@ +# =========================================================================== +# http://autoconf-archive.cryp.to/ax_python.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PYTHON +# +# DESCRIPTION +# +# This macro does a complete Python development environment check. +# +# It recurses through several python versions (from 2.1 to 2.5 in this +# version), looking for an executable. When it finds an executable, it +# looks to find the header files and library. +# +# It sets PYTHON_BIN to the name of the python executable, +# PYTHON_INCLUDE_DIR to the directory holding the header files, and +# PYTHON_LIB to the name of the Python library. +# +# This macro calls AC_SUBST on PYTHON_BIN (via AC_CHECK_PROG), +# PYTHON_INCLUDE_DIR and PYTHON_LIB. +# +# LAST MODIFICATION +# +# 2008-04-12 +# +# COPYLEFT +# +# Copyright (c) 2008 Michael Tindal +# +# 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, see . +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Macro Archive. When you make and +# distribute a modified version of the Autoconf Macro, you may extend this +# special exception to the GPL to apply to your modified version as well. + +AC_DEFUN([AX_PYTHON], +[AC_MSG_CHECKING(for python build information) +AC_MSG_RESULT([]) +for python in python2.4 python2.5 python2.3 python2.2 python2.1 python; do +AC_CHECK_PROGS(PYTHON_BIN, [$python]) +ax_python_bin=$PYTHON_BIN +if test "x$ax_python_bin" != "x"; then + AC_CHECK_LIB($ax_python_bin, main, ax_python_lib=$ax_python_bin, ax_python_lib=no) + AC_CHECK_HEADER([$ax_python_bin/Python.h], + [[ax_python_header=`locate "$ax_python_bin/Python.h" | sed -e s,/Python.h,,`]], + ax_python_header=no) + if test "$ax_python_lib" != no; then + if test "$ax_python_header" != no; then + break; + fi + fi +fi +done +if test x$ax_python_bin = x; then + ax_python_bin=no +fi +if test x$ax_python_header = x; then + ax_python_header=no +fi +if test x$ax_python_lib = x; then + ax_python_lib=no +fi + +AC_MSG_RESULT([ results of the Python check:]) +AC_MSG_RESULT([ Binary: $ax_python_bin]) +AC_MSG_RESULT([ Library: $ax_python_lib]) +AC_MSG_RESULT([ Include Dir: $ax_python_header]) + +if test x$ax_python_header != xno; then + PYTHON_INCLUDE_DIR=$ax_python_header + AC_SUBST(PYTHON_INCLUDE_DIR) +fi +if test x$ax_python_lib != xno; then + PYTHON_LIB=$ax_python_lib + AC_SUBST(PYTHON_LIB) +fi +])dnl diff -r 000000000000 -r 4da14cce0890 octave_to_python.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/octave_to_python.cc Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,298 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +#include "arrayobjectdefs.h" +#include +#include +#undef HAVE_STAT /* both boost::python and octave define HAVE_STAT... */ +#include +#include +#include + +#include +#include "pytavedefs.h" +#include "exceptions.h" + +/* From docs: + * Note that the names of the element type constants refer to the C data + * types, not the Python data types. A Python int is equivalent to a C long, + * and a Python float corresponds to a C double . Many of the element types + * listed above do not have corresponding Python scalar types + * (e.g. PyArray_INT ). + */ + +using namespace std; +using namespace boost::python; + +namespace pytave { + + template + static void copy_octarray_to_pyarrobj( + PyArrayObject *pyarr, + const OctaveBase &matrix, + const unsigned int matindex, + const unsigned int matstride, + const int dimension, + const unsigned int offset) { + unsigned char *ptr = (unsigned char*) pyarr->data; + if (dimension == pyarr->nd - 1) { + // Last dimension, base case + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + *(PythonPrimitive *)&ptr[offset + i*pyarr->strides[dimension]] + = matrix.elem(matindex + i*matstride).value(); + } + } else { + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + copy_octarray_to_pyarrobj( + pyarr, + matrix, + matindex + i*matstride, + matstride * pyarr->dimensions[dimension], + dimension + 1, + offset + i*pyarr->strides[dimension]); + } + } + } + + template <> + static void copy_octarray_to_pyarrobj( + PyArrayObject *pyarr, + const NDArray &matrix, + const unsigned int matindex, + const unsigned int matstride, + const int dimension, + const unsigned int offset) { + unsigned char *ptr = (unsigned char*) pyarr->data; + if (dimension == pyarr->nd - 1) { + // Last dimension, base case + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + *(double *)&ptr[offset + i*pyarr->strides[dimension]] + = matrix.elem(matindex + i*matstride); + } + } else { + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + copy_octarray_to_pyarrobj( + pyarr, + matrix, + matindex + i*matstride, + matstride * pyarr->dimensions[dimension], + dimension + 1, + offset + i*pyarr->strides[dimension]); + } + } + } + +#ifdef PYTAVE_USE_OCTAVE_FLOATS + template <> + static void copy_octarray_to_pyarrobj( + PyArrayObject *pyarr, + const FloatNDArray &matrix, + const unsigned int matindex, + const unsigned int matstride, + const int dimension, + const unsigned int offset) { + unsigned char *ptr = (unsigned char*) pyarr->data; + if (dimension == pyarr->nd - 1) { + // Last dimension, base case + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + *(float *)&ptr[offset + i*pyarr->strides[dimension]] + = matrix.elem(matindex + i*matstride); + } + } else { + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + copy_octarray_to_pyarrobj( + pyarr, + matrix, + matindex + i*matstride, + matstride * pyarr->dimensions[dimension], + dimension + 1, + offset + i*pyarr->strides[dimension]); + } + } + } +#endif /* PYTAVE_USE_OCTAVE_FLOATS */ + + static PyArrayObject *createPyArr(const dim_vector &dims, + int pyarrtype) { + int dimensions[dims.length()]; + for (int i = 0; i < dims.length(); i++) { + dimensions[i] = dims(i); + } + + return (PyArrayObject *)PyArray_FromDims( + dims.length(), dimensions, pyarrtype); + } + + template + static PyArrayObject *create_array(const OctaveBase &octarr, + int pyarraytype) { + PyArrayObject *pyarr = createPyArr(octarr.dims(), pyarraytype); + try { + copy_octarray_to_pyarrobj + (pyarr, octarr, 0, 1, 0, 0); + } catch (value_convert_exception &pe) { + Py_DECREF(pyarr); + throw; + } + return pyarr; + } + + template + inline static PyArrayObject *create_uint_array(CLASS value) { + if (bytes == sizeof(int)) { + return create_array(value, PyArray_UINT); + } else if (bytes == sizeof(char)) { + return create_array(value, PyArray_UBYTE); + } else if (bytes == sizeof(short)) { + return create_array(value, PyArray_USHORT); + } else { + ostringstream os; + os << "Numeric arrays doesn't support unsigned " << (bytes*8) + << "-bit values on this architecture."; + throw value_convert_exception(os.str()); + } + } + + template + inline static PyArrayObject *create_sint_array(CLASS value) { + if (bytes == sizeof(long)) { + return create_array(value, PyArray_LONG); + } else if (bytes == sizeof(int)) { + return create_array(value, PyArray_INT); + } else if (bytes == sizeof(char)) { + return create_array(value, PyArray_SBYTE); + } else if (bytes == sizeof(short)) { + return create_array(value, PyArray_SHORT); + } else { + ostringstream os; + os << "Numeric arrays doesn't support signed " << (bytes*8) + << "-bit values on this architecture."; + throw value_convert_exception(os.str()); + } + } + + static PyArrayObject *octvalue_to_pyarrobj(const octave_value &matrix) { + if (matrix.is_complex_type ()) { + throw value_convert_exception( + "Complex Octave matrices conversion not implemented"); + } + + if (matrix.is_double_type ()) { + if (matrix.is_real_type()) { + return create_array(matrix.array_value(), + PyArray_DOUBLE); + } else + throw value_convert_exception("Unknown double matrix type"); + } + +#ifdef PYTAVE_USE_OCTAVE_FLOATS + if (matrix.is_single_type ()) { + if (matrix.is_real_type()) { + return create_array( + matrix.float_array_value(), PyArray_FLOAT); + } else + throw value_convert_exception("Unknown float matrix type"); + } +#endif + + if (matrix.is_int64_type()) { + return create_sint_array( + matrix.int64_array_value()); + } + if (matrix.is_uint32_type()) { + return create_uint_array( + matrix.uint32_array_value()); + } + if (matrix.is_int32_type()) { + return create_sint_array( + matrix.int32_array_value()); + } + if (matrix.is_uint16_type()) { + return create_uint_array( + matrix.uint16_array_value()); + } + if (matrix.is_int16_type()) { + return create_sint_array( + matrix.int16_array_value()); + } + if (matrix.is_uint8_type()) { + return create_uint_array( + matrix.uint8_array_value()); + } + if (matrix.is_int8_type()) { + return create_sint_array( + matrix.int8_array_value()); + } + + throw value_convert_exception("Octave matrix type not known, " + "conversion not implemented"); + } + + static void octvalue_to_pyarr(boost::python::object &py_object, + const octave_value& octvalue) { + PyArrayObject *pyarr = octvalue_to_pyarrobj(octvalue); + py_object = object(handle((PyObject *)pyarr)); + } + + void octvalue_to_pyobj(boost::python::object &py_object, + const octave_value& octvalue) { + if (octvalue.is_scalar_type()) { + if (octvalue.is_bool_type()) + py_object = object(octvalue.bool_value()); + else if (octvalue.is_real_scalar()) + py_object = object(octvalue.double_value()); + else if (octvalue.is_integer_type()) + py_object = object(octvalue.int_value()); + else + throw value_convert_exception( + "Conversion for this scalar not implemented"); + } else if (octvalue.is_string()) + py_object = str(octvalue.string_value()); + else if (octvalue.is_matrix_type()) + octvalue_to_pyarr(py_object, octvalue); + else if (octvalue.is_undefined()) + throw value_convert_exception( + "Octave value `undefined'. Can not convert to a Python object"); + else + throw value_convert_exception( + "Conversion from Octave value not implemented"); + } + + void octlist_to_pytuple(boost::python::tuple &python_tuple, + const octave_value_list &octave_list) { + boost::python::list seq; + int length = octave_list.length(); + for (int i = 0; i < length; i++) { + boost::python::object py_object; + octvalue_to_pyobj(py_object, octave_list(i)); + seq.append(py_object); + } + python_tuple = tuple(seq); + } +} + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 octave_to_python.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/octave_to_python.h Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,41 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +#ifndef OCTAVE_TO_PYTHON_H +#define OCTAVE_TO_PYTHON_H + +class octave_value_list; +class boost::python::tuple; + +namespace pytave { + void octlist_to_pytuple(boost::python::tuple &python_tuple, + const octave_value_list &octave_list); +} + +#endif /* OCTAVE_TO_PYTHON_H */ + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 package/__init__.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/package/__init__.py Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,30 @@ +# -*- coding:utf-8 -*- +# +# Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson +# +# This file is part of Pytave. +# +# Pytave is free software: you can 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. +# +# Pytave is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Pytave. If not, see . + +import _pytave +from pytave import * + +# Emacs +# Local Variables: +# fill-column:70 +# coding:utf-8 +# indent-tabs-mode:t +# tab-width:3 +# End: +# vim: set textwidth=70 noexpandtab tabstop=3 : diff -r 000000000000 -r 4da14cce0890 package/pytave.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/package/pytave.py Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,111 @@ +# -*- coding:utf-8 -*- +# +# Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson +# +# This file is part of Pytave. +# +# Pytave is free software: you can 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. +# +# Pytave is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with Pytave. If not, see . + +"""Python to Octave bridge""" + +import _pytave + +_pytave.init() +(OctaveError, ValueConvertError, ObjectConvertError) \ + = _pytave.get_exceptions(); + +def feval(nargout, funcname, *arguments): + + """Executes an Octave function called funcname. + + The function is set to return nargout values. Returned values are + stored in a tuple. If the nargout argument is less than or equal + to 0, an empty tuple is returned. + + M-files are searched for in the Octave path. + + See also the Octave documentation for the builtin Octave function + feval. + + Type conversions + **************** + + The following type conversions are supported: + + Python to Octave + ================ + + Objects: + int (32-bit) int32 + float (64-bit) double + str string + + Numeric Array: + UBYTE, SBYTE, matrix of correct type + USHORT, SHORT, -''- + UINT, SINT, -''- + LONG, -''- + DOUBLE -''- + + All other objects causes a pytave.ObjectConvertError to be + raised. This exception inherits TypeError. + + Octave to Python + ================ + + Scalar values to objects: + bool bool + real scalar float (64-bit) + string, sq_string str + str string + + Matrix values to Numeric arrays: + int64 LONG + int32, uint32 INT, UINT + int16, uint16 SHORT, USHORT + int8, unint8 SBYTE, UBYTE + + All other values causes a pytave.ValueConvertError to be + raised. This exception inherits TypeError. + + Errors + ****** + + Octave runtime errors are encapsulated into + pytave.OctaveError exceptions, base class RuntimeError. + + """ + + return _pytave.feval(nargout, funcname, arguments) + +def addpath(*arguments): + """See Octave documentation""" + return _pytave.feval(1, "addpath", arguments)[0] + +def rmpath(*paths): + """See Octave documentation""" + return _pytave.feval(1, "rmpath", paths)[0] + +def path(*paths): + """See Octave documentation""" + return _pytave.feval(1, "path", paths)[0] + +# Emacs +# Local Variables: +# fill-column:70 +# coding:utf-8 +# indent-tabs-mode:t +# tab-width:3 +# End: +# vim: set textwidth=70 noexpandtab tabstop=3 : diff -r 000000000000 -r 4da14cce0890 project-root.jam.in diff -r 000000000000 -r 4da14cce0890 pytave.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pytave.cc Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,164 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +#define PYTAVE_DO_DECLARE_SYMBOL +#include "arrayobjectdefs.h" +#include +#include + +#undef HAVE_STAT /* Both boost.python and octave define HAVE_STAT... */ +#include +#include +#include +#include +#include + +#include +#include + +#include + +#include +#include +#include +#include + +#include "pytavedefs.h" + +#include "exceptions.h" +#include "python_to_octave.h" +#include "octave_to_python.h" + +using namespace boost::python; +using namespace std; + +namespace pytave { /* {{{ */ + + void init() { + + if (!octave_error_exception::init() + || !value_convert_exception::init() + || !object_convert_exception::init()) { + PyErr_SetString(PyExc_ImportError, "_pytave: init failed"); + return; + } + + set_liboctave_error_handler(error); + set_liboctave_warning_handler(warning); + set_liboctave_warning_with_id_handler(warning_with_id); + + // New in Octave 3 + initialize_default_warning_state(); + + install_defaults(); + initialize_file_io(); + initialize_symbol_tables(); + install_types(); + + install_ops(); + + install_builtins(); + + // true argument new in Octave 3 + load_path::initialize(true); // or use false to set empty path + + // initialize python numeric array + import_array(); + } + + boost::python::tuple get_exceptions() { + return make_tuple(object(handle( + octave_error_exception::excclass)), + object(handle( + value_convert_exception::excclass)), + object(handle( + object_convert_exception::excclass))); + } + + boost::python::tuple func_eval(const int nargout, + const std::string &funcname, + const boost::python::tuple &arguments) { + + octave_value_list octave_args, retval; + + pytuple_to_octlist(octave_args, arguments); + + reset_error_handler(); + buffer_error_messages++; + + Py_BEGIN_ALLOW_THREADS + retval = feval(funcname, octave_args, nargout); + Py_END_ALLOW_THREADS + + if (error_state != 0) { +// error_state values: +// -2 error without traceback +// -1 traceback +// 1 general error + int parse_status = 0; + reset_error_handler(); + octave_value_list tmp = eval_string("lasterror.message", + true, parse_status, 1); + if (!tmp.empty() && tmp(0).is_string()) + throw octave_error_exception(tmp(0).string_value()); + else + throw octave_error_exception(""); + } + + if (nargout > 0) { + boost::python::tuple pytuple; + octlist_to_pytuple(pytuple, retval); + return pytuple; + } else { + // Return () if nargout <= 0. + return make_tuple(); + } + } +} /* namespace pytave }}} */ + +BOOST_PYTHON_MODULE(_pytave) { /* {{{ */ + using namespace boost::python; + + def("init", pytave::init); + def("feval", pytave::func_eval); + def("get_exceptions", pytave::get_exceptions); + + register_exception_translator( + pytave::pytave_exception::translate_exception); + + register_exception_translator( + pytave::octave_error_exception::translate_exception); + + register_exception_translator( + pytave::object_convert_exception::translate_exception); + + register_exception_translator( + pytave::value_convert_exception::translate_exception); + +} /* }}} */ + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 pytavedefs.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pytavedefs.h Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,38 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +// This file MUST NOT be included in header files. +// It should be included after library includes. + +/* XXX: Octave leaks its internal config.h to the include files */ +#include "config.h.in" +#ifndef HAVE_CONFIG_H +#error Need config.h file +#endif +#include "config.h" + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 python_to_octave.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python_to_octave.cc Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,228 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +#include +#include +#include +#include "arrayobjectdefs.h" +#undef HAVE_STAT /* both boost.python and octave defines HAVE_STAT... */ +#include +#include +#include + +#include "pytavedefs.h" +#include "exceptions.h" + +using namespace std; +using namespace boost::python; + +namespace pytave { + + template + static void copy_pyarrobj_to_octarray(OctaveBase &matrix, + const PyArrayObject* const pyarr, + const int unsigned matindex, + const unsigned int matstride, + const int dimension, + const unsigned int offset) { + unsigned char *ptr = (unsigned char*) pyarr->data; + if (dimension == pyarr->nd - 1) { + // Last dimension, base case + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + matrix.elem(matindex + i*matstride) + = *(PythonPrimitive*) + &ptr[offset + i*pyarr->strides[dimension]]; + } + } else { + for (int i = 0; i < pyarr->dimensions[dimension]; i++) { + copy_pyarrobj_to_octarray( + matrix, + pyarr, + matindex + i*matstride, + matstride * pyarr->dimensions[dimension], + dimension + 1, + offset + i*pyarr->strides[dimension]); + } + } + } + + template + static void copy_pyarrobj_to_octarray_boot(OctaveBase &matrix, + const PyArrayObject* const pyarr) { + +#define ARRAYCASE(AC_pyarrtype, AC_primitive) case AC_pyarrtype: \ + copy_pyarrobj_to_octarray\ + (matrix, pyarr, 0, 1, 0, 0); \ + break; \ + + switch (pyarr->descr->type_num) { +// ARRAYCASE(PyArray_CHAR, ) + ARRAYCASE(PyArray_UBYTE, unsigned char) + ARRAYCASE(PyArray_SBYTE, signed char) + ARRAYCASE(PyArray_SHORT, signed short) + ARRAYCASE(PyArray_USHORT, unsigned short) + ARRAYCASE(PyArray_INT, signed int) + ARRAYCASE(PyArray_UINT, unsigned int) + ARRAYCASE(PyArray_LONG, signed long) + + /* Commonly Numeric.array(..., Numeric.Float32) */ + ARRAYCASE(PyArray_FLOAT, float) + + /* Commonly Numeric.array(..., Numeric.Float) */ + ARRAYCASE(PyArray_DOUBLE, double) +// ARRAYCASE(PyArray_CFLOAT, ) +// ARRAYCASE(PyArray_CDOUBLE, ) +// ARRAYCASE(PyArray_OBJECT, ) + default: + throw object_convert_exception( + PyEval_GetFuncName((PyObject*)pyarr) + + (PyEval_GetFuncDesc((PyObject*)pyarr) + + string(": Unsupported Python array type"))); + } + } + + template + static void pyarrobj_to_octvalueNd(octave_value &octvalue, + const PyArrayObject* const pyarr, + dim_vector dims) { + OctaveBase array(dims); + copy_pyarrobj_to_octarray_boot(array, pyarr); + octvalue = array; + } + + static void pyarr_to_octvalue(octave_value &octvalue, + const PyArrayObject *pyarr) { + if (pyarr->nd < 1) + throw object_convert_exception("Less than 1 dimensions not supported"); + + dim_vector dims; + switch (pyarr->nd) { + case 1: + // Always make PyArray vectors row vectors. + dims = dim_vector(1, pyarr->dimensions[0]); + break; + default: + dims.resize(pyarr->nd); + for (int d = 0; d < pyarr->nd; d++) { + dims(d) = pyarr->dimensions[d]; + } + break; + } + + switch (pyarr->descr->type_num) { + case PyArray_UBYTE: + case PyArray_USHORT: + case PyArray_UINT: + switch (pyarr->descr->elsize) { + case 1: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + case 2: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + case 4: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + default: + throw object_convert_exception("Unknown unsigned integer."); + } + case PyArray_SBYTE: + case PyArray_SHORT: + case PyArray_INT: + case PyArray_LONG: + switch (pyarr->descr->elsize) { + case 1: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + case 2: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + case 4: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + case 8: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + default: + throw object_convert_exception("Unknown integer."); + } + break; + case PyArray_FLOAT: +#ifdef PYTAVE_USE_OCTAVE_FLOATS + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; +#else + /* fallthrough */ +#endif + case PyArray_DOUBLE: + pyarrobj_to_octvalueNd(octvalue, pyarr, dims); + break; + default: + throw object_convert_exception( + PyEval_GetFuncDesc((PyObject*)(pyarr)) + string(" ") + + PyEval_GetFuncName((PyObject*)(pyarr)) + + ": Encountered unsupported Python array"); + break; + } + } + + void pyobj_to_octvalue(octave_value &oct_value, + const boost::python::object &py_object) { + extract intx(py_object); + extract doublex(py_object); + extract stringx(py_object); + extract arrayx(py_object); + if (intx.check()) { + oct_value = intx(); + } else if (doublex.check()) { + oct_value = doublex(); + } else if (arrayx.check()) { + pyarr_to_octvalue(oct_value, (PyArrayObject*)py_object.ptr()); + } else if (stringx.check()) { + oct_value = stringx(); + } else { + throw object_convert_exception( + PyEval_GetFuncName(py_object.ptr()) + + (PyEval_GetFuncDesc(py_object.ptr()) + + string(": Unsupported Python object type, " + "cannot convert to Octave value"))); + } + } + + void pytuple_to_octlist(octave_value_list &octave_list, + const boost::python::tuple &python_tuple) { + int length = extract(python_tuple.attr("__len__")()); + + for (int i = 0; i < length; i++) { + pyobj_to_octvalue(octave_list(i), python_tuple[i]); + } + } + + +} + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 python_to_octave.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python_to_octave.h Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,41 @@ +/* + * Copyright 2008 David Grundberg, HÃ¥kan Fors Nilsson + * + * This file is part of Pytave. + * + * Pytave is free software: you can 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. + * + * Pytave is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Pytave. If not, see . + */ + +#ifndef PYTHON_TO_OCTAVE_H +#define PYTHON_TO_OCTAVE_H + +class octave_value_list; +class boost::python::tuple; + +namespace pytave { + void pytuple_to_octlist(octave_value_list &octave_list, + const boost::python::tuple &python_tuple); +} + +#endif /* PYTHON_TO_OCTAVE_H */ + +/* Emacs + * Local Variables: + * fill-column:79 + * coding:utf-8 + * indent-tabs-mode:nil + * c-basic-offset:3 + * End: + * vim: set textwidth=79 expandtab shiftwidth=3 : + */ diff -r 000000000000 -r 4da14cce0890 setup.py.in --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/setup.py.in Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,41 @@ +#!/usr/bin/python +# -*- coding: utf-8; c-basic-offset: 3; indent-tabs-mode: nil; tab-width: 3; -*- +# @configure_input@ + +from distutils.core import setup, Extension + +setup( + name = 'pytave', + version = '@PACKAGE_VERSION@', + author = '@PACKAGE_NAME@ team', + author_email = '@PACKAGE_BUGREPORT@', + package_dir = {'pytave' : '@srcdir@/package'}, + packages = ['pytave'], + ext_modules = [ + Extension('pytave/_pytave', + language = "c++", + sources = [ + '@srcdir@/octave_to_python.cc', + '@srcdir@/pytave.cc', + '@srcdir@/exceptions.cc', + '@srcdir@/python_to_octave.cc', + ], + depends = [ + '@srcdir@/arrayobjectdefs.h', + '@srcdir@/config.h', + '@srcdir@/octave_to_python.h', + '@srcdir@/pytavedefs.h', + '@srcdir@/exceptions.h', + '@srcdir@/python_to_octave.h' + ], + + # TODO: Check whether paths work on Windows or not. + # The file separator might be wrong. (Must be / in setup.cfg) + include_dirs = ['@PYTAVE_OCTAVE_INCLUDE_PATH@', '@abs_builddir@', '@srcdir@'], # Python always included. + define_macros = [('HAVE_CONFIG_H', '1')], + library_dirs = ['@PYTAVE_OCTAVE_RPATH@'], + runtime_library_dirs = ['@PYTAVE_OCTAVE_RPATH@'], + libraries = ['octinterp', 'octave', 'cruft', '@BOOST_PYTHON_LIB@'] + ) + ] +) diff -r 000000000000 -r 4da14cce0890 test/exceptions.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/exceptions.py Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,23 @@ +#!/usr/bin/python +import pytave + +try: + pytave.feval(1,"",) +except pytave.OctaveError, e: + print "test ok" +except: + print "test fail" + +try: + pytave.feval(1,"cell",) +except pytave.ValueConvertError, e: + print "test ok" +except: + print "test fail" + +try: + pytave.feval(1,"sin",{"asdf":"asdf"}) +except pytave.ObjectConvertError, e: + print "test ok" +except: + print "test fail" diff -r 000000000000 -r 4da14cce0890 test/test.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/test.py Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,89 @@ +#!/usr/bin/python + +import pytave +import Numeric + +pytave.feval(0, "addpath", ".",); + +arr0_0 = Numeric.zeros((0,0)); +arr0_1 = Numeric.zeros((0,1)); +arr1_0 = Numeric.zeros((1,0)); +arr1f = Numeric.array([1, 2, 3, 4], Numeric.Float32) +arr1b = Numeric.array([1, 2, 3, 256], Numeric.Int8) +arr1i = Numeric.array([1, 2, 3, 4], Numeric.Int) +arr1i32 = Numeric.array([1, 2, 3, 4], Numeric.Int32) +arr1a = Numeric.array([1, 2, 3, 4]) +arr2f = Numeric.array([[1, 2, 3, 4],[5,6,7,8]], Numeric.Float32) +arr2d = Numeric.array([[1, 2, 3, 4],[5,6,7,8]], Numeric.Float) +arr3f = Numeric.array([[[1, 2, 3, 4],[5,6,7,8]],[[9, 10, 11, 12],[13,14,15,16]]], Numeric.Float32) + +alimit_int32 = Numeric.array([-2147483648, 2147483647], Numeric.Int32); +alimit_int16 = Numeric.array([-32768, 32767, -32769, 32768], Numeric.Int16); +alimit_int8 = Numeric.array([-128, 127, -129, 128], Numeric.Int8); +alimit_uint8 = Numeric.array([0, 255, -1, 256], Numeric.UnsignedInt8); + + +b = pytave.feval(1, "testfile", 1) +print "first exec ok:", b + +def testequal(value): + try: + print "------------ test ", value + nvalue = pytave.feval(1, "testfile", *value) + if nvalue != value: + print "Equal ", value, " == ", nvalue, ", ", (nvalue == value), " Equal" + except TypeError, e: + print "Execute failed: ", value,":", e + +def testint(value): + try: + print "------------ int test ", value + nvalue = pytave.feval(1, "testfile", *value) + class1 = pytave.feval(1, "class", *value) + class2 = pytave.feval(1, "class", *nvalue) + if class1 != class2: + print "Integer check failed, got ",class1, "and later", class2 + except TypeError, e: + print "Execute failed: ", value,":", e + +print "------------" + +testint((alimit_int32, )) +testint((alimit_int16, )) +testint((alimit_int8, )) + +testequal((alimit_int32, )) +testequal((alimit_int16, )) +testequal((alimit_int8, )) + +testequal(("mystring", )) + +testequal((1, )) +testequal((1L, )) +testequal((1.2, )) +testequal((1.2, )) +testequal((arr1a, )) + +testequal((arr1f, )) +testequal((arr1i, )) +testequal((arr1b, )) +testequal((arr1i32, )) +testequal((arr2f, )) +testequal((arr2d, )) + +testequal((arr3f, )) + +print("Equality for these three tests fails") +testequal((arr0_0, )) +testequal((arr1_0, )) +testequal((arr0_1, )) + +# these should fail. +print("These tests should fail.") +testequal(([1, 2],)) +testequal((None,)) +testequal(((1,),)) +testequal(([],)) +testequal(((),)) +testequal((1, 8.9, 3, 4, "testfile", [], arr1f)) + diff -r 000000000000 -r 4da14cce0890 testfile.m --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testfile.m Fri Oct 17 12:05:46 2008 +0200 @@ -0,0 +1,5 @@ +function [testresult] = testfile(arg) + disp(arg) + disp(["Type info: " typeinfo(arg)]) + testresult = arg;#int8([1]); +end