标签: vectorization

我正在为一个项目使用GCC SIMD向量扩展,一切都很好但是转换,它们只是重置向量的所有组件.

在手动状态:

可以从一种向量类型转换为另一种向量类型,前提是它们具有相同的大小(实际上,您也可以将向量转换为相同大小的其他数据类型).

这是一个简单的例子:

#include <stdio.h>

typedef int int4 __attribute__ (( vector_size( sizeof( int ) * 4 ) ));
typedef float float4 __attribute__ (( vector_size( sizeof( float ) * 4 ) ));

int main()
{
    int4 i = { 1 , 2 , 3 , 4 };
    float4 f = { 0.1 , 0.2 , 0.3 , 0.4 };

    printf( "%i %i %i %i\n" , i[0] , i[1] , i[2] , i[3] );
    printf( "%f %f %f …

在Matlab 2012b中,有一个changem函数允许您用一组键指定的其他值替换矩阵的元素: 数据数组中的替换值

如果我没有Mapping工具箱,是否有一种优雅/矢量化的方法来做同样的事情？

我需要一些以下代码的帮助:

if x(:,3)>x(:,4)
output=[x(:,1)-x(:,2)];
elseif x(:,3)<x(:,4)
output=[x(:,2)-x(:,1)];
else
output=NaN
end

这是一个示例数据:

matrix x              output
10   5   1   2        -5
10   5   2   1         5     
NaN  1   1   3         NaN

我不确定如何使代码工作.它只需要第一个参数并忽略else if和else参数.请帮忙.谢谢.

我正在数值求解一阶微分方程组的x(t).该系统是:

dx/dt = y
dy/dt = -x - a*y(x ^ 2 + y ^ 2 -1)

我已经实现了Forward Euler方法来解决这个问题,如下所示:

def forward_euler():
    h = 0.01
    num_steps = 10000

    x = np.zeros([num_steps + 1, 2]) # steps, number of solutions
    y = np.zeros([num_steps + 1, 2])
    a = 1.

    x[0, 0] = 10. # initial condition 1st solution
    y[0, 0] = 5.

    x[0, 1] = 0.  # initial condition 2nd solution
    y[0, 1] = 0.0000000001

    for step in xrange(num_steps):
        x[step + 1] = …

考虑2个矢量A = [20000000 x 1]和B = [20000000 x 1 ]

我需要找到对应于B的每个独特元素的所有A的总和.

虽然这看起来很简单,但这在MATLAB中将永远存在.

目前,我正在使用

u = unique(B);
length_u = length(u);
C = zeros(length_u,1);

for i = 1:length_u
   C(i,1) = sum(A(B==u(i)));
end

反正有没有让它跑得更快？我尝试parfor使用并行计算工具箱拆分循环并运行2个循环(因为我只有2个核心).还需要几个小时.

PS:是的,我应该买一台更好的电脑.

我经常想要遍历数据帧的长数组或列,并为每个项目查看它是否是另一个数组的成员.而不是做

giant_list = ["a", "c", "j"]
good_letters = ["a", "b"]
isin = falses(size(giant_list,1))
for i=1:size(giant_list,1)
    isin[i] = giant_list[i] in good_letters
end

是否有任何矢量化(双向矢量？)方式在朱莉娅这样做？与基本操作符类似,我想做类似的事情

isin = giant_list .in good_letters

我意识到这可能是不可能的,但我只是想确保我没有遗漏一些东西.我知道我可能会使用DataStructures中的DefaultDict做类似但不知道基础中的任何内容.

在路由规划算法中,我试图根据到另一个节点的距离对节点列表执行过滤.我实际上是从粗略的场景图中提取列表.我使用术语"单元格"来指代简单场景图中的一个卷,我们从中获取了彼此接近的节点列表.

现在,我正在实现这个:

# SSCCE version of the core function
def nodes_in_range(src, cell, maxDist):
    srcX, srcY, srcZ = src.x, src.y, src.z
    maxDistSq = maxDist ** 2
    for node in cell:
        distSq = (node.x - srcX) ** 2
        if distSq > maxDistSq: continue
        distSq += (node.y - srcY) ** 2
        if distSq > maxDistSq: continue
        distSq += (node.z - srcZ) ** 2
        if distSq <= maxDistSq:
            yield node, distSq ** 0.5  # fast sqrt

from collections import namedtuple
class Node(namedtuple('Node', ('ID', 'x', …

为了在Python中编写"分段函数",我通常使用if(在控制流或三元运算符形式).

def spam(x):
    return x+1 if x>=0 else 1/(1-x)

现在,有了NumPy,我们的口头禅是为了避免在单个值上进行矢量化,以获得性能.所以我认为这样的事情会更受欢迎:_{正如Leon所言,以下是错误的}

def eggs(x):
    y = np.zeros_like(x)
    positive = x>=0
    y[positive] = x+1
    y[np.logical_not(positive)] = 1/(1-x)
    return y

(纠正我,如果我在这里错过了一些东西,因为坦率地说,我觉得这很难看.)

现在,当然只有在实际上是一个NumPy数组eggs时才会起作用x,因为否则x>=0只会产生一个布尔值,它不能用于索引(至少不做正确的事情).

有没有一种很好的方法来编写看起来更像是spam在Numpy数组上惯用的代码,或者我应该使用vectorize(spam)？

我想要一个坐标列表.对于坐标中的每个位置,我想为矩阵分配1.最终矩阵应如下所示.我想使用快速矢量化方法而不是for循环.

    > sample.matrix
      A B C D E F G H I J K L M N O P Q R S T
    A 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    B 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
    C 0 0 0 0 0 0 0 0 0 0 0 0 0 0 …

我有一个带整数值的NumPy数组.矩阵的值在矩阵中从0到最大元素(换句话说,在其中呈现的从0到最大数据元素的所有数字).我需要构建有效(有效的快速全矢量化解决方案)来搜索每行中的元素数量,并根据矩阵值对其进行编码.

我找不到类似的问题,或者以某种方式帮助解决这个问题的问题.

所以,如果我有这个data输入:

# shape is (N0=4, m0=4) 
1   1   0   4
2   4   2   1
1   2   3   5
4   4   4   1

期望的输出是:

# shape(N=N0, m=data.max()+1):
1   2   0   0   1   0
0   1   2   0   1   0
0   1   1   1   0   1
0   1   0   0   3   0

我知道如何通过简单地计算逐行data 迭代的每一行中的唯一值来解决这个问题,然后结合考虑到data数组中所有可能值的结果.

在使用NumPy进行矢量化时,关键问题是逐个搜索每个数字很慢并且假设有很多唯一数字,这不是有效的解决方案.通常,两者N和唯一数字计数相当大(顺便说一下,N似乎比唯一数字计数大).

有人有好主意吗？)