blocks|key|907975|text|你的集成算法是什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|907976|从数学上讲，范围上的积分是各部分上的积分之和，因此并行化似乎微不足道。|907977|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

What is your integration algorithm?

Mathematically, integral over range is sum of integrals over parts, so parallelization seems trivial.

blocks|key|3223577|text|我建议你看看英特尔的线程构建块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3223578|http://www.threadingbuildingblocks.org/|offset|length|3223579|尤其是parallel_reduce。|style|CODE|3223580|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|13|0|0|3|F|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@$D|S|E|T|1|U]]|A|$]]|$1|F|3|G|5|6|7|V|8|@$D|W|E|X|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|C]]]]

I suggest you look at intel's thread building blocks.

<a href="http://www.threadingbuildingblocks.org/" rel="nofollow noreferrer">http://www.threadingbuildingblocks.org/</a>

and especially <code>parallel_reduce</code>.

blocks|key|3223596|text|使用OpenMP。gcc对此表示支持。Visual+C%2B%2B支持它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3223597|entityMap|0|LINK|mutability|MUTABLE|url|http://openmp.org/wp/^0|2|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Use <a href="http://openmp.org/wp/" rel="nofollow noreferrer">OpenMP</a>. gcc supports it. Visual C++ supports it.

blocks|key|908031|text|正如其他人所说，我相信你会知道集成就是求和，并行化应该很容易我知道你正在使用C%2B%2B，但是使用go是可能的吗？使用goroutines来完成这类工作非常容易。但我知道，如果这段代码是给客户的，你就不会愿意使用go，因为它还没有在野外测试过。如果这是一个个人项目，就去做吧(没有双关语的意思)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|908032|entityMap|0|LINK|mutability|MUTABLE|url|http://golang.org/|1|http://golang.org/doc/effective_go.html#goroutines^0|1A|2|0|1K|A|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

As others have said, and I'm sure you would know integration is summation, parellization should be easy
I know you are using C++, but is using <a href="http://golang.org" rel="nofollow noreferrer">go</a> a possibility? It is very easy to use <a href="http://golang.org/doc/effective_go.html#goroutines" rel="nofollow noreferrer">goroutines</a> to do this type of job. But I understand if this code is going to a customer you would be reluctant to use go as it is still untested in the wild. If it is a personal project go for it (no pun intended).

blocks|key|3223693|text|你会遇到的问题是边界条件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3223694|很容易认为数值求积可以分成几个区域，但你不知道内部边界条件是什么。|3223695|将积分分解为子域开始听起来像有限元、有限差分或边界元解。你已经把一个复杂的域分解成碎片，把它变成一个矩阵，并在给定边界条件的情况下求解它。|3223696|我认为这不像将域分成多个子域并将每个子域分配给一个处理器那么简单，但我可能错了。|3223697|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The problem you'll have is boundary conditions. 

It's easy to think that numerical quadrature can be broken up into several domains, but you don't know what the internal boundary conditions are.

Breaking an integral up into subdomains starts sounding like a finite element, finite difference, or boundary element solution. You've taken a complex domain, broken into to pieces, turned it into a matrix, and solved it given the boundary conditions you know.

I don't think this is as simple as breaking the domain into subdomains and assigning each one to a processor, but I could be wrong.

blocks|key|4691372|text|分两部分来解决这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4691373|1)你打算采用什么样的并行化方法:+MPI，OpenMP，线程，你有什么？和|4691374|2)如何修改算法。|4691375|在一台四核的Windows机上，我建议使用OpenMP作为第一部分的答案。第二部分的答案取决于您使用的算法。例如，如果您正在使用蒙特卡罗技术，那么并行化是微不足道的。如果你使用某种类型的数值求积，那么确保其他人确定的任何角落情况都不会成为严重问题，就不那么简单了。然而，如果你能排除病理积分，这应该不会太难。|4691376|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Tackle this in 2 parts:

1) What approach to parallelisation are you going to take: MPI, OpenMP, threads, what-have-you ? and

2) How to modify the algorithm.

On a quad-core Windows machine, I'd suggest OpenMP as my answer to the first part of this. The answer to the second part depends on what algorithm you are using. If, for example, you are using the Monte Carlo technique, parallelisation is trivial. If you're using numerical quadrature of some sort, it's a lot less trivial to ensure that none of the corner cases that others have identified become serious problems. However, if you can exclude pathological integrals it shouldn't be prohibitively difficult

blocks|key|1049823|text|您可以使用Trapezoidal+rule+(或任何其他牛顿-柯特斯公式)计算积分。为了获得更好的结果，您可以对间隔进行分段，并对每个分段使用梯形规则。公式可以在链接的文章中找到。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1049824|由于每个计算都是相互独立的，因此可以并行执行它们。最简单的方法是OpenMP+(如上所述)。|1049825|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Trapezoidal_rule^0|5|G|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

You can calculate the integral using the <a href="http://en.wikipedia.org/wiki/Trapezoidal_rule" rel="nofollow noreferrer">Trapezoidal rule</a> (or any other of the Newton-Cotes formulas). To get a better result, you can segment the interval and use the Trapezoidal rule for each segment. The formula can be found in the linked article.

Since each calculation is independent of the other, you can execute them in parallel. The easiest way to do this is OpenMP (as mentioned above).

I want to reduce the calculation time for a time-consuming integral by splitting the integration range. I'm using C++, Windows, and a quad-core Intel i7 CPU.

How can I split it into 4 parallel computations?

Parallel computing for integrals

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想通过拆分积分范围来减少耗时的积分的计算时间。我使用的是C++、Windows和一个四核的英特尔i7处理器。如何将其拆分成4个并行计算？

问积分的并行计算
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问积分的并行计算EN