小编wee*_*not的帖子

我有一个 N 维数组，每个维度具有相同数量的项目（即相同的“长度”）。

给定数组中的一维索引，我想要一个函数来返回与该索引关联的坐标。数组的索引方式实际上并不重要（从某种意义上说，数组的所有维度都是相等的，就将在数组上运行的算法而言，没有任何维度具有优先权）。

因此，例如，如果我有一个 4x4x4 数组，索引 63 应返回 [3,3,3]，索引 0 应返回 [0,0,0]，索引 5 应返回 [1,1,0]。

我编写了以下函数，其中 nDim 是维度数，nBin 是每个维度的长度：

def indicesOf(x,nDim,nBin) :
    indices = []
    for i in arange(0,nDim) :   
        index = (x/nBin**(i))%nBin
        indices.append(index)
        x -= index*nBin**i
    return indices

它似乎有效——但是有没有更有效的方法来进行这个计算？老实说，我有一半“问”了这个问题只是为了分享这个解决方案，因为我在网上找不到解决方案。但如果有更有效的方法来做到这一点，那就太好了——请分享！

上面的函数是用 python 编写的，但我刚刚用它来对 C（实际上是 CUDA）函数进行原型设计，所以没有一个 python 很棒的库可供我使用。

这是结合 JackOLantern 和 Eric 关于以下两种尺寸的力量的评论的解决方案。它似乎适用于我尝试过的少数测试用例。

def indicesPowOf2(x,nDim,nBin) :
    logWidth = math.log(nBin,2)         
    indices = [0]*nDim
    for i in arange(nDim) :
        indices[i] = x & (nBin-1)
        x = x >> int(logWidth)
    return indices

我正在优化pycuda /推力计划.在其中,我使用thrust :: min_element来识别设备上的数组中的最小元素的索引.

使用Nvidia的可视化分析器,似乎每当我打电话时thrust::min_element,都有一个DtoH(设备到主机)memcpy.我想要的只是在设备上进行的一切.换句话说,min_element()的输出应存储在设备上,我可以在以后使用它,而不会花费小DtoH memcpy的成本.有没有办法做到这一点？还是我错误地思考问题？

我的尝试是在下面,其中的想法是将指向的数组中最小元素的索引input_ptr放入指向的数组的第一个元素中output_ptr.一切都应该在设备上完成,主机上没有任何东西.

此代码生成正确的答案,但涉及不需要的memcpys.非常感谢您提供的任何帮助.

#include <thrust/extrema.h>
#include <thrust/device_vector.h>
#include <cuda.h>

void my_min_element(CUdeviceptr input_ptr, int length, CUdeviceptr output_ptr)
{
  thrust::device_ptr<float> i_ptr((float*)input_ptr);
  thrust::device_ptr<int> o_ptr((int*)output_ptr);
  o_ptr[0] = thrust::distance(i_ptr,thrust::min_element(i_ptr, i_ptr+length));
}

我正在使用boost的使用push的odeint扩展参数研究示例,我不知道如何将值向量传递给观察者的构造函数,以便可以从观察者的函子中访问这些值(只读) .

以下是仅供观察者使用的代码.

//// Observes the system, comparing the current state to 
//// values in unchangingVector

struct minimum_perturbation_observer { 
  struct minPerturbFunctor
  {
    template< class T >
    __host__ __device__
    void operator()( T t ) const
    {
    //// I would like to be able to read any member 
    //// of m_unchangingVector here.
    }
  };


  // CONSTRUCTOR
  minimum_perturbation_observer( size_t N, state_type unchangingVector, int len) : 
        m_N( N ),
        m_output( N ),
        m_unchangingVector( len ) // len is the correct length of unchangingVector
  { …

当你像这样在matplotlib中绘制一堆透明线条时,你会得到一个很好的效果; 当它们重叠时,它们会更暗.

from pylab import *
for _ in xrange(1000) :
    plot(np.random.randn(2),np.random.randn(2),alpha=0.1,color='k')
show()

它看起来像这样:

但是如果你像这样绘制一条与它自身重叠的长线,那么该线就不会"与自身相互作用".它看起来像这样:

我想绘制一条与自身重叠的曲线,这样它与自身重叠的越多,它就越暗.如果我使用一个循环来分解曲线并分别绘制每个线段,我得到了我想要的东西,但是我也得到了线段相遇的丑陋和不可接受的伪像,使得曲线看起来像点线或虚线.这个:

是否有任何好的方法来绘制曲线,使其在与自身重叠时变得更暗,但是你没有得到像刚刚描述的那样的工件？

我在很多地方读到过，__device__函数几乎总是由 CUDA 编译器内联。__device__那么，当我将代码从内核移动到内核调用的函数时，（通常）使用的寄存器数量不会增加，这样说是否正确？

例如，以下代码片段使用相同数量的寄存器吗？他们的效率相同吗？

片段 1

__global__ void manuallyInlined(float *A,float *B,float *C,float *D,float *E) {
    // code that manipulates A,B,C,D and E 
}

片段2

__device__ void fn(float *A,float *B,float *C,float *D,float *E) {
    // code that manipulates A,B,C,D and E 
}


__global__ void manuallyInlined(float *A,float *B,float *C,float *D,float *E) {
    fn(A,B,C,D,E);
}

我有以下CUDA核心,其中执行计算上昂贵的计算然后在两个操作中使用.

偶尔,我想myKernel没有operationOne.我知道代码分支通常是个坏主意,但是如果所有线程都运行相同的分支,那么仍然存在很大的低效率吗？即以下是一个坏主意？

__global__ void myKernel(bool doOpOne, ...) {
    // usefulValue is computed

    if(doOpOne) {
         // perform operation one
    }
    // perform operation two
}

我想有一个ptr可以指向以下任一的函数指针:

• 一个功能,

• 对象实例的方法,或

• 对象的构造函数.

在后一种情况下,执行ptr()应该实例化该类.

def function(argument) :
    print("Function called with argument: "+str(argument))

class C(object) :
    def __init__(self,argument) :
        print("C's __init__ method called with argument: "+str(argument))

    def m(self,argument) :
        print("C's method 'm' called with argument: "+str(argument))

## works
ptr = function
ptr('A')

## works
instance = C('asdf')
ptr = instance.m
ptr('A')

## fails
constructorPtr = C.__init__
constructorPtr('A')

这产生了输出:

Function called with argument: A

C's __init__ method called with argument: asdf

C's method 'm' called …

我有一个kivy应用程序,我希望在特定RenderContext上绘制的所有内容都应用着色器后处理效果(类似于文档中kivy-examples中的EffectWidget示例中演示的效果).

在worldWidget 的构造函数中,我创建了RenderContext

self.prc = RenderContext()

设置其投影矩阵(这是有效的)

self.prc['projection_mat'] = proj_mat

然后尝试将其片段着色器设置为默认片段着色器的最小副本,该着色器应该只将十分之一变为不透明(基本上使屏幕变暗).

self.prc.shader.fs = """
#ifdef GL_ES
    precision highp float;
#endif

/* Outputs from the vertex shader */
varying vec4 frag_color;
varying vec2 tex_coord0;

/* uniform texture samplers */
uniform sampler2D texture0;

void main (void){
    gl_FragColor = 0.1*frag_color * texture2D(texture0, tex_coord0);
}
"""

如果此着色器的代码不正确,则程序不会运行,抱怨着色器编译错误,这表示正在编译着色器.但是,我没有看到着色器的任何影响.绘制的所有内容prc都是绘制的,但是在正常的不透明度下.我究竟做错了什么？谢谢你的时间!

编辑!

我被要求提供一个完整的可运行示例.以下程序绘制两个矩形.左侧的Rectangle有自己的RenderContext,不受灰度后处理影响(它绘制为红色)的影响.右边的矩形没有自己的RenderContext中,它被正确地受到影响后处理.

这是代码:

from kivy.app import App
from kivy.uix.widget import Widget
from kivy.uix.floatlayout import FloatLayout
from kivy.graphics import *
from …