小编jrs*_*rsm的帖子

哪个是在CUDA中使用常量的最佳方法？

一种方法是在常量内存中定义常量,例如:

// CUDA global constants
__constant__ int M;

int main(void)
{
    ...
    cudaMemcpyToSymbol("M", &M, sizeof(M));
    ...
}

一种替代方法是使用C预处理器:

#define M = ... 

我认为使用C预处理器定义常量要快得多.那么在CUDA设备上使用常量内存的好处是什么？

使用ctypes将numpy 2d - 数组传递给ac函数的正确方法是什么？到目前为止我的当前方法(导致段错误):

C代码:

void test(double **in_array, int N) {
    int i, j;
    for(i = 0; i<N; i++) {
        for(j = 0; j<N; j++) {
            printf("%e \t", in_array[i][j]);
        }
        printf("\n");
    }
}

Python代码:

from ctypes import *
import numpy.ctypeslib as npct

array_2d_double = npct.ndpointer(dtype=np.double,ndim=2, flags='CONTIGUOUS')
liblr = npct.load_library('libtest.so', './src')

liblr.test.restype = None
liblr.test.argtypes = [array_2d_double, c_int]

x = np.arange(100).reshape((10,10)).astype(np.double)
liblr.test(x, 10)

我想渲染大约500个图像并将它们保存到不同的png文件中,因此我写了一个包含我的数据集和渲染函数的小类

from mayavi import mlab
mlab.options.offscreen=True

class Dataset(object):
    def __init__(self):
        some init stuff etc

                 .
                 .
                 .
                 .

    def save_current_frame_to_png(self, filename):
        mlab.contour3d(self.frame_data, contours =30, opacity=0.2) 
        mlab.savefig(filename)
        mlab.clf()
        mlab.close()
        gc.collect()

    def create_movie_files(self):
        folder_name = "animation"
        try:
            os.makedirs(folder_name)
        except OSError:
            raise OSError("Directory already exists.")

        self.__go_to_first_frame()

        for i in range(self.frames):
            filename = "".join([folder_name, "/%.5i" % i, ".png"])
            print filename
            self.save_current_frame_to_png(filename)
            self.read_single_frame()

        self.__go_to_first_frame()

所以一切似乎都运行良好,但我看看内存使用情况,直到系统崩溃.所以我试图使用mlab.clf()并gc.collect()保持我的记忆低,这是行不通的.我发现一个解决方案mlab.close()似乎适用于内存使用,但这带来了一个新问题.每次渲染新图像时,mayavi都会创建一个新窗口,因此在大约200个窗口之后程序崩溃.也许是否有可能完全禁用Windows？在我看来,mlab.options.offscreen=True只禁用当前窗口内的绘图.

编辑: self.frame_data是一个numpy形状的数组(100,100,100),self.read_single_frame()只是从文本文件中读取下一帧并存储它self.frame_data.这个函数不会增加内存,如果我关闭渲染内存使用率保持在1.2%.

我正在使用sympy为cfd模拟生成不同的表达式.这些表达式大多数是exp = f(x,y,z),例如f(x,y,z)= sin(x)*cos(y)*sin(z).要在网格上获取值,我使用simpy.lambdify.例如:

import numpy as np
import sympy as sp
from sympy.abc import x,y,z

xg, yg, zg = np.mgrid[0:1:50*1j, 0:1:50*1j, 0:1:50*1j]
f  = sp.sin(x)*sp.cos(y)*sp.sin(z)

lambda_f = sp.lambdify([x,y,z], f, "numpy")
fn = lambda_f(xg, yg, zg)

print fn

这似乎工作得很好但不幸的是我的表达式越来越复杂,网格计算需要花费很多时间.我的想法是,可能可以使用uFuncify方法(请参阅http://docs.sympy.org/latest/modules/numeric-computation.html)来加快计算速度,我不确定这是否是正确的方法？我也不知道如何让3d功能为3d网格工作？感谢您的任何建议

在我目前的数据分析中,我有一些分段图像,例如下面.

我的问题是我想在分割图像中将多项式或样条(s.th. one-dimensional)拟合到某个区域(红色).(结果将是黑线).

通常我会使用像正交距离回归这样的东西,问题是这需要某种拟合函数,在这种情况下我没有.那么用python/numpy执行此操作的最佳方法是什么？对于这种问题,是否有一些标准算法？

更新:看起来我的绘图技巧可能不是最好的,图片中的红色区域也可能有一些随机噪音而且不必完全连接(由于噪音可能会有小间隙).

更新2:总体目标是具有参数化曲线p(t),其返回[0,1]中t的位置,即p(t)=>(x,y).其中t = 0开始黑线,t = 1黑线结束.

可以说我有一个像numpy数组

x = np.arange(10)

以某种方式可以创建对单个元素的引用,即

y = create_a_reference_to(x[3])
y = 100 
print x
[  0   1   2 100   4   5   6   7   8   9]

我正在使用sympy为数值计算生成一些函数.因此,我将一个表达式lambdify,并将其与numpy数组一起使用.这是一个例子:

import numpy as np
import sympy as sp

def numpy_function():
    x, y, z = np.mgrid[0:1:40*1j, 0:1:40*1j, 0:1:40*1j]
    T   = (1 - np.cos(2*np.pi*x))*(1 - np.cos(2*np.pi*y))*np.sin(np.pi*z)*0.1
    return T

def sympy_function():
    x, y, z = sp.Symbol("x"), sp.Symbol("y"), sp.Symbol("z")
    T   = (1 - sp.cos(2*sp.pi*x))*(1 - sp.cos(2*sp.pi*y))*sp.sin(sp.pi*z)*0.1
    lambda_function = np.vectorize(sp.lambdify((x, y, z), T, "numpy"))
    x, y, z = np.mgrid[0:1:40*1j, 0:1:40*1j, 0:1:40*1j]
    T = lambda_function(x,y,z)
    return T

sympy版本和纯粹numpy版本之间的问题是速度即

In [3]: timeit test.numpy_function()  
100 loops, best of 3: 11.9 ms per loop

与

In [4]: timeit …

我有一个动态分配数组的ctypes结构,即:

array_1d_double=npct.ndpointer(dtype=np.double,ndim=1,
                               flags='CONTIGUOUS')
class Test(Structure):
    _fields_ = ("x", array_1d_double, ..)

test = Test()
do_some_init_in_c(  for example malloc)

如果我打印test.x,我得到以下输出:

<ndpointer_<f8_1d_CONTIGUOUS object at 0x7f104dc0c3b0>

c结构看起来大致如此,

structure Test_s{
    double *x;....
};

如何像numpy数组一样访问这个元素？是否可能需要将数组分配为np.arrays而不是使用malloc？这样做的正确方法是什么？

假设我在 2d 平面上有一条由参数化给出的路径，例如阿基米德螺线：

x(t) = a*\xcf\x86*cos(\xcf\x86) , y(t) = a*\xcf\x86*sin(\xcf\x86)

我正在寻找一种用 numpy 数组离散化它的方法，\n问题是如果我使用

a = 1\nphi = np.arange(0, 10*np.pi, 0.1)\nx = a*phi*np.cos(phi)\ny = a*phi*np.sin(phi)\nplt.plot(x,y, "ro")\n

我得到了一条漂亮的曲线，但这些点的距离不一样，随着\n增长\xcf\x86，两点之间的距离变得更大。\n我正在寻找一种好的且如果可能的话快速的方法来做到这一点。

我想使用符号数学库从矢量/标量字段派生类似curl/ divergence等的属性.根据sympy文档,这可以通过sympy.physics.vector模块实现,

http://docs.sympy.org/dev/modules/physics/vector/api/fieldfunctions.html

http://docs.sympy.org/dev/modules/physics/vector/fields.html

但是我无法找到卷曲/发散功能随时随地为这个模块中,根据文档应该 sympy.physics.vector.curl和sympy.physics.vector.divergence

我用pip安装了版本并检查了它的0.7.5版本.那么我能找到这些功能的任何想法？也许文档不是最新的？

我有一些使用多处理 Pool 类并行运行的代码。不幸的是，我从另一个库中使用的一些函数有一些冗长的输出。要抽象问题，请查看以下示例：

from multiprocessing import Pool

def f(x):
    print 'hello'
    return x*x

p = Pool(10)
p.map(f, [1,2,3])

所以这将打印 'hello' 10 次。是否有可能使进程的输出静音或将 std.out 放在某个变量中？感谢您的任何建议。

编辑：我不想重定向整个标准输出，只是为了我的池进程。

假设我用 matplotlib 创建了一个简单的绘图

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)

plot stuff etc .. . 

完成绘图例程后，我想调整图形的大小（但保持所有纵横比相同），以便将总高度ax设置为恒定值，即 3 英寸。有没有一种好的、简短的方法来实现这个目标？

编辑：我知道如何更改图形大小，但在这里我想根据轴的大小调整它。

fI尝试使用ctypes包装ac函数,例如:

#include<stdio.h>

typedef struct {
    double x;
    double y;
}Number;

double add_numbers(Number *n){
    double x;
    x = n->x+n->y;
    printf("%e \n", x);
    return x;
}

我用选项编译c文件

gcc -shared -fPIC -o test.so test.c 

到共享库.

Python代码如下所示:

from ctypes import * 

class Number(Structure):
    _fields_=[("x", c_double),
              ("y", c_double)]

def main():
    lib = cdll.LoadLibrary('./test.so')
    n = Number(10,20)
    print n.x, n.y
    lib.add_numbers.argtypes = [POINTER(Number)]
    lib.add_numbers.restypes = [c_double]

    print lib.add_numbers(n)

if __name__=="__main__":
    main()

add_numbers函数中的printf语句返回期望值3.0e + 1,但lib.add_numbers函数的返回值始终为零.我没有看到错误,任何想法？