Parametre 6 parametre bir şey verimli bir şekilde bunu yapmak için arıyorum ... karmaşık yapmaya çalışıyor önce sayısal davranışları üzerine bir fonksiyon alanı yapmaya çalışıyorum.

Benim görevim, kayan noktalı değişkenler girdi olarak 6-dim numpy dizi belirli bir zaman alır. Başlangıçta yapmaya çalıştığım şey şuydu:

1) İlk 2 dizi alır ve iki dizi değerlerinin tüm kombinasyonları bir dizi üreten bir fonksiyon oluşturdum

from numpy import *
def comb(a,b):
    c = []
    for i in a:
        for j in b:
            c.append(r_[i,j])
    return c

Ben azaltmak aynı dizinin m kopya için bunu uygulamak için kullanılır:

def combs(a,m):
    return reduce(comb,[a]*m)

Ve sonra ben bu şekilde fonksiyon testleri:

values = combs(np.arange(0,1,0.1),6)
for val in values:
    print F(val)

Bu waaaay çok yavaş ama çalışıyor. Parametrelerin büyük bir boşluk olduğunu biliyorum, ama bu kadar yavaş olmamalı. Sadece (10)^6 = Bu örnekte bir milyon puan ve daha sonra 15 sadece dizi oluşturmak için saniye sürdü tabii 'değerler'.

Numpy ile bunu yapmanın daha etkili bir yolu olduğunu biliyor musunuz?

F eğer gerekli ise, bu bağımsız değişken almaz şekilde getirebilirim.

Burada saf-numpy bir uygulama. Ca. 5 kat daha hızlıdır itertools kullanarak daha.

import numpy as np

def cartesian(arrays, out=None):
    """
    Generate a cartesian product of input arrays.

    Parameters
    ----------
    arrays : list of array-like
        1-D arrays to form the cartesian product of.
    out : ndarray
        Array to place the cartesian product in.

    Returns
    -------
    out : ndarray
        2-D array of shape (M, len(arrays)) containing cartesian products
        formed of input arrays.

    Examples
    --------
    >>> cartesian(([1, 2, 3], [4, 5], [6, 7]))
    array([[1, 4, 6],
           [1, 4, 7],
           [1, 5, 6],
           [1, 5, 7],
           [2, 4, 6],
           [2, 4, 7],
           [2, 5, 6],
           [2, 5, 7],
           [3, 4, 6],
           [3, 4, 7],
           [3, 5, 6],
           [3, 5, 7]])

    """

    arrays = [np.asarray(x) for x in arrays]
    dtype = arrays[0].dtype

    n = np.prod([x.size for x in arrays])
    if out is None:
        out = np.zeros([n, len(arrays)], dtype=dtype)

    m = n / arrays[0].size
    out[:,0] = np.repeat(arrays[0], m)
    if arrays[1:]:
        cartesian(arrays[1:], out=out[0:m,1:])
        for j in xrange(1, arrays[0].size):
            out[j*m:(j 1)*m,1:] = out[0:m,1:]
    return out