为什么在openMP中旧的rand()比uniform_real_distribution快？
在OpenMP中，旧的rand()函数比uniform_real_distribution快的原因是因为rand()函数是一个伪随机数生成器，它使用线性同余算法生成随机数。这种算法的计算速度相对较快，但生成的随机数序列可能存在一定的偏差和周期性。
而uniform_real_distribution是C++标准库中的一个随机数分布类，它使用更复杂的算法生成均匀分布的随机数。这种算法的计算速度相对较慢，但生成的随机数序列更加均匀和随机。
在OpenMP并行计算中，旧的rand()函数由于计算速度快，可以更好地满足并行计算的需求。而uniform_real_distribution由于计算速度较慢，可能会成为并行计算的瓶颈。
然而，需要注意的是，旧的rand()函数生成的随机数序列可能存在一定的偏差和周期性，不够随机。在一些对随机性要求较高的应用场景中，建议使用uniform_real_distribution等更高质量的随机数生成方法。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 腾讯云弹性MapReduce（EMR）：https://cloud.tencent.com/product/emr
- 腾讯云容器服务（TKE）：https://cloud.tencent.com/product/tke
- 腾讯云人工智能（AI）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（IoT）：https://cloud.tencent.com/product/iot
- 腾讯云移动开发（Mobile）：https://cloud.tencent.com/product/mobile
- 腾讯云对象存储（COS）：https://cloud.tencent.com/product/cos
- 腾讯云区块链（BCS）：https://cloud.tencent.com/product/bcs
- 腾讯云元宇宙（Metaverse）：https://cloud.tencent.com/product/metaverse
相关·内容
我正在调试的一个神经进化程序不会在每次调用它时产生随机值。在程序中，使用以下语句初始化网络对象的向量：
vector<Network> population(POPULATION_SIZE, Network(sizes, inputCount));
我认为程序不能收敛到最优解的原因是，头100个人口总是相同的。当以这种方式初始化网络时，连接权重和神经元偏差(每个)都由以下类函数初始化：
double Network::randDouble(double low, double high) {
/*default_random_engine generator(std::ch
浏览 0提问于2018-02-11得票数 1
1回答
我正在c++中测试随机数生成器的性能，并得到了一些我不理解的非常奇怪的结果。
我测试了使用std::uniform_real_distribution的std::rand和std::minstd_rand。
计时std代码：：rand
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 1000000; ++i)
std::rand();
auto finish = std::chrono::high_resolution_clock::now();
std::chrono::
浏览 0提问于2019-11-06得票数 2
回答已采纳
我正在尝试编写一个多文件程序，包括以下与随机数生成相关的代码：
in Hel.h文件：
extern random_device rand_dev;
extern ranlux48 rand_eng;
extern uniform_real_distribution<> zero2one_dist;
中的help.cpp文件：
#include "help.h"
random_device rand_dev;
ranlux48 rand_eng{ rand_dev() };
uniform_real_distribution<> zero2one_dis
浏览 3提问于2017-12-04得票数 0
回答已采纳
为什么作为随机数生成器，std::uniform_real_distribution比rand()更好？有没有人能举个例子？
浏览 0提问于2012-11-21得票数 12
回答已采纳
2回答
我的用于OpenMP中并行化的简单的OpenMP循环是
vector< double > xs;
vector< double > ys;
xs.resize(N);
ys.resize(N);
if(rank0) printf("Assigning points ...\n");
#pragma omp parallel for
for(long i = 0; i < N; i++) {
xs[i] = ((double)rand()/(double)RAND_MAX);
浏览 7提问于2016-04-29得票数 2
回答已采纳
我的代码中有以下实现：
// first solution
//random.h
class Random{
public:
std::mt19937* gen;
std::uniform_real_distribution<double>* dis;
}
//random.cpp
Random::Random()
{
std::mt19937_64::result_type seed = chrono::high_resolution_clock::now().time_since_epoch().count();
ge
浏览 0提问于2015-08-07得票数 1
回答已采纳
编辑:解决了！Windows将堆栈大小限制在缓冲区不适合的地方；linux则不适合(另外，我正在访问数组外的内存.(哎呀)。使用gcc，您可以将堆栈大小设置为：gcc -Wl --stack,N [your other flags n stuff]，其中N是堆栈的大小(以字节为单位)。最终工作编译命令：gcc -Wl --stack,8000000 -fopenmp openmp.c -o openmp
有趣的是，rand()函数产生的模式似乎比Linux中的要小，因为我可以看到在Windows上生成的噪声中的模式(平铺)，而在Linux上看不到。与往常一样，如果您需要它是绝对随机的，请使用加
浏览 0提问于2019-05-16得票数 2
回答已采纳
1回答
我想在C++中的0,1上生成均匀分布的数字。我知道下面的代码将适用于这项工作
std::random_device rand_dev;
std::mt19937 generator(rand_dev());
std::uniform_real_distribution<double> uni(0,1);
std::cout << uni(generator);
但我的问题是，我想在类范围内生成这些数字。每次我调用这个类的函数时，我都不想使用一个新的随机数生成器，因为我需要经常调用这个函数。我可以在整个类中使用相同的数字生成器
浏览 2提问于2020-04-26得票数 3
回答已采纳
在我的程序中，我使用uniform_real_distribution()生成0到1之间的均匀随机数。
#include <random>
default_random_engine e;
uniform_real_distribution<double> u(0,1);
double rand_num = u(e);
我想知道，除了0，生成的随机数的最小值是多少。即两个随机数之间的最小间距。
浏览 1提问于2015-02-02得票数 2
回答已采纳
2回答
我使用rand()函数来生成0,1之间的伪随机数，以进行模拟，但当我决定将C++代码并行运行(通过OpenMP)时，我注意到rand()不是线程安全的，也不是很均匀的。
因此，我转而使用(所谓的)更统一的生成器，在许多其他问题的答案中。看上去像这样
double rnd(const double & min, const double & max) {
static thread_local mt19937* generator = nullptr;
if (!generator) generator = new mt19937(clock() + omp_ge
浏览 2提问于2018-05-15得票数 12
回答已采纳
如何从区间0，1中得到一个均匀分布的随机数
我目前使用的是以下代码，但它是用C语言编写的，我想知道人们是如何用C++来做事情的。
double RND()
{
return ((double)rand()/RAND_MAX);
}
浏览 0提问于2015-04-01得票数 0
2回答
给定一个示例函数(下面给出示例)，for循环可以使用OpenMP并行化，也可以使用向量化(假设编译器执行向量化)进行向量化。
示例
void function(float* a, float* b, float* c, int n)
{
for(int i = 0; i < n; i++)
{
c[i] = a[i] * b[i];
}
}
我想知道
VectorizationIs和是否会在性能上有任何差异？是否有可能同时使用OpenMP和矢量化。
注意:我没有给出关于SSE的不同版本，处理器/核的数量(随着OpenMP中的线程数的
浏览 3提问于2012-05-09得票数 2
回答已采纳
谁能解释一下为什么使用旧的rand()的第二个for循环的执行速度比第一个循环快得多？我在这里通过多篇文章看到，推荐使用c++11引擎和统一分发，因为rand() +多线程是性能瓶颈？同样，正如我所建议的，我有生成器和每个线程的函数。 int main(int argc, char *argv[])
{
std::vector<mt19937> generators(omp_get_max_threads());
std::vector<uniform_real_distribution<double>> functions(omp_ge
浏览 14提问于2020-09-15得票数 0
1回答
我正在尝试通过并行化蒙特卡罗代码来学习如何使用OpenMP，该代码通过给定的迭代次数来计算PI的值。代码的要点是：
int chunk = CHUNKSIZE;
count=0;
#pragma omp paralle
浏览 1提问于2011-06-01得票数 5
回答已采纳
我写了这段代码：
std::pair<std::weak_ptr<Node>, size_t> NodeSelector::rouletteWheel() const {
const std::uniform_real_distribution<long double> urd;
size_t i = 0;
for(auto rnd = urd(shared_random_engine); rnd >= 0; ++i) {
rnd -= getNormValue(i);
}
return std:
浏览 1提问于2019-03-20得票数 6
回答已采纳
2回答
我有以下代码，它们使用openmp做矩阵多用，让我们假设a=m x n和b=n x k
for (i = 0; i < m; i++)
for (j = 0; j < k; j++)
for (l = 0; l < n; l++)
c[i * k + j] += a[i * n + l] * b[l * k + j];
和
for (i = 0; i < m; i++)
for (j = 0; j < k; j++)
for (l = 0; l < n; l++)
浏览 0提问于2017-08-19得票数 0
2回答
我做了一个计算斐波纳契序列的程序。我用不同数量的线程来执行它。1，2，10)但是执行时间几乎保持不变(大约0.500秒)。
我在Ubuntu和GNU GCC编译器上使用CodeBlocks。在CodeBlocks中，我链接了库gomp，并为编译器定义了标志-fopenmp。
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i, n=1000, a[n];
omp_set_num_threads(4);
for(i=0; i<n;
浏览 7提问于2013-11-17得票数 0
回答已采纳
我有一个简单的代码示例：
#include <iostream>
#include <random>
using namespace std;
int main() {
minstd_rand0 gen(1);
uniform_real_distribution<double> dist(0.0, 1.0);
for(int i = 0; i < 10; ++i) {
cout << "1 " << dist(gen) << endl;
}
n
浏览 3提问于2016-07-22得票数 11
回答已采纳
1回答
优化佛陀罗特
、、、
我目前正在开发自己的Buddhabrot实现。到目前为止，我正在使用来自C++11的std::thread-Class同时完成以下迭代：
void iterate(float *res){
//generate starting point
std::default_random_engine generator;
std::uniform_real_distribution<double> distribution(-1.5,1.5);
double ReC,ImC;
double ReS,ImS,ReS_;
unsigned int steps;
unsigned int
浏览 1提问于2014-12-18得票数 1
3回答
在C++11中有一堆新的随机数生成器引擎和分布函数。它们是线程安全的吗？如果你在多个线程之间共享一个随机分布和引擎，它是安全的吗?你还会收到随机数吗？我正在寻找的场景是这样的，
void foo() {
std::mt19937_64 engine(static_cast<uint64_t> (system_clock::to_time_t(system_clock::now())));
std::uniform_real_distribution<double> zeroToOne(0.0, 1.0);
#pragma omp parallel for
浏览 0提问于2012-01-11得票数 36
回答已采纳
我试图生成一个均匀分布在[0，1]之间的随机数，我尝试过uniform_real_distribution，但我不知道它是如何工作的。我有下面的代码，但它每次都会生成接近相同的数字~.456
void RandomNumber()
{
srand(time(0));
double number=(double)rand()/((double)RAND_MAX+1);
cout<<"RANDOM NUMBER: "<<number<<endl;
}
浏览 2提问于2018-02-10得票数 1
1回答
我对使用OpenMp的性能有问题。我正在尝试测试不使用OpenMP的单线程程序和使用OpenMP的应用程序的结果。通过在线查看比较矩阵链乘法程序的结果，openMP实现的速度是2到3倍，但我的实现速度与这两个应用程序相同。我实现openMP的方式不正确吗？openMP上的任何指针以及如何正确地实现它？任何帮助都是非常感谢的。提前谢谢。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main( int argc , char *argv[] )
{
srand(time(0)
浏览 2提问于2016-01-25得票数 1
回答已采纳
2回答
这个问题是我以前的代码评审问题的后续问题.这个问题涉及到选择一个预定义随机数发生器算法的能力，也考虑了一个生成器的分布。
对于上下文，下面是当前状态下的完整代码：
#include <algorithm>
#include <boost/program_options.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits&
浏览 0提问于2017-08-24得票数 2
回答已采纳
调用std：：在不同的容器上两次从STL生成算法会产生等价的结果。
假设我想填充两个浮点数在-1之间的随机数。和1.：
std::array<float, 1000> x;
std::array<float, 1000> y;
std::random_device rd;
std::mt19937_64 gen(rd());
std::uniform_real_distribution<float> dis(-1.f, 1.f);
auto rand = std::bind(dis, gen);
std::generate(x.begin(), x.end
浏览 2提问于2013-12-19得票数 4
回答已采纳
2回答
我试了两件事：
class RandDouble{
public:
RandDouble(double const& min_inclusive, double const& max_exclusive):
mt_(std::random_device()),
dist_(min_inclusive,max_exclusive)
{}
~RandDouble(){}
double get(){ return dist_(mt_); }
pr
浏览 2提问于2014-11-25得票数 0
回答已采纳
4回答
在PHP中获得随机布尔值true/false的最优雅方法是什么？
我能想到：
$value = (bool)rand(0,1);
但是，将整数转换为布尔值会带来任何缺点吗？
还是说这是一种“官方”的方式？
浏览 5提问于2013-10-07得票数 86
回答已采纳
我正在编写一个OpenMP代码，其中每个线程将在0到1之间的均匀分布的随机数的大数组上工作，每个线程需要有不同的独立的随机数分布。此外，每次调用代码时，随机数分布都需要不同。这就是我现在用的。这是否总是保证每个线程都有自己的/不同的随机数序列？每次调用代码时，序列会有所不同吗？正确的做法是什么？下面的代码让每个线程生成5个示例，但在实际运行中，它将是数百万的顺序。
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <time.h>
int main(int argc
浏览 1提问于2020-02-19得票数 1
回答已采纳
我最近学到了oenmp，我有两个主要的问题。考虑一下简单的例子：
using namespace std;
std::minstd_rand gen(std::random_device{}());
std::uniform_real_distribution<double> unirnd(0, 1);
int main(){
double eta=something;
double x[N],y[N];
//initializing x[] and y[]...
for (i=0;i<N;i++)
{
double z= unirnd(gen) * et
浏览 3提问于2017-11-21得票数 1
回答已采纳
我正在做一个模拟，我使用一个函数来生成模拟指数分布的数字(我不想使用c++ 11函数)
这是密码
long double exponential(long double l)
{
long double mean = l;
long double u = ((long double)rand() / ((long double)RAND_MAX + 1.0));
return (-log(u) * mean);
}
有时返回的值是inf，知道为什么，会是0吗？
浏览 4提问于2013-11-19得票数 0
回答已采纳
1回答
我想要生成一个随机数，并在我的GPU上使用SHA256使用OpenCL和基本代码进行散列(而不是散列那些预先给定的纯文本，而是散列随机数)。
我得到了所有的哈希处理我的GPU，但有一个问题：
当使用OpenCL时每秒所做的哈希量会降低吗？
是的，您正确地听到了，目前只使用CPU比只使用GPU更快。
我的GPU只在~10%上运行，而CPU在~100%上运行。
我的问题是:这怎么可能，更重要的是，我如何解决它？
这是我用来生成Pseudo-Random Number的代码(在两次运行之间根本不改变)：
long Miner::Rand() {
std::mt19937 rng;
/
浏览 15提问于2017-10-02得票数 0
1回答
我有一种动物，在一段时间的循环中生活了很多天。
最后，她有40%的机会生产，
class Animal
{
public:
double chance_of_birth;
...
public Animal(..., int chance)
{
this.chance_of_birth = chance;
...
}
}
// create this animal
Animal this_animal = new Animal(..., .50);
考虑到我所创造的每一种动物都有特定的生育机会，我如何才能写出一种只对chance_of_birth %进行
浏览 3提问于2016-04-16得票数 1
回答已采纳
1回答
OpenMP调度器
、、、
我对在OpenMP中分发任务有问题。我有下一个代码：
#include <stdio.h>
#include <unistd.h>
int cnttotal = 0;
int cnt1 = 0, cnt2 = 0;
int main()
{
int i;
#pragma omp parallel
#pragma omp single nowait
for (i = 0; i < 60; i++) {
if (cnttotal < 1) {
cnttotal++;
浏览 0提问于2015-08-07得票数 0
回答已采纳
我试图实现一个简单的噪声函数，它接受两个整数，并根据两个参数组合的种子返回一个随机浮点数。
使用std::mt19937很好，但是由于某种原因，当我尝试在rand()中使用srand时，我会得到重复的数字。
注意:在循环中使用c++11 seed成员函数的非常非常慢。
下面是两个使用这两种方法的地形(有相同的重播号)：
c++11随机：
std::random_device rd;
std::mt19937 g{ rd() };
std::uniform_real_distribution<float> gen{ -1.0, 1.0 };
float getNoise(i
浏览 0提问于2016-07-03得票数 3
回答已采纳
<random>有大量的引擎和分配选项。这是很好的，但我读过的大多数文档都同样关注每个引擎和发行版，并且不努力为某些用例建议使用或有用的实例。我通常只是使用rand()来快速获取有用的数据，但我正在努力成为一个更好的C++程序员！(另外，在一定范围内从rand()中获得有用的浮标有时可能是自己的头疼)
我的问题是，在C++中，最快速、最懒惰的方法是在0.n范围内执行随机数(浮动，选择类型)，而不会有任何奇怪的意外？
编辑：
看着评论中随机提到的演示文稿，我意识到我需要的引擎和发行版是mt199937和uniform_real_distribution。我不知道哪个是梅森龙卷风，但是
浏览 0提问于2014-07-06得票数 2
回答已采纳
我正在使用javax.crypto.KeyGenerator生成密钥。
下面是AES的代码：
Key key = null;
SecureRandom rand = new SecureRandom();
KeyGenerator generator;
try {
generator = KeyGenerator.getInstance("AES");
generator.init(rand);
generator
浏览 2提问于2017-12-05得票数 0
回答已采纳
1回答
我最近开始学习JAX。我用NumPy编写了一个简短的片段，并在JAX中编写了相应的代码片段。我原以为JAX会更快，但当我分析代码时，NumPy代码要比JAX代码快得多。我想知道这是否一般是真的，或者在我的实现中是否存在问题。
NumPy代码：
import numpy as np
from time import time as tm
def gp(x):
return np.maximum(np.zeros(x.shape), x)
# -- inputs
n_q1 = 25
n_q2 = 5
x = np.random.rand(1, n_q1) # todo: cha
浏览 7提问于2022-01-17得票数 1
回答已采纳
我有以下使用openmp多线程的蒙特卡洛代码 int main()
{
std::uniform_int_distribution<int> dir(0, 1);
std::uniform_int_distribution<int> xyz(0, 2);
std::uniform_real_distribution<double> angle(0,360);
mt19937 gen{0};
auto M = 20;
long double sum = 0;
auto num_trials = 10000;
// omp_s
浏览 8提问于2020-10-21得票数 0
回答已采纳
最近我参加了关于数据结构的课程，我了解到在连接两个元素时，QuickUnion的性能优于QuickFind。但是当我在GCC，Windows 10，而不是老师的机器Mac中测试相同的代码时，我得到了完全不同的运行时结果，但不知道为什么。这是QuickFind的代码。
#ifndef INC_03_QUICK_UNION_UNIONFIND1_H
#define INC_03_QUICK_UNION_UNIONFIND1_H
#include <cassert>
using namespace std;
namespace UF1 {
class UnionFind
浏览 3提问于2017-04-07得票数 3
回答已采纳
我首先编写了两个应用程序:使用C#中的随机类生成任意颜色的图像，每个像素的颜色范围从0到255 ARGB，图像大小为3000 x 3000宽度和高度。第二个应用:生成相同的宽度和高度(3000 X 3000)的图像，但使用范围从60到120的ARGB颜色的A，R，G，B的每个像素.
第一个应用程序生成大小为500 KB的图像。第二个应用程序生成图像大小: 24 MB。
它们都使用PNG作为图像的格式和32位的颜色深度。我不明白两者之间的区别是什么，为什么图像大小不同？什么事情对图像的大小有显著的影响？...............................................
浏览 0提问于2014-04-07得票数 0
回答已采纳
1回答
OpenMP分割在C++中的应用
、、、、
我有一个非常简单的函数，通过N 2D矩阵(由指针arr表示)计算N2D矩阵的内部条目数，并更新通过引用传递的计数器below_threshold：
void count(float *arr, const int N, const float threshold, int &below_threshold) {
below_threshold = 0; // make sure it is reset
bool comparison;
float temp;
#pragma omp parallel for shared(arr, N, th
浏览 1提问于2022-03-02得票数 0
如果我只想计算一个标准的正常变量，那么使用：
samples=norminv(rand(N),0,1);
和
samples=normrnd(0,1,N,1);
无论是在处理时间上还是在蒙特卡罗模拟中使用时的收敛性？
我问这个问题的原因是，我想使用类似于norminv()的Halton数这样的准蒙特卡罗技术来复制normrnd()，但首先我要确保我理解它们之间的关系。
我想中心问题之一是:在rand()和normrnd中，随机数是如何产生的？是同一种方法吗？
如果它们完全等同，为什么重复呢？
浏览 0提问于2014-01-23得票数 2
回答已采纳
1回答
我需要编写函数的模板，它的类型为eg。，然后生成从MIN_INT到MAX_INT的随机值。
template<typename TYPE>
TYPE generateRandom()
{
srand(static_cast<unsigned int>(time(nullptr)));
TYPE generatedValue;
//code :/
return generatedValue;
}
这里有几个问题：
rand生成to0小值(RAND_MAX)
在rand中，我不能做INT_MAX+1来包含int和负值
我也尝试
浏览 0提问于2019-01-08得票数 0
回答已采纳
1回答
我正在使用C++11提供的RNG，我也在尝试使用OpenMP。我为每个线程分配了一个引擎，作为测试，我给每个引擎分配了相同的种子。这意味着我希望两个线程产生完全相同的随机生成的数字序列。以下是MWE：
#include <iostream>
#include <random>
using namespace std;
uniform_real_distribution<double> uni(0, 1);
normal_distribution<double> nor(0, 1);
int main()
{
#pragma om
浏览 1提问于2013-04-13得票数 4
回答已采纳
2回答
我创建了一个简单的模板函数，以在范围[低、高]范围内生成T类型的随机数(我需要int或float)，如下所示：
template <typename T>
T randm(T low, T high)
{
static std::random_device seeder;
static std::mt19937 gen(seeder());
std::uniform_real_distribution<T> dis(low, high);
return dis(gen);
}
然而，当我试图称之为：
int r = randm<in
浏览 2提问于2021-11-18得票数 1
回答已采纳
我有一个类，我希望能够静态地生成自己的随机实例。要做到这一点，我有一个std::uniform_real_distribution的静态实例。但是，我在编译器中得到了一个类型错配错误。
编译器错误是：'genId' in 'class Foo' does not name a type和'randId' in 'class Foo' does not name a type。但是，我已经在头文件中指定了类型，如下所示。
头文件(Foo.hpp)：
class Foo {
public:
static std::random
浏览 0提问于2017-02-26得票数 0
回答已采纳
3回答
类montecarlo包含lambda作为成员变量。这段代码可以编译，但会在运行时导致“分段错误(内核转储)”。你能解释一下怎么修吗？
#include<random>
#include<functional>
#include<iostream>
class montecarlo
{
public:
montecarlo(double x_min, double x_max);
std::function<double()> rand;
};
montecarlo::montecarlo(double x_min, do
浏览 0提问于2018-07-03得票数 8
回答已采纳
2回答
我正在做一个简单的Pi计算，在这里我并行生成随机数和计数递增的循环。串行(非OpenMP )代码的性能优于OpenMP代码。这是我做过的一些测量。以下还提供了这两种代码。
编译串行代码为: gcc pi.c -O3
将OpenMP代码编译为: gcc pi_omp.c -O3 -fopenmp
有什么问题吗？
# Iterations = 60000000
Serial Time = 0.893912
OpenMP 1 Threads Time = 0.876654
OpenMP 2 Threads Time = 23.8537
OpenMP 4 Threads Time = 7.7241
浏览 7提问于2017-04-16得票数 0
回答已采纳
在下面给出的代码中，我希望实现一个标志(或一些同样简单的标记)，其效果与注释本地设置和使用全局设置(在本例中产生两个不同的数字)和在其他时间使用本地设置(在本例中产生两个相同的数字)具有相同的效果。
我尝试过明显的“如果”和“转换”结构，但没有成功。
#include <iostream>
#include <random>
void print();
std::seed_seq seed{1, 2, 3, 4, 5};
std::mt19937 rng(seed); // *global* initial state
std::uniform_real_dis
浏览 2提问于2015-05-14得票数 5
回答已采纳
1回答
我正在尝试使用OpenMP向我的程序添加并行性。
std::random_device rd;
std::mt19937 generator(rd());
std::uniform_real_distribution<float> distribution(-0.5, 0.5);
#pragma omp parallel for
for(int i = 0; i < 100000000; i++)
{
float x = distribution(generator);
}
我在windows (Visual 2010)和linux (Centos 6.5，gcc
浏览 2提问于2014-09-15得票数 0
回答已采纳
我有一个非常简单的矩阵乘法程序来尝试OpenMP：
#include <iostream>
#include <stdlib.h>
#include <omp.h>
int main() {
const int N = 1000;
double matrix[N][N];
double vector[N];
double outvector[N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
matrix[i][j] = ra
浏览 12提问于2021-07-14得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
