我想用C或C++计算复数数组元素的绝对值.最简单的方法是
for(int i = 0; i < N; i++)
{
b[i] = cabs(a[i]);
}
但是对于那些速度很慢的大型载体.有没有办法加快速度(例如,使用并行化)？语言可以是C或C++.
学习C++时,学习函数概念的第一个函数之一就是
int add(int a, int b)
{
return a+b;
}
现在我想知道:我应该在const这里使用-keyword,或者更确切地说不是,因此
int add(const int a, const int b)
{
return a+b;
}
但那会有意义吗？它会加速我的程序,做一些其他重要的事情,或只是增加混乱？
我想在我的程序中使用信号和插槽,但遗憾的是它们应该用于传输几种不同的数据类型(例如QString,double等).我不想写二十个不同的插槽只是因为我需要一个数据类型.但是当我想要声明一个像这样的插槽时
template <typename t>
void Slot1(t data);
QT告诉我,不可能在信号和插槽中使用模板.有解决方法吗？或者我的方法可以简单改进吗？
我有以下问题:我想通过TCP传输数据,并为此编写了一个函数.为了获得最大的可重用性,函数模板是f(QPair<QString, QVariant> data).第一个值(aka QString)由接收器用作目标地址,第二个值包含数据.现在我想转移一个QPair<int, int>-value,但不幸的是我无法将a转换QPair为a QVariant.最佳的方法是能够传输一对值int而无需编写新函数(或使旧函数过载).QPair在这种情况下,最好的选择是什么？
我目前正在使用我的python程序中的非常小的数字,例如
x = 200 + 2e-26
一种解决方案是使用对数值,这将增加我的浮点值的范围.问题是我必须使用这些值进行fft,因此使用对数方法是不可用的(并且Decimal也不使用-module).有没有其他方法可以解决这个问题？
编辑:我的decimal模块问题是:我如何处理虚数值？我试过a = Decimal(1e-26)+Decimal(1e-26*1j)和a = Decimal(1e-26)+Decimal(1e-26)*1j,以及两种方式失败(应要求提供误差).
我试过写一个makefile:
CC = g++
LD = ld
CFLAGS = -Wall -std=c++0x -O3
LDFLAGS = -lgsl -lgslcblas -lpthread
SOURCES = main.cpp
OBJECTS = $(SOURCES:.cpp=.o)
EXECUTABLES = main
all: $(SOURCES) $(EXECUTABLES)
$(EXECUTABLES): $(OBJECTS)
$(CC) $(OBJECTS) -o $@ $^ $(LDFLAGS)
.cpp.o:
$(CC) $(CFLAGS) $< -o $@
.PHONY: clean
clean:
rm -f *~ *.o main
但是当我执行此代码时,我收到以下错误:
g++ -Wall -std=c++0x -O3 main.cpp -o main.o
main.cpp: In function ‘int main()’:
main.cpp:63:12: warning: unused variable ‘order’ [-Wunused-variable]
main.cpp:64:12: warning: variable ‘x’ set but not used [-Wunused-but-set-variable]
g++ …我有一个复数的向量(可以在这里找到),包括Python和MATLAB.我计算ifft与-transformation
ifft(<vector>)
在MATLAB和
np.fft.ifft(<vector>)
在Python中.我的问题是我得到两个完全不同的结果,即虽然Python中的向量很复杂,但它不在MATLAB中.虽然MATLAB中的一些组件为零,但Python中没有组件.这是为什么？在fft按预期-version工作.最小值在附近1e-10,即不太低.
我目前正试图从numpy中理解fft函数.为此,我测试了以下假设:
我有两个函数,f(x) = x^2和g(x) = f'(x) = 2*x.根据傅立叶变换定律和wolfram alpha,它应该是G(w) = 2pi*i*F(w)(前因子可以变化,但应该只有一个常数因子).在python中实现它时,我写道
import numpy as np
def x2(x):
return x*x
def nx(x):
return 2*x
a = np.linspace(-3, 3, 16)
a1 = x2(a)
a2 = nx(a)
b1 = np.fft.fft(a1)
b2 = np.fft.fft(a2)
c = b1/b2
现在我期待一个几乎恒定的价值c,但我得到了
array([ 1.02081592e+16+0.j , 1.32769987e-16-1.0054679j ,
4.90653893e-17-0.48284271j, -1.28214041e-16-0.29932115j,
-1.21430643e-16-0.2j , 5.63664751e-16-0.13363573j,
-5.92271642e-17-0.08284271j, -4.21346622e-16-0.03978247j,
-5.55111512e-16-0.j , -5.04781597e-16+0.03978247j,
-6.29288619e-17+0.08284271j, 8.39500693e-16+0.13363573j,
-1.21430643e-16+0.2j , -0.00000000e+00+0.29932115j,
-0.00000000e+00+0.48284271j, 1.32769987e-16+1.0054679j ])
我的错误在哪里,我该如何按照预期使用fft？
在我的项目中，我必须做几个向量乘法，在double *a-vectors 或float *a-vectors 上完成。为了加速这一过程，我想使用 SIMD 操作或omp. 为了获得最快的结果，我编写了一个基准程序：
#include <iostream>
#include <memory>
#include <vector>
#include <omp.h>
#include <immintrin.h>
#include <stdlib.h>
#include <chrono>
#define SIZE 32768
#define ROUNDS 1e5
void multiply_singular(float *a, float *b, float *d)
{
for(int i = 0; i < SIZE; i++)
d[i] = a[i]*b[i];
}
void multiply_omp(float *a, float *b, float *d)
{
#pragma omp parallel for
for(int i = 0; i < SIZE; i++)
d[i] = a[i]*b[i];
}
void multiply_avx(float …假设我想两个向量加a和b成矢量c
std::vector<double> a, b, c;
//Fill/Initialize vectors
我可以使用std::transform()或简单的for循环：
//std::transform
std::transform(a.begin(),
a.end(),
b.begin(),
c.begin(),
[](const auto &a_val, const auto &b_val){
return a_val + b_val;
});
//Loop
for(size_t i = 0; i < a.size(); ++i){
c[i] = a[i] + b[i];
}
通常，std::transform()推荐使用与for-loop 相比较。不幸的是，据我所知，我无法使用类似的方法来std::transform()添加超过两个向量的情况，即如果我想将向量相加a，b并c放入 d 中。然后我回到 for 循环，或者我必须使用两轮std::transform(). 或者有没有一种方法可以使用单个std::transform()操作（或类似的东西）同时对两个以上的输入向量进行操作？