有一个循环：
long a* = new long[32];
long b* = new long[32];
double c* = new double[32];
double d = 3.14159268;
//set a, b and c arrays
//.....
for(int i = 0; i < 32; i ++){
d+= (a[i] % b[i])/c[i];
}
我如何使用英特尔 C++ 矢量化功能（例如#pragma simd 或 sse- 指令）来实现此周期？
如果我写：
#pragma simd reduction(+:c)
for(int i = 0; i < 32; i ++){
d+= (a[i] % b[i])/c[i];
}
那么速度不会增加:(
我有一个 R 函数来使用 for 循环计算逻辑图，如下所示。但是有没有办法改变它（例如向量化它）以便它不使用循环？
logistic_map <- function(x, # starting condition
r, # rate parameter
N) { # number of iterations
results <- numeric(length = N + 1)
results[1] <- x
for (i in seq_len(N)) {
results[i + 1] <- r * results[i] * (1 - results[i])
}
data.frame(i = c(0, seq_len(N)),
x = results)
}
我已经研究了apply()函数族和 中的函数purrr，但我正在努力确定这是否可能。我很想得出这样的结论：这是不可能的，因为每一步都完全依赖于前一步，但完全有可能有一个我无法找到的优雅解决方案。
我可以在不使用 for 循环的情况下执行此操作吗？
这本书说如下：
对于 Knights Landing，当数据起始地址位于 64 字节边界时，内存移动是最佳的。
Q1. 有没有办法在 C++ 代码中动态查询处理器，以了解n当前运行应用程序的处理器的最佳字节边界是什么？这样，代码就可以移植了。
书中进一步指出：
作为程序员，我们最终有两项工作：（1）对齐我们的数据；（2）确保编译器知道它是对齐的。
（假设对于下面的问题，我们知道处理器的最佳数据是从 64 字节边界开始。）
这个“数据”到底是什么？
假设我有一堂课：
class Class1_{
private:
int a;//4 bytes
double b;//8 bytes
std::vector<int> potentially_longish_vector_int;
std::vector<double> potentially_longish_vector_double;
double * potentially_longish_heap_array_double;
public:
//--stuff---//
double * return_heap_array_address() {return potentially_longish_heap_array_double;}
}
假设我还有原型化的函数：
void func1(Class1_& obj_class1);
void func2(double* array);
也就是说，通过引用func1接收一个对象，并调用为Class1_func2func2(obj_class1.return_heap_array_address());
为了与数据应该适当边界对齐的建议保持一致，obj_class1它本身应该是 64 字节边界对齐以实现 的有效运行func1()吗？应该potentially_longish_heap_array_double对齐 64 字节边界才能有效运行吗func2()？
对于作为 STL 容器的类的其他数据成员的对齐，此处的线程建议如何完成所需的对齐。
Q2。那么，对象本身以及其中的所有数据成员是否需要适当对齐？
c++ simd vectorization memory-alignment compiler-optimization
我有一个可重现的样本，如下所示 -
#include <iostream>
#include <chrono>
#include <immintrin.h>
#include <vector>
#include <numeric>
template<typename type>
void AddMatrixOpenMP(type* matA, type* matB, type* result, size_t size){
for(size_t i=0; i < size * size; i++){
result[i] = matA[i] + matB[i];
}
}
int main(){
size_t size = 8192;
//std::cout<<sizeof(double) * 8<<std::endl;
auto matA = (float*) aligned_alloc(sizeof(float), size * size * sizeof(float));
auto matB = (float*) aligned_alloc(sizeof(float), size * size * sizeof(float));
auto result = (float*) aligned_alloc(sizeof(float), size * size * sizeof(float));
for(int i = …我正在编写一个封装父类的多个对象的子类，这样我就可以像向量一样调用函数，如下所示：
package OriginalClass;
sub new { return bless {bar => 123}, 'OriginalClass' }
sub foo { return shift->{bar}; }
1;
package NewClass;
use parent OriginalClass;
# Return a blessed arrayref of "OriginalClass" objects.
# new() would be called NewClass->new(OriginalClass->new(), ...)
sub new {
my $class = shift;
return bless \@_, 'NewClass';
}
# Vectorized foo(), returns a list of SUPER::foo() results:
sub foo
{
my $self = shift;
my @ret;
push @ret, $_->SUPER::foo() foreach @$self;
return @ret;
}
1;
我不想 …
我有一个二维矩阵
M = np.array([[0.5+t, 1, 1],
[0.5, 0.5, t],
[0.5, 1-t, 0.5]])
我想为 $t$ 的几个值计算该矩阵的一些属性。我可以用 for 循环来做到这一点，但我想知道是否有一种方法可以不用循环来做到这一点。例如，创建一个 3d 数组，其中该数组的每个幻灯片都是一个 2d 数组，其中包含给定 t 的矩阵 M。
循环实现将是这样的。
import numpy as np
def M(t: float):
return np.array([[0.5+t, 1, 1], [0.5, 0.5, t], [0.5, 1-t, 0.5]])
t_vec = np.linspace(0, 1, num=100)
norm = np.zeros_like(t_vec)
for i, t in enumerate(t_vec):
matrix = M(t)
norm[i] = np.linalg.norm(matrix)
在本例中，我想计算矩阵的 2 范数并将所有值存储在数组中。
我想“添加”两个矩阵，一个形状a为 ( K,T) 的矩阵和一个形状b为 的矩阵(K,N)，以产生形状为 的矩阵(K,T,N）
以下工作正常：
import numpy as np
from numba import njit
@njit
def add_matrices(a, b):
K, T, N = a.shape[0], a.shape[1], b.shape[1]
result_matrix = np.empty((K, T, N))
for k in range(K):
for t in range(T):
for n in range(N):
result_matrix[k, t, n] = a[k, t] + b[k, n]
return result_matrix
K = 10
T = 11
N = 12
a = np.ones((K,T))
b = np.ones((K,N))
result = …我有一个矩阵a,我想计算从一个点到所有其他点的距离.所以结果矩阵确实应该为零(在我选择的点上)并且应该在该特定点周围显示为某种数字圆圈.
这就是我已经拥有但我似乎无法得到正确的结果.
a = [1 2 3 4 5 6 7 8 9 10]
for i = 2:20
a(i,:) = a(i-1,:) + 1;
end
N = 10
for I = 1:N
for J = 1:N
dx = a(I,1)-a(J,1);
dy = a(I,2)-a(J,2);
distance(I,J) = sqrt(dx^2 + dy^2)
end
end
我有一个Python函数f,它接受一对数字并返回计算结果,比方说, x+y
def f(x,y):
return x+y
如何进行矢量化f,因此对于给定的矢量X =(x1,...,xn)和Y =(y1,...,yn)
f_vectorized(X,Y)返回f(x1,y1),f(x2,y2)...的数组？
编辑
上面,x + y是一个例子,但实际计算更复杂,因此通过考虑x和y,numpy向量不一定是开箱即用的.
我有一个大矢量vec大小n x 1(与n一个庞大的数字).所有值vec都是0或1.向量由大小块组成m,在每个块中,只包括这两个值中的一个.
为了确保这种情况,我遍历块中的每个start元素并将该值复制到相应块的所有条目中:
for i = 1:m:n
if vec(i) == 1
vec(i:i+m-1) = 1;
else
vec(i:i+m-1) = 0;
end
end
如何在不丢失循环的情况下实现这一目标,以便更好地使用MATLABs矢量化并行化？提前致谢