Revision including a bunch of patches from scipy-svn. Now also includes

  sandbox modules with a use flag. Revert to fftw-2.* for fftw, faster for
  complex. Added a patch to enable numpy-1.0.3 API changes.
Package-Manager: portage-2.1.2.7

12 files changed, 1392 insertions, 0 deletions

diff --git a/sci-libs/scipy/files/digest-scipy-0.5.2-r2 b/sci-libs/scipy/files/digest-scipy-0.5.2-r2
new file mode 100644
index 000000000000..89b1226c8e1b
--- /dev/null
+++ b/sci-libs/scipy/files/digest-scipy-0.5.2-r2
@@ -0,0 +1,3 @@
+MD5 e24387ac7f9e589816364db7c64c3185 scipy-0.5.2.tar.gz 6362164
+RMD160 fa945185df7fc48e03bafdddeaaea72a8eb4914d scipy-0.5.2.tar.gz 6362164
+SHA256 38e42155d3445699f28c36facdaa82200d8e017b4ca608f95f6d928065dc03ed scipy-0.5.2.tar.gz 6362164
diff --git a/sci-libs/scipy/files/enabled_packages.txt b/sci-libs/scipy/files/enabled_packages.txt
new file mode 100644
index 000000000000..9f1a335d9055
--- /dev/null
+++ b/sci-libs/scipy/files/enabled_packages.txt
@@ -0,0 +1,25 @@
+ann
+arpack
+arraysetops
+buildgrid
+constants
+cow
+delaunay
+exmplpackage
+fdfpack
+ga
+gplt
+image
+models
+montecarlo
+netcdf
+newoptimize
+numexpr
+plt
+pyem
+rkern
+spline
+stats
+svm
+umfpack
+xplt
diff --git a/sci-libs/scipy/files/scipy-0.5.2-bspline.patch b/sci-libs/scipy/files/scipy-0.5.2-bspline.patch
new file mode 100644
index 000000000000..2169438c6997
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-bspline.patch
@@ -0,0 +1,29 @@
+--- Lib/sandbox/models/bspline_module.py~	2006-12-07 01:13:15.000000000 +0000
++++ Lib/sandbox/models/bspline_module.py	2007-06-06 22:16:13.556342500 +0100
+@@ -128,7 +128,7 @@
+ 
+     eval_ext_code = '''
+ 
+-    int dim[2] = {upper-lower, Nx[0]};
++    npy_intp dim[2] = {upper-lower, Nx[0]};
+     PyArrayObject *basis;
+     double *data;
+ 
+@@ -252,7 +252,7 @@
+ 
+     gram_ext_code = '''
+ 
+-    int dim[2] = {Nknots[0]-m, m};
++    npy_intp dim[2] = {Nknots[0]-m, m};
+     double *data;
+     PyArrayObject *gram;
+ 
+@@ -315,7 +315,7 @@
+ 
+     invband_ext_code = '''
+ 
+-    int dim[2] = {NL[0], NL[1]};
++    npy_intp dim[2] = {NL[0], NL[1]};
+     int i, j;
+     double *data;
+     PyArrayObject *invband;
diff --git a/sci-libs/scipy/files/scipy-0.5.2-getpath.patch b/sci-libs/scipy/files/scipy-0.5.2-getpath.patch
new file mode 100644
index 000000000000..fe98a999411e
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-getpath.patch
@@ -0,0 +1,108 @@
+diff -Nur Lib.orig/linalg/setup_atlas_version.py Lib/linalg/setup_atlas_version.py
+--- Lib.orig/linalg/setup_atlas_version.py	2006-03-15 02:29:45.000000000 +0000
++++ Lib/linalg/setup_atlas_version.py	2007-06-06 16:43:08.000000000 +0100
+@@ -4,14 +4,14 @@
+ 
+ import os
+ from distutils.core import Extension
+-from numpy.distutils.misc_util import get_path, default_config_dict
++from numpy.distutils.misc_util import get_path_from_frame, default_config_dict
+ from numpy.distutils.system_info import get_info,AtlasNotFoundError
+ 
+ def configuration (parent_package=''):
+     package = 'linalg'
+     config = default_config_dict(package,parent_package)
+     del config['fortran_libraries']
+-    local_path = get_path(__name__)
++    local_path = get_path_from_frame(__name__)
+     atlas_info = get_info('atlas_threads')
+     if not atlas_info:
+         atlas_info = get_info('atlas')
+diff -Nur Lib.orig/odr/setup.py Lib/odr/setup.py
+--- Lib.orig/odr/setup.py	2006-12-02 03:24:44.000000000 +0000
++++ Lib/odr/setup.py	2007-06-06 16:43:08.000000000 +0100
+@@ -6,7 +6,7 @@
+ import warnings
+ 
+ from numpy.distutils.core import Extension
+-from numpy.distutils.misc_util import get_path, Configuration, dot_join
++from numpy.distutils.misc_util import get_path_from_frame, Configuration, dot_join
+ 
+ from numpy.distutils.system_info import get_info,dict_append,\
+      AtlasNotFoundError,LapackNotFoundError,BlasNotFoundError,\
+diff -Nur Lib.orig/sandbox/ga/setup_ga.py Lib/sandbox/ga/setup_ga.py
+--- Lib.orig/sandbox/ga/setup_ga.py	2006-01-05 03:35:26.000000000 +0000
++++ Lib/sandbox/ga/setup_ga.py	2007-06-06 16:43:08.000000000 +0100
+@@ -1,7 +1,7 @@
+ #!/usr/bin/env python
+ 
+ import os
+-from numpy.distutils.misc_util import get_path, default_config_dict
++from numpy.distutils.misc_util import get_path_from_frame, default_config_dict
+ 
+ def configuration(parent_package='',parent_path=None):
+     package = 'ga'
+diff -Nur Lib.orig/sandbox/gplt/setup_gplt.py Lib/sandbox/gplt/setup_gplt.py
+--- Lib.orig/sandbox/gplt/setup_gplt.py	2006-01-05 03:35:31.000000000 +0000
++++ Lib/sandbox/gplt/setup_gplt.py	2007-06-06 16:43:08.000000000 +0100
+@@ -1,11 +1,11 @@
+ #!/usr/bin/env python
+ 
+ import os, sys
+-from numpy.distutils.misc_util import get_path, default_config_dict
++from numpy.distutils.misc_util import get_path_from_frame, default_config_dict
+ 
+ def configuration(parent_package='',parent_path=None):
+     package = 'gplt'
+-    local_path = get_path(__name__,parent_path)
++    local_path = get_path_from_frame(__name__,parent_path)
+     config = default_config_dict(package,parent_package)
+ 
+     if sys.platform == 'win32':
+diff -Nur Lib.orig/sandbox/image/setup_image.py Lib/sandbox/image/setup_image.py
+--- Lib.orig/sandbox/image/setup_image.py	2006-03-15 02:29:18.000000000 +0000
++++ Lib/sandbox/image/setup_image.py	2007-06-06 16:43:08.000000000 +0100
+@@ -6,12 +6,12 @@
+ def configuration(parent_package='', parent_path=None):
+     from numpy.distutils.system_info import get_info, dict_append
+     from numpy.distutils.misc_util import default_config_dict, \
+-         dot_join, get_path
++         dot_join, get_path_from_frame
+ 
+     package = 'image'
+     config = default_config_dict(package,parent_package)
+ 
+-    local_path = get_path(__name__, parent_path)
++    local_path = get_path_from_frame(__name__, parent_path)
+     image_path = os.path.join(parent_package,'image')
+ 
+     color_files = glob(os.path.join(local_path, '*.txt'))
+diff -Nur Lib.orig/sandbox/plt/setup_plt.py Lib/sandbox/plt/setup_plt.py
+--- Lib.orig/sandbox/plt/setup_plt.py	2006-01-13 00:08:11.000000000 +0000
++++ Lib/sandbox/plt/setup_plt.py	2007-06-06 16:43:08.000000000 +0100
+@@ -1,11 +1,11 @@
+ #!/usr/bin/env python
+ 
+ import os
+-from numpy.distutils.misc_util import get_path, default_config_dict
++from numpy.distutils.misc_util import get_path_from_frame, default_config_dict
+ 
+ def configuration(parent_package='',parent_path=None):
+     package = 'plt'
+-    local_path = get_path(__name__,parent_path)
++    local_path = get_path_from_frame(__name__,parent_path)
+     config = default_config_dict(package,parent_package)
+     return config
+ 
+diff -Nur Lib.orig/sandbox/pysparse/setup.py Lib/sandbox/pysparse/setup.py
+--- Lib.orig/sandbox/pysparse/setup.py	2006-03-15 02:29:36.000000000 +0000
++++ Lib/sandbox/pysparse/setup.py	2007-06-06 16:43:08.000000000 +0100
+@@ -12,7 +12,7 @@
+ 
+ import os
+ from numpy.distutils.core import Extension
+-from numpy.distutils.misc_util import get_path,Configuration,dot_join
++from numpy.distutils.misc_util import get_path_from_frame,Configuration,dot_join
+ join = os.path.join
+ import glob
+ 
diff --git a/sci-libs/scipy/files/scipy-0.5.2-minpack.patch b/sci-libs/scipy/files/scipy-0.5.2-minpack.patch
new file mode 100644
index 000000000000..496fd70e06f3
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-minpack.patch
@@ -0,0 +1,10 @@
+--- Lib/optimize/__minpack.h.orig	2007-06-06 17:34:35.232483750 +0100
++++ Lib/optimize/__minpack.h	2007-06-06 17:34:37.788643500 +0100
+@@ -585,7 +585,6 @@
+   else {
+     Py_DECREF(ap_fvec);
+     Py_DECREF(ap_fjac);
+-    Py_DECREF(ap_diag);
+     Py_DECREF(ap_ipvt);
+     Py_DECREF(ap_qtf);
+     return Py_BuildValue("Ni",PyArray_Return(ap_x),info);
diff --git a/sci-libs/scipy/files/scipy-0.5.2-mio.patch b/sci-libs/scipy/files/scipy-0.5.2-mio.patch
new file mode 100644
index 000000000000..b48c8eb4e770
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-mio.patch
@@ -0,0 +1,524 @@
+diff -Nur Lib/io.orig/mio4.py Lib/io/mio4.py
+--- Lib/io.orig/mio4.py	2007-06-06 14:56:05.610464000 +0100
++++ Lib/io/mio4.py	2007-06-06 14:56:17.015176750 +0100
+@@ -1,9 +1,9 @@
+ ''' Classes for read / write of matlab (TM) 4 files
+ '''
+ 
+-from numpy import *
++import numpy as N
+ 
+-from miobase import *
++from scipy.io.miobase import *
+ 
+ miDOUBLE = 0
+ miSINGLE = 1
+@@ -76,7 +76,7 @@
+         header['mclass'] = T
+         header['dims'] = (data['mrows'], data['ncols'])
+         header['is_complex'] = data['imagf'] == 1
+-        remaining_bytes = header['dtype'].itemsize * product(header['dims'])
++        remaining_bytes = header['dtype'].itemsize * N.product(header['dims'])
+         if header['is_complex'] and not header['mclass'] == mxSPARSE_CLASS:
+             remaining_bytes *= 2
+         next_pos = self.mat_stream.tell() + remaining_bytes
+@@ -109,7 +109,7 @@
+         num_bytes = dt.itemsize
+         for d in dims:
+             num_bytes *= d
+-        arr = ndarray(shape=dims,
++        arr = N.ndarray(shape=dims,
+                       dtype=dt,
+                       buffer=self.mat_stream.read(num_bytes),
+                       order='F')
+@@ -122,9 +122,9 @@
+     def __init__(self, array_reader, header):
+         super(Mat4FullGetter, self).__init__(array_reader, header)
+         if header['is_complex']:
+-            self.mat_dtype = dtype(complex128)
++            self.mat_dtype = N.dtype(N.complex128)
+         else:
+-            self.mat_dtype = dtype(float64)
++            self.mat_dtype = N.dtype(N.float64)
+         
+     def get_raw_array(self):
+         if self.header['is_complex']:
+@@ -137,12 +137,12 @@
+ 
+ class Mat4CharGetter(Mat4MatrixGetter):
+     def get_raw_array(self):
+-        arr = self.read_array().astype(uint8)
++        arr = self.read_array().astype(N.uint8)
+         # ascii to unicode
+         S = arr.tostring().decode('ascii')
+-        return ndarray(shape=self.header['dims'],
+-                       dtype=dtype('U1'),
+-                       buffer = array(S)).copy()
++        return N.ndarray(shape=self.header['dims'],
++                       dtype=N.dtype('U1'),
++                       buffer = N.array(S)).copy()
+ 
+ 
+ class Mat4SparseGetter(Mat4MatrixGetter):
+@@ -166,7 +166,7 @@
+         res = self.read_array()
+         tmp = res[:-1,:]
+         dims = res[-1,0:2]
+-        ij = transpose(tmp[:,0:2]) - 1 # for 1-based indexing
++        ij = N.transpose(tmp[:,0:2]) - 1 # for 1-based indexing
+         vals = tmp[:,2]
+         if res.shape[1] == 4:
+             vals = vals + res[:-1,3] * 1j
+@@ -196,15 +196,15 @@
+     def format_looks_right(self):
+         # Mat4 files have a zero somewhere in first 4 bytes
+         self.mat_stream.seek(0)
+-        mopt_bytes = ndarray(shape=(4,),
+-                             dtype=uint8,
++        mopt_bytes = N.ndarray(shape=(4,),
++                             dtype=N.uint8,
+                              buffer = self.mat_stream.read(4))
+         self.mat_stream.seek(0)
+         return 0 in mopt_bytes
+     
+     def guess_byte_order(self):
+         self.mat_stream.seek(0)
+-        mopt = self.read_dtype(dtype('i4'))
++        mopt = self.read_dtype(N.dtype('i4'))
+         self.mat_stream.seek(0)
+         if mopt < 0 or mopt > 5000:
+             return ByteOrder.swapped_code
+@@ -222,7 +222,7 @@
+         '''
+         if dims is None:
+             dims = self.arr.shape
+-        header = empty((), mdtypes_template['header'])
++        header = N.empty((), mdtypes_template['header'])
+         M = not ByteOrder.little_endian
+         O = 0
+         header['mopt'] = (M * 1000 +
+@@ -237,11 +237,10 @@
+         self.write_string(self.name + '\0')
+         
+     def arr_to_2d(self):
+-        self.arr = atleast_2d(self.arr)
++        self.arr = N.atleast_2d(self.arr)
+         dims = self.arr.shape
+         if len(dims) > 2:
+-            dims = [product(dims[:-1]), dims[-1]]
+-            self.arr = reshape(self.arr, dims)
++            self.arr = self.arr.reshape(-1,dims[-1])
+             
+     def write(self):
+         assert False, 'Not implemented'
+@@ -280,12 +279,12 @@
+                           T=mxCHAR_CLASS)
+         if self.arr.dtype.kind == 'U':
+             # Recode unicode to ascii
+-            n_chars = product(dims)
+-            st_arr = ndarray(shape=(),
++            n_chars = N.product(dims)
++            st_arr = N.ndarray(shape=(),
+                              dtype=self.arr_dtype_number(n_chars),
+                              buffer=self.arr)
+             st = st_arr.item().encode('ascii')
+-            self.arr = ndarray(shape=dims, dtype='S1', buffer=st)
++            self.arr = N.ndarray(shape=dims, dtype='S1', buffer=st)
+         self.write_bytes(self.arr)
+ 
+ 
+@@ -296,9 +295,9 @@
+         See docstring for Mat4SparseGetter
+         '''
+         imagf = self.arr.dtype.kind == 'c'
+-        N = self.arr.nnz
+-        ijd = zeros((N+1, 3+imagf), dtype='f8')
+-        for i in range(N):
++        nnz = self.arr.nnz
++        ijd = N.zeros((nnz+1, 3+imagf), dtype='f8')
++        for i in range(nnz):
+             ijd[i,0], ijd[i,1] = self.arr.rowcol(i)
+         ijd[:-1,0:2] += 1 # 1 based indexing
+         if imagf:
+@@ -322,13 +321,13 @@
+     if have_sparse:
+         if scipy.sparse.issparse(arr):
+             return Mat4SparseWriter(stream, arr, name)
+-    arr = array(arr)
++    arr = N.array(arr)
+     dtt = arr.dtype.type
+-    if dtt is object_:
++    if dtt is N.object_:
+         raise TypeError, 'Cannot save object arrays in Mat4'
+-    elif dtt is void:
++    elif dtt is N.void:
+         raise TypeError, 'Cannot save void type arrays'
+-    elif dtt in (unicode_, string_):
++    elif dtt in (N.unicode_, N.string_):
+         return Mat4CharWriter(stream, arr, name)
+     else:
+         return Mat4NumericWriter(stream, arr, name)
+diff -Nur Lib/io.orig/mio5.py Lib/io/mio5.py
+--- Lib/io.orig/mio5.py	2007-06-06 14:56:05.610464000 +0100
++++ Lib/io/mio5.py	2007-06-06 14:56:17.019177000 +0100
+@@ -29,9 +29,9 @@
+ import zlib
+ from copy import copy as pycopy
+ from cStringIO import StringIO
+-from numpy import *
++import numpy as N
+ 
+-from miobase import *
++from scipy.io.miobase import *
+ 
+ try:  # Python 2.3 support
+     from sets import Set as set
+@@ -154,10 +154,10 @@
+ 
+     def read_element(self, copy=True):
+         raw_tag = self.mat_stream.read(8)
+-        tag = ndarray(shape=(),
++        tag = N.ndarray(shape=(),
+                       dtype=self.dtypes['tag_full'],
+                       buffer = raw_tag)
+-        mdtype = tag['mdtype']
++        mdtype = tag['mdtype'].item()
+         byte_count = mdtype >> 16
+         if byte_count: # small data element format
+             if byte_count > 4:
+@@ -165,10 +165,10 @@
+             mdtype = mdtype & 0xFFFF
+             dt = self.dtypes[mdtype]
+             el_count = byte_count / dt.itemsize
+-            return ndarray(shape=(el_count,),
++            return N.ndarray(shape=(el_count,),
+                            dtype=dt,
+                            buffer=raw_tag[4:])
+-        byte_count = tag['byte_count']
++        byte_count = tag['byte_count'].item()
+         if mdtype == miMATRIX:
+             return self.current_getter(byte_count).get_array()
+         if mdtype in self.codecs: # encoded char data
+@@ -180,7 +180,7 @@
+         else: # numeric data
+             dt = self.dtypes[mdtype]
+             el_count = byte_count / dt.itemsize
+-            el = ndarray(shape=(el_count,),
++            el = N.ndarray(shape=(el_count,),
+                          dtype=dt,
+                          buffer=self.mat_stream.read(byte_count))
+             if copy:
+@@ -193,8 +193,8 @@
+     def matrix_getter_factory(self):
+         ''' Returns reader for next matrix at top level '''
+         tag = self.read_dtype(self.dtypes['tag_full'])
+-        mdtype = tag['mdtype']
+-        byte_count = tag['byte_count']
++        mdtype = tag['mdtype'].item()
++        byte_count = tag['byte_count'].item()
+         next_pos = self.mat_stream.tell() + byte_count
+         if mdtype == miCOMPRESSED:
+             getter = Mat5ZArrayReader(self, byte_count).matrix_getter_factory()
+@@ -285,7 +285,7 @@
+         self.mat_dtype = 'f8'
+     
+     def get_raw_array(self):
+-        return array([[]])
++        return N.array([[]])
+ 
+ 
+ class Mat5NumericMatrixGetter(Mat5MatrixGetter):
+@@ -293,7 +293,7 @@
+     def __init__(self, array_reader, header):
+         super(Mat5NumericMatrixGetter, self).__init__(array_reader, header)
+         if header['is_logical']:
+-            self.mat_dtype = dtype('bool')
++            self.mat_dtype = N.dtype('bool')
+         else:
+             self.mat_dtype = self.class_dtypes[header['mclass']]
+ 
+@@ -305,7 +305,7 @@
+             res = res + (res_j * 1j)
+         else:
+             res = self.read_element()
+-        return ndarray(shape=self.header['dims'],
++        return N.ndarray(shape=self.header['dims'],
+                        dtype=res.dtype,
+                        buffer=res,
+                        order='F')
+@@ -334,14 +334,14 @@
+         stored in column order, this gives the column corresponding to
+         each rowind
+         '''
+-        cols = empty((len(res)), dtype=rowind.dtype)
+-        col_counts = diff(colind)
++        cols = N.empty((len(res)), dtype=rowind.dtype)
++        col_counts = N.diff(colind)
+         start_row = 0
+-        for i in where(col_counts)[0]:
++        for i in N.where(col_counts)[0]:
+             end_row = start_row + col_counts[i]
+             cols[start_row:end_row] = i
+             start_row = end_row
+-        ij = vstack((rowind[:len(res)], cols))
++        ij = N.vstack((rowind[:len(res)], cols))
+         if have_sparse:
+             result = scipy.sparse.csc_matrix((res,ij),
+                                              self.header['dims'])
+@@ -354,19 +354,19 @@
+     def get_raw_array(self):
+         res = self.read_element()
+         # Convert non-string types to unicode
+-        if isinstance(res, ndarray):
+-            if res.dtype.type == uint16:
++        if isinstance(res, N.ndarray):
++            if res.dtype.type == N.uint16:
+                 codec = miUINT16_codec
+                 if self.codecs['uint16_len'] == 1:
+-                    res = res.astype(uint8)
+-            elif res.dtype.type in (uint8, int8):
++                    res = res.astype(N.uint8)
++            elif res.dtype.type in (N.uint8, N.int8):
+                 codec = 'ascii'
+             else:
+                 raise TypeError, 'Did not expect type %s' % res.dtype
+             res = res.tostring().decode(codec)
+-        return ndarray(shape=self.header['dims'],
+-                       dtype=dtype('U1'),
+-                       buffer=array(res),
++        return N.ndarray(shape=self.header['dims'],
++                       dtype=N.dtype('U1'),
++                       buffer=N.array(res),
+                        order='F').copy()
+ 
+ 
+@@ -374,12 +374,11 @@
+     def get_raw_array(self):
+         # Account for fortran indexing of cells
+         tupdims = tuple(self.header['dims'][::-1])
+-        length = product(tupdims)
+-        result = empty(length, dtype=object)
++        length = N.product(tupdims)
++        result = N.empty(length, dtype=object)
+         for i in range(length):
+             result[i] = self.get_item()
+-        result = transpose(reshape(result,tupdims))
+-        return result
++        return result.reshape(tupdims).T
+ 
+     def get_item(self):
+         return self.read_element()
+@@ -507,7 +506,7 @@
+         ''' Read in mat 5 file header '''
+         hdict = {}
+         hdr = self.read_dtype(self.dtypes['file_header'])
+-        hdict['__header__'] = hdr['description'].strip(' \t\n\000')
++        hdict['__header__'] = hdr['description'].item().strip(' \t\n\000')
+         v_major = hdr['version'] >> 8
+         v_minor = hdr['version'] & 0xFF
+         hdict['__version__'] = '%d.%d' % (v_major, v_minor)
+@@ -516,8 +515,8 @@
+     def format_looks_right(self):
+         # Mat4 files have a zero somewhere in first 4 bytes
+         self.mat_stream.seek(0)
+-        mopt_bytes = ndarray(shape=(4,),
+-                             dtype=uint8,
++        mopt_bytes = N.ndarray(shape=(4,),
++                             dtype=N.uint8,
+                              buffer = self.mat_stream.read(4))
+         self.mat_stream.seek(0)
+         return 0 not in mopt_bytes
+@@ -525,7 +524,7 @@
+ 
+ class Mat5MatrixWriter(MatStreamWriter):
+ 
+-    mat_tag = zeros((), mdtypes_template['tag_full'])
++    mat_tag = N.zeros((), mdtypes_template['tag_full'])
+     mat_tag['mdtype'] = miMATRIX
+ 
+     def __init__(self, file_stream, arr, name, is_global=False):
+@@ -555,14 +554,14 @@
+         self._mat_tag_pos = self.file_stream.tell()
+         self.write_dtype(self.mat_tag)
+         # write array flags (complex, global, logical, class, nzmax)
+-        af = zeros((), mdtypes_template['array_flags'])
++        af = N.zeros((), mdtypes_template['array_flags'])
+         af['data_type'] = miUINT32
+         af['byte_count'] = 8
+         flags = is_complex << 3 | is_global << 2 | is_logical << 1
+         af['flags_class'] = mclass | flags << 8
+         af['nzmax'] = nzmax
+         self.write_dtype(af)
+-        self.write_element(array(self.arr.shape, dtype='i4'))
++        self.write_element(N.array(self.arr.shape, dtype='i4'))
+         self.write_element(self.name)
+ 
+     def update_matrix_tag(self):
+@@ -598,12 +597,12 @@
+                           T=mxCHAR_CLASS)
+         if self.arr.dtype.kind == 'U':
+             # Recode unicode to ascii
+-            n_chars = product(dims)
+-            st_arr = ndarray(shape=(),
++            n_chars = N.product(dims)
++            st_arr = N.ndarray(shape=(),
+                              dtype=self.arr_dtype_number(n_chars),
+                              buffer=self.arr)
+             st = st_arr.item().encode('ascii')
+-            self.arr = ndarray(shape=dims, dtype='S1', buffer=st)
++            self.arr = N.ndarray(shape=dims, dtype='S1', buffer=st)
+         self.write_bytes(self.arr)
+ 
+ 
+@@ -615,7 +614,7 @@
+         '''
+         imagf = self.arr.dtype.kind == 'c'
+         N = self.arr.nnz
+-        ijd = zeros((N+1, 3+imagf), dtype='f8')
++        ijd = N.zeros((N+1, 3+imagf), dtype='f8')
+         for i in range(N):
+             ijd[i,0], ijd[i,1] = self.arr.rowcol(i)
+         ijd[:-1,0:2] += 1 # 1 based indexing
+@@ -649,7 +648,7 @@
+         if have_sparse:
+             if scipy.sparse.issparse(arr):
+                 return Mat5SparseWriter(self.stream, arr, name, is_global)
+-        arr = array(arr)
++        arr = N.array(arr)
+         if arr.dtype.hasobject:
+             types, arr_type = classify_mobjects(arr)
+             if arr_type == 'c':
+@@ -680,13 +679,13 @@
+                         o  - object array
+         '''
+         N = objarr.size
+-        types = empty((N,), dtype='S1')
++        types = N.empty((N,), dtype='S1')
+         types[:] = 'i'
+         type_set = set()
+         flato = objarr.flat
+         for i in range(N):
+             obj = flato[i]
+-            if isinstance(obj, ndarray):
++            if isinstance(obj, N.ndarray):
+                 types[i] = 'a'
+                 continue
+             try:
+@@ -743,7 +742,7 @@
+                 ).write()
+             if self.do_compression:
+                 str = zlib.compress(stream.getvalue())
+-                tag = empty((), mdtypes_template['tag_full'])
++                tag = N.empty((), mdtypes_template['tag_full'])
+                 tag['mdtype'] = miCOMPRESSED
+                 tag['byte_count'] = len(str)
+                 self.file_stream.write(tag.tostring() + str)
+diff -Nur Lib/io.orig/miobase.py Lib/io/miobase.py
+--- Lib/io.orig/miobase.py	2007-06-06 14:56:05.610464000 +0100
++++ Lib/io/miobase.py	2007-06-06 14:56:17.019177000 +0100
+@@ -6,7 +6,7 @@
+ 
+ import sys
+ 
+-from numpy import *
++import numpy as N
+ 
+ try:
+     import scipy.sparse
+@@ -71,10 +71,10 @@
+         a_dtype is assumed to be correct endianness
+         '''
+         num_bytes = a_dtype.itemsize
+-        arr = ndarray(shape=(),
+-                      dtype=a_dtype,
+-                      buffer=self.mat_stream.read(num_bytes),
+-                      order='F')
++        arr = N.ndarray(shape=(),
++                        dtype=a_dtype,
++                        buffer=self.mat_stream.read(num_bytes),
++                        order='F')
+         return arr
+ 
+     def read_ztstring(self, num_bytes):
+@@ -184,7 +184,7 @@
+     def convert_dtypes(self, dtype_template):
+         dtypes = dtype_template.copy()
+         for k in dtypes:
+-            dtypes[k] = dtype(dtypes[k]).newbyteorder(
++            dtypes[k] = N.dtype(dtypes[k]).newbyteorder(
+                 self.order_code)
+         return dtypes
+     
+@@ -227,10 +227,10 @@
+                 if len(dims) >= 2: # return array of strings
+                     dtt = self.order_code + 'U'
+                     n_dims = dims[:-1]
+-                    str_arr = reshape(arr,
+-                                    (small_product(n_dims),
+-                                     dims[-1]))
+-                    arr = empty(n_dims, dtype=object)
++                    str_arr = arr.reshape(
++                        (small_product(n_dims),
++                         dims[-1]))
++                    arr = N.empty(n_dims, dtype=object)
+                     for i in range(0, n_dims[-1]):
+                         arr[...,i] = self.chars_to_str(str_arr[i])
+                 else: # return string
+@@ -241,9 +241,9 @@
+                 if getter.mat_dtype is not None:
+                     arr = arr.astype(getter.mat_dtype)
+             if self.squeeze_me:
+-                arr = squeeze(arr)
++                arr = N.squeeze(arr)
+                 if not arr.size:
+-                    arr = array([])
++                    arr = N.array([])
+                 elif not arr.shape: # 0d coverted to scalar
+                     arr = arr.item()
+             return arr
+@@ -251,8 +251,8 @@
+ 
+     def chars_to_str(self, str_arr):
+         ''' Convert string array to string '''
+-        dt = dtype('U' + str(small_product(str_arr.shape)))
+-        return ndarray(shape=(),
++        dt = N.dtype('U' + str(small_product(str_arr.shape)))
++        return N.ndarray(shape=(),
+                        dtype = dt,
+                        buffer = str_arr.copy()).item()
+ 
+@@ -354,7 +354,7 @@
+         
+     def arr_dtype_number(self, num):
+         ''' Return dtype for given number of items per element'''
+-        return dtype(self.arr.dtype.str[:2] + str(num))
++        return N.dtype(self.arr.dtype.str[:2] + str(num))
+ 
+     def arr_to_chars(self):
+         ''' Convert string array to char array '''
+@@ -362,7 +362,7 @@
+         if not dims:
+             dims = [1]
+         dims.append(int(self.arr.dtype.str[2:]))
+-        self.arr = ndarray(shape=dims,
++        self.arr = N.ndarray(shape=dims,
+                            dtype=self.arr_dtype_number(1),
+                            buffer=self.arr)
+ 
+diff -Nur Lib/io.orig/mio.py Lib/io/mio.py
+--- Lib/io.orig/mio.py	2007-06-06 14:56:05.610464000 +0100
++++ Lib/io/mio.py	2007-06-06 14:56:17.015176750 +0100
+@@ -7,10 +7,10 @@
+ import os
+ import sys
+ 
+-from numpy import *
++from scipy.io.mio4 import MatFile4Reader, MatFile4Writer
++from scipy.io.mio5 import MatFile5Reader, MatFile5Writer
+ 
+-from mio4 import MatFile4Reader, MatFile4Writer
+-from mio5 import MatFile5Reader, MatFile5Writer
++__all__ = ['find_mat_file','mat_reader_factory','loadmat', 'savemat']
+ 
+ def find_mat_file(file_name, appendmat=True):
+     ''' Try to find .mat file on system path
diff --git a/sci-libs/scipy/files/scipy-0.5.2-montecarlo-test.patch b/sci-libs/scipy/files/scipy-0.5.2-montecarlo-test.patch
new file mode 100644
index 000000000000..681b32057815
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-montecarlo-test.patch
@@ -0,0 +1,11 @@
+--- Lib/sandbox/montecarlo/tests/test_dictsampler.py.orig	2007-06-06 14:25:47.000000000 +0100
++++ Lib/sandbox/montecarlo/tests/test_dictsampler.py	2007-06-06 14:26:02.000000000 +0100
+@@ -37,7 +37,7 @@
+         #import pdb
+         #pdb.set_trace()
+         s = sampler.sample(n)
+-        assert sum(s[i]=='b' for i in range(n),axis=0)*1./n > 0.75
++        assert sum((s[i]=='b' for i in range(n)),axis=0)*1./n > 0.75
+ 
+         #lam = 10.0
+         #n = 35
diff --git a/sci-libs/scipy/files/scipy-0.5.2-nonexisting.patch b/sci-libs/scipy/files/scipy-0.5.2-nonexisting.patch
new file mode 100644
index 000000000000..182768dfeff2
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-nonexisting.patch
@@ -0,0 +1,42 @@
+--- Lib/maxentropy/setup.py.orig	2007-06-06 16:04:57.267196500 +0100
++++ Lib/maxentropy/setup.py	2007-06-06 16:05:54.786791250 +0100
+@@ -10,7 +10,6 @@
+ 
+     config.add_data_dir('tests')
+     config.add_data_dir('examples')
+-    config.add_data_dir('doc')
+ 
+     return config
+ 
+--- Lib/linsolve/setup.py.orig	2007-06-06 16:10:41.592715500 +0100
++++ Lib/linsolve/setup.py	2007-06-06 16:11:01.929986500 +0100
+@@ -7,7 +7,6 @@
+     from numpy.distutils.system_info import get_info
+ 
+     config = Configuration('linsolve',parent_package,top_path)
+-    config.add_data_dir('tests')
+ 
+     lapack_opt = get_info('lapack_opt',notfound_action=2)
+     if sys.platform=='win32':
+--- Lib/sandbox/buildgrid/setup.py.orig	2007-06-06 16:49:49.411337500 +0100
++++ Lib/sandbox/buildgrid/setup.py	2007-06-06 16:50:03.436214000 +0100
+@@ -10,7 +10,7 @@
+                           
+     config.add_extension('build_grid',
+                          sources = ['build_grid.c'])
+-    config.add_data_files('README')
++    config.add_data_files('README.txt')
+     return config
+ 
+ if __name__ == "__main__":
+--- Lib/sandbox/montecarlo/setup.py.orig	2007-06-06 16:50:34.242139250 +0100
++++ Lib/sandbox/montecarlo/setup.py	2007-06-06 16:52:00.442607500 +0100
+@@ -15,8 +15,6 @@
+                         ['_intsamplermodule.c', 'compact5table.c', 'randomkit.c']])
+     
+     config.add_data_dir('tests')
+-    config.add_data_dir('examples')
+-    config.add_data_dir('doc')
+ 
+     return config
+ 
diff --git a/sci-libs/scipy/files/scipy-0.5.2-randomkit.patch b/sci-libs/scipy/files/scipy-0.5.2-randomkit.patch
new file mode 100644
index 000000000000..8ff523b1f866
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-randomkit.patch
@@ -0,0 +1,552 @@
+--- Lib/sandbox/montecarlo/src/randomkit.c.orig	1970-01-01 01:00:00.000000000 +0100
++++ Lib/sandbox/montecarlo/src/randomkit.c	2007-06-06 17:15:22.505066000 +0100
+@@ -0,0 +1,357 @@
++/* Random kit 1.3 */
++
++/*
++ * Copyright (c) 2003-2005, Jean-Sebastien Roy (js@jeannot.org)
++ *
++ * The rk_random and rk_seed functions algorithms and the original design of 
++ * the Mersenne Twister RNG:
++ *
++ *   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
++ *   All rights reserved.
++ *
++ *   Redistribution and use in source and binary forms, with or without
++ *   modification, are permitted provided that the following conditions
++ *   are met:
++ * 
++ *   1. Redistributions of source code must retain the above copyright
++ *   notice, this list of conditions and the following disclaimer.
++ *
++ *   2. Redistributions in binary form must reproduce the above copyright
++ *   notice, this list of conditions and the following disclaimer in the
++ *   documentation and/or other materials provided with the distribution.
++ *
++ *   3. The names of its contributors may not be used to endorse or promote
++ *   products derived from this software without specific prior written
++ *   permission.
++ *
++ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
++ *   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
++ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
++ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
++ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
++ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
++ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
++ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
++ *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ * 
++ * Original algorithm for the implementation of rk_interval function from
++ * Richard J. Wagner's implementation of the Mersenne Twister RNG, optimised by
++ * Magnus Jonsson.
++ *
++ * Constants used in the rk_double implementation by Isaku Wada.
++ * 
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++/* static char const rcsid[] =
++  "@(#) $Jeannot: randomkit.c,v 1.28 2005/07/21 22:14:09 js Exp $"; */
++
++#include <stddef.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <errno.h>
++#include <time.h>
++#include <limits.h>
++#include <math.h>
++
++#ifdef _WIN32
++/* Windows */
++#include <sys/timeb.h>
++#ifndef RK_NO_WINCRYPT
++/* Windows crypto */
++#ifndef _WIN32_WINNT
++#define _WIN32_WINNT 0x0400
++#endif
++#include <windows.h>
++#include <wincrypt.h>
++#endif
++#else
++/* Unix */
++#include <sys/time.h>
++#include <unistd.h>
++#endif
++
++#include "randomkit.h"
++
++#ifndef RK_DEV_URANDOM
++#define RK_DEV_URANDOM "/dev/urandom"
++#endif
++
++#ifndef RK_DEV_RANDOM
++#define RK_DEV_RANDOM "/dev/random"
++#endif
++
++char *rk_strerror[RK_ERR_MAX] =
++{
++	"no error",
++	"random device unvavailable"
++};
++
++/* static functions */
++static unsigned long rk_hash(unsigned long key);
++
++void rk_seed(unsigned long seed, rk_state *state)
++{
++	int pos;
++	seed &= 0xffffffffUL;
++
++	/* Knuth's PRNG as used in the Mersenne Twister reference implementation */
++	for (pos=0; pos<RK_STATE_LEN; pos++)
++	{
++		state->key[pos] = seed;
++		seed = (1812433253UL * (seed ^ (seed >> 30)) + pos + 1) & 0xffffffffUL;
++	}
++
++	state->pos = RK_STATE_LEN;
++	state->has_gauss = 0;
++        state->has_binomial = 0;
++}
++
++/* Thomas Wang 32 bits integer hash function */
++unsigned long rk_hash(unsigned long key)
++{
++  key += ~(key << 15);
++  key ^=  (key >> 10);
++  key +=  (key << 3);
++  key ^=  (key >> 6);
++  key += ~(key << 11);
++  key ^=  (key >> 16);
++  return key;
++}
++
++rk_error rk_randomseed(rk_state *state)
++{
++#ifndef _WIN32
++	struct timeval tv;
++#else
++	struct _timeb	tv;
++#endif
++        int i;
++
++	if(rk_devfill(state->key, sizeof(state->key), 0) == RK_NOERR)
++	{
++		state->key[0] |= 0x80000000UL; /* ensures non-zero key */
++		state->pos = RK_STATE_LEN;
++		state->has_gauss = 0;
++                state->has_binomial = 0;
++
++                for (i=0; i<624; i++)
++                {
++                    state->key[i] &= 0xffffffffUL;
++                }
++
++		return RK_NOERR;
++	}
++
++#ifndef _WIN32
++	gettimeofday(&tv, NULL);
++	rk_seed(rk_hash(getpid()) ^ rk_hash(tv.tv_sec) ^ rk_hash(tv.tv_usec)
++		^ rk_hash(clock()), state);
++#else
++	_ftime(&tv);
++	rk_seed(rk_hash(tv.time) ^ rk_hash(tv.millitm) ^ rk_hash(clock()), state);
++#endif
++
++	return RK_ENODEV;
++}
++
++/* Magic Mersenne Twister constants */
++#define N 624
++#define M 397
++#define MATRIX_A 0x9908b0dfUL
++#define UPPER_MASK 0x80000000UL
++#define LOWER_MASK 0x7fffffffUL
++
++/* Slightly optimised reference implementation of the Mersenne Twister */
++unsigned long rk_random(rk_state *state)
++{
++  unsigned long y;
++
++  if (state->pos == RK_STATE_LEN)
++	{
++    int i;
++
++    for (i=0;i<N-M;i++)
++		{
++      y = (state->key[i] & UPPER_MASK) | (state->key[i+1] & LOWER_MASK);
++      state->key[i] = state->key[i+M] ^ (y>>1) ^ (-(y & 1) & MATRIX_A);
++    }
++    for (;i<N-1;i++)
++		{
++      y = (state->key[i] & UPPER_MASK) | (state->key[i+1] & LOWER_MASK);
++      state->key[i] = state->key[i+(M-N)] ^ (y>>1) ^ (-(y & 1) & MATRIX_A);
++    }
++    y = (state->key[N-1] & UPPER_MASK) | (state->key[0] & LOWER_MASK);
++    state->key[N-1] = state->key[M-1] ^ (y>>1) ^ (-(y & 1) & MATRIX_A);
++
++    state->pos = 0;
++  }
++  
++  y = state->key[state->pos++];
++
++  /* Tempering */
++  y ^= (y >> 11);
++  y ^= (y << 7) & 0x9d2c5680UL;
++  y ^= (y << 15) & 0xefc60000UL;
++  y ^= (y >> 18);
++
++  return y;
++}
++
++long rk_long(rk_state *state)
++{
++	return rk_ulong(state) >> 1;
++}
++
++unsigned long rk_ulong(rk_state *state)
++{
++#if ULONG_MAX <= 0xffffffffUL
++	return rk_random(state);
++#else
++	return (rk_random(state) << 32) | (rk_random(state));
++#endif
++}
++
++unsigned long rk_interval(unsigned long max, rk_state *state)
++{
++	unsigned long mask = max, value;
++
++	if (max == 0) return 0;
++
++	/* Smallest bit mask >= max */
++	mask |= mask >> 1;
++	mask |= mask >> 2;
++	mask |= mask >> 4;
++	mask |= mask >> 8;
++	mask |= mask >> 16;
++#if ULONG_MAX > 0xffffffffUL
++	mask |= mask >> 32;
++#endif
++
++	/* Search a random value in [0..mask] <= max */
++	while ((value = (rk_ulong(state) & mask)) > max);
++
++	return value;
++}
++
++double rk_double(rk_state *state)
++{
++	/* shifts : 67108864 = 0x4000000, 9007199254740992 = 0x20000000000000 */
++	long a = rk_random(state) >> 5, b = rk_random(state) >> 6;
++	return (a * 67108864.0 + b) / 9007199254740992.0;
++}
++
++void rk_fill(void *buffer, size_t size, rk_state *state)
++{
++	unsigned long r;
++	unsigned char *buf = buffer;
++	
++	for (; size >= 4; size -= 4)
++	{
++		r = rk_random(state);
++		*(buf++) = r & 0xFF;
++		*(buf++) = (r >> 8) & 0xFF;
++		*(buf++) = (r >> 16) & 0xFF;
++		*(buf++) = (r >> 24) & 0xFF;
++	}
++	
++	if (!size) return;
++
++	r = rk_random(state);
++
++	for (; size; r >>= 8, size --)
++		*(buf++) = (unsigned char)(r & 0xFF);
++}
++
++rk_error rk_devfill(void *buffer, size_t size, int strong)
++{
++#ifndef _WIN32
++	FILE *rfile;
++	int done;
++
++	if (strong)
++		rfile = fopen(RK_DEV_RANDOM, "rb");
++	else
++		rfile = fopen(RK_DEV_URANDOM, "rb");
++	if (rfile == NULL)
++		return RK_ENODEV;
++	done = fread(buffer, size, 1, rfile);
++	fclose(rfile);
++	if (done)
++		return RK_NOERR;
++#else
++
++#ifndef RK_NO_WINCRYPT
++	HCRYPTPROV hCryptProv;
++	BOOL done;
++
++	if (!CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
++		CRYPT_VERIFYCONTEXT) || !hCryptProv)
++		return RK_ENODEV;
++	done = CryptGenRandom(hCryptProv, size, (unsigned char *)buffer);
++	CryptReleaseContext(hCryptProv, 0);
++	if (done)
++		return RK_NOERR;
++#endif
++
++#endif
++
++	return RK_ENODEV;
++}
++
++rk_error rk_altfill(void *buffer, size_t size, int strong, rk_state *state)
++{
++	rk_error err;
++
++	err = rk_devfill(buffer, size, strong);
++	if (err)
++		rk_fill(buffer, size, state);
++
++	return err;
++}
++
++double rk_gauss(rk_state *state)
++{
++	if (state->has_gauss)
++	{
++		state->has_gauss = 0;
++		return state->gauss;
++	}
++	else
++	{
++		double f, x1, x2, r2;
++		do
++		{
++			x1 = 2.0*rk_double(state) - 1.0;
++			x2 = 2.0*rk_double(state) - 1.0;
++			r2 = x1*x1 + x2*x2;
++		}
++		while (r2 >= 1.0 || r2 == 0.0);
++		
++		f = sqrt(-2.0*log(r2)/r2); /* Box-Muller transform */
++		state->has_gauss = 1;
++		state->gauss = f*x1; /* Keep for next call */
++		return f*x2;
++	}
++}
++
++
+--- Lib/sandbox/montecarlo/src/randomkit.h.orig	1970-01-01 01:00:00.000000000 +0100
++++ Lib/sandbox/montecarlo/src/randomkit.h	2007-06-06 17:15:22.505066000 +0100
+@@ -0,0 +1,189 @@
++/* Random kit 1.3 */
++
++/*
++ * Copyright (c) 2003-2005, Jean-Sebastien Roy (js@jeannot.org)
++ * 
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++/* @(#) $Jeannot: randomkit.h,v 1.24 2005/07/21 22:14:09 js Exp $ */
++
++/*
++ * Typical use:
++ *
++ * {
++ * 	rk_state state;
++ * 	unsigned long seed = 1, random_value;
++ * 	
++ * 	rk_seed(seed, &state); // Initialize the RNG
++ * 	...
++ * 	random_value = rk_random(&state); // Generate random values in [0..RK_MAX]
++ * }
++ * 
++ * Instead of rk_seed, you can use rk_randomseed which will get a random seed
++ * from /dev/urandom (or the clock, if /dev/urandom is unavailable):
++ *
++ * {
++ * 	rk_state state;
++ * 	unsigned long random_value;
++ * 	
++ * 	rk_randomseed(&state); // Initialize the RNG with a random seed
++ * 	...
++ * 	random_value = rk_random(&state); // Generate random values in [0..RK_MAX]
++ * }
++ */
++ 
++/*
++ * Useful macro:
++ * 	RK_DEV_RANDOM: the device used for random seeding.
++ *                 defaults to "/dev/urandom"
++ */
++
++#include <stddef.h>
++
++#ifndef _RANDOMKIT_
++#define _RANDOMKIT_
++
++#define	RK_STATE_LEN 624
++
++typedef struct rk_state_
++{
++	unsigned long key[RK_STATE_LEN];
++	int pos;
++	int has_gauss; /* !=0: gauss contains a gaussian deviate */
++	double gauss;
++
++    /* The rk_state structure has been extended to store the following
++     * information for the binomial generator. If the input values of n or p
++     * are different than nsave and psave, then the other parameters will be
++     * recomputed. RTK 2005-09-02 */
++
++    int has_binomial; /* !=0: following parameters initialized for 
++                              binomial */
++    double psave;
++    long nsave;
++    double r;
++    double q;
++    double fm;
++    long m;
++    double p1;
++    double xm;
++    double xl;
++    double xr;
++    double c;
++    double laml;
++    double lamr;
++    double p2;
++    double p3;
++    double p4;
++
++}
++rk_state;
++
++typedef enum {
++	RK_NOERR = 0, /* no error */
++	RK_ENODEV = 1, /* no RK_DEV_RANDOM device */
++	RK_ERR_MAX = 2
++} rk_error;
++
++/* error strings */
++extern char *rk_strerror[RK_ERR_MAX];
++
++/* Maximum generated random value */
++#define RK_MAX 0xFFFFFFFFUL
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/*
++ * Initialize the RNG state using the given seed.
++ */
++extern void rk_seed(unsigned long seed, rk_state *state);
++
++/*
++ * Initialize the RNG state using a random seed.
++ * Uses /dev/random or, when unavailable, the clock (see randomkit.c).
++ * Returns RK_NOERR when no errors occurs.
++ * Returns RK_ENODEV when the use of RK_DEV_RANDOM failed (for example because
++ * there is no such device). In this case, the RNG was initialized using the
++ * clock.
++ */
++extern rk_error rk_randomseed(rk_state *state);
++
++/*
++ * Returns a random unsigned long between 0 and RK_MAX inclusive
++ */
++extern unsigned long rk_random(rk_state *state);
++
++/*
++ * Returns a random long between 0 and LONG_MAX inclusive
++ */
++extern long rk_long(rk_state *state);
++
++/*
++ * Returns a random unsigned long between 0 and ULONG_MAX inclusive
++ */
++extern unsigned long rk_ulong(rk_state *state);
++
++/*
++ * Returns a random unsigned long between 0 and max inclusive.
++ */
++extern unsigned long rk_interval(unsigned long max, rk_state *state);
++
++/*
++ * Returns a random double between 0.0 and 1.0, 1.0 excluded.
++ */
++extern double rk_double(rk_state *state);
++
++/*
++ * fill the buffer with size random bytes
++ */
++extern void rk_fill(void *buffer, size_t size, rk_state *state);
++
++/*
++ * fill the buffer with randombytes from the random device
++ * Returns RK_ENODEV if the device is unavailable, or RK_NOERR if it is
++ * On Unix, if strong is defined, RK_DEV_RANDOM is used. If not, RK_DEV_URANDOM
++ * is used instead. This parameter has no effect on Windows.
++ * Warning: on most unixes RK_DEV_RANDOM will wait for enough entropy to answer
++ * which can take a very long time on quiet systems.
++ */
++extern rk_error rk_devfill(void *buffer, size_t size, int strong);
++
++/*
++ * fill the buffer using rk_devfill if the random device is available and using
++ * rk_fill if is is not
++ * parameters have the same meaning as rk_fill and rk_devfill
++ * Returns RK_ENODEV if the device is unavailable, or RK_NOERR if it is
++ */
++extern rk_error rk_altfill(void *buffer, size_t size, int strong,
++	rk_state *state);
++
++/*
++ * return a random gaussian deviate with variance unity and zero mean.
++ */
++extern double rk_gauss(rk_state *state);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* _RANDOMKIT_ */ 
diff --git a/sci-libs/scipy/files/scipy-0.5.2-signals.patch b/sci-libs/scipy/files/scipy-0.5.2-signals.patch
new file mode 100644
index 000000000000..bbd6b3dcb812
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-signals.patch
@@ -0,0 +1,19 @@
+--- Lib/signal/filter_design.py.orig	2007-06-06 14:27:50.000000000 +0100
++++ Lib/signal/filter_design.py	2007-06-06 14:43:14.000000000 +0100
+@@ -4,11 +4,11 @@
+ """
+ 
+ import numpy
+-from numpy.core.umath import *
+-from numpy import atleast_1d, poly, polyval, roots, imag, real, asarray,\
+-     allclose, resize, pi, concatenate, absolute, logspace
+-from numpy import mintypecode, select
+-from scipy import special, optimize, linalg
++from numpy import atleast_1d, poly, polyval, roots, real, asarray, allclose, \
++     resize, pi, absolute, logspace, r_, sqrt, tan, log10, arctan, arcsinh, \
++     cos, exp, cosh, arccosh, ceil, conjugate, zeros, sinh
++from numpy import mintypecode
++from scipy import special, optimize
+ from scipy.misc import comb
+ import string, types
+ 
diff --git a/sci-libs/scipy/files/scipy-0.5.2-umfpack.patch b/sci-libs/scipy/files/scipy-0.5.2-umfpack.patch
new file mode 100644
index 000000000000..21916b097ed9
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-umfpack.patch
@@ -0,0 +1,28 @@
+--- Lib/linsolve/umfpack/umfpack.i.orig	2007-06-06 14:53:42.261505250 +0100
++++ Lib/linsolve/umfpack/umfpack.i	2007-06-06 14:54:12.167374250 +0100
+@@ -114,6 +114,7 @@
+     return NULL; \
+   } \
+   $1 = (double *) obj->data; \
++  Py_DECREF( obj ); \
+ };
+ 
+ /*!
+@@ -127,7 +128,7 @@
+ }; \
+ %typemap( python, argout ) ttype* opaque_argout { \
+   PyObject *obj; \
+-  obj = SWIG_NewPointerObj( (ttype) (*$1), $*1_descriptor, 1 ); \
++  obj = SWIG_NewPointerObj( (ttype) (*$1), $*1_descriptor, 0 ); \
+   $result = helper_appendToTuple( $result, obj ); \
+ };
+ 
+@@ -143,7 +144,7 @@
+ }; \
+ %typemap( python, argout ) ttype* opaque_arginout { \
+   PyObject *obj; \
+-  obj = SWIG_NewPointerObj( (ttype) (*$1), $*1_descriptor, 1 ); \
++  obj = SWIG_NewPointerObj( (ttype) (*$1), $*1_descriptor, 0 ); \
+   $result = helper_appendToTuple( $result, obj ); \
+ };
+ 
diff --git a/sci-libs/scipy/files/scipy-0.5.2-viewer.patch b/sci-libs/scipy/files/scipy-0.5.2-viewer.patch
new file mode 100644
index 000000000000..8c4bd2a6b9f9
--- /dev/null
+++ b/sci-libs/scipy/files/scipy-0.5.2-viewer.patch
@@ -0,0 +1,41 @@
+--- Lib/misc/pilutil.py.orig	2007-06-06 14:28:07.000000000 +0100
++++ Lib/misc/pilutil.py	2007-06-06 14:44:10.000000000 +0100
+@@ -2,6 +2,7 @@
+ 
+ import types
+ import numpy
++import tempfile
+ 
+ from numpy import amin, amax, ravel, asarray, cast, arange, \
+      ones, newaxis, transpose, mgrid, iscomplexobj, sum, zeros, uint8
+@@ -226,17 +227,20 @@
+     """Simple showing of an image through an external viewer.
+     """
+     im = toimage(arr)
+-    if (len(arr.shape) == 3) and (arr.shape[2] == 4):
+-        try:
+-            import os
+-            im.save('/tmp/scipy_imshow.png')
+-            if os.system("(xv /tmp/scipy_imshow.png; rm -f /tmp/scipy_imshow.png)&"):
+-                raise RuntimeError
+-            return
+-        except:
+-            print "Warning: Alpha channel may not be handled correctly."
++    fnum,fname = tempfile.mkstemp('.png')
++    try:
++        im.save(fname)
++    except:
++        raise RuntimeError("Error saving temporary image data.")
++
++    import os
++    os.close(fnum)
++    cmd = os.environ.get('SCIPY_PIL_IMAGE_VIEWER','see')
++    status = os.system("%s %s" % (cmd,fname))
++    os.unlink(fname)
++    if status != 0:
++        raise RuntimeError('Could not execute image viewer.')
+ 
+-    im.show()
+     return
+ 
+ def imresize(arr,size):