blocks|key|155607|text|以下是通用Lisp中RK的一个实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|155608|http://github.com/bld/bld-ode/blob/master/rk.lisp|offset|length|155609|关于Common的好处是，您可以从简单而优雅的代码开始，然后使关键位快速运行(例如，从大多数功能转换为状态计算，或者声明类型)。|155610|SBCL有一个优秀的本机代码编译器.|155611|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1D|0|0|0|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|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|C]]]]

Here's an implementation of RK in Common Lisp:

<a href="http://github.com/bld/bld-ode/blob/master/rk.lisp" rel="nofollow noreferrer">http://github.com/bld/bld-ode/blob/master/rk.lisp</a>

The nice thing about Common Lisp is that you can start with simple and elegant code and then make the critical bits run fast (e.g. by switching from mostly functional to stateful computation, or by declaring types).

SBCL has an excellent native-code compiler.

blocks|key|155564|text|RK4是一种非常基本的方法，已经编写了许多优秀的实现。使用其中之一，并将您的精力花在项目的其他方面。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|155565|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

RK4 is a very basic method, and there lots of excellent implementations that are already written. Use one of them, and spend your effort on other aspects of the project.

blocks|key|155635|text|我不太熟悉Runge，但是OCaml可以提供良好的速度和可读性，至少如果你稍微小心的话。然后，对于应用程序的其余部分，您就有了一个健壮的静态类型系统的优势。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|155636|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I'm not familiar with Runge Kutta, but OCaml can provide good speed and readability in general, at least if you're a bit careful. You then have the advantage of a robust static type system for the rest of your application.

blocks|key|155654|text|除了其他任何东西，您还可以将OCaml绑定写入现有的C+runge-kutta解决程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|155655|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Apart from anything else, you can write OCaml bindings to your existing C runge-kutta solver.

blocks|key|1382578|text|很难说哪种语言是最简单的，有lisp、C%2B%2B、C#等库来实现这一点，所以如果它与个人喜好有关的话，那就很难说了。我推测Matlab是针对这些类型的任务而专门定制的最优雅的解决方案，它有很多支持ODEs.Lisp可能有点慢..。我不能代表OCaml说话。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1382579|entityMap|0|LINK|mutability|MUTABLE|url|http://common-lisp.net/project/gsll/|1|http://www.nr.com/com/storefront.html|2|http://numerical.codeplex.com/|3|http://www.mathworks.com/support/tech-notes/1500/1510.html^0|E|4|0|J|3|1|N|2|2|2M|6|3|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]|$A|Y|B|Z|1|10]|$A|11|B|12|1|13]]|C|$]]|$1|D|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]|P|$5|G|H|I|C|$J|Q]]]]

Its hard to say which language would be easiest, there are <a href="http://common-lisp.net/project/gsll/" rel="nofollow noreferrer">lisp</a>, <a href="http://www.nr.com/com/storefront.html" rel="nofollow noreferrer">C++</a>, <a href="http://numerical.codeplex.com/" rel="nofollow noreferrer">C#</a>, etc libraries to accomplish this, so alot if it has to do with personal preference. I would speculate Matlab is the most tailored and elegant solution specifically for these types of tasks, and it has a lot of <a href="http://www.mathworks.com/support/tech-notes/1500/1510.html" rel="nofollow noreferrer">built in support for ODEs</a>... Lisp may be on the slow side... and I can't speak for OCaml.

blocks|key|1382630|text|我建议使用python%2Bnumpy%2Bscipy，一般的数学和数字支持(超级多维数组)是很好的。无论如何，这取决于具体的需要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382631|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I would suggest using python+numpy+scipy, the general math and numeric support (superbe multidimensional arrays) is excellent. Anyway it depends on specific needs.

blocks|key|155493|text|Fortran或C可能需要查看NAG例程。C会更灵活，更容易理解，但是Fortran通常被认为是最适合数字的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|155494|entityMap|0|LINK|mutability|MUTABLE|url|http://www.nag.co.uk/numeric/numerical_libraries.asp^0|F|5|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]]]]

Fortran or C, might want to look into <a href="http://www.nag.co.uk/numeric/numerical_libraries.asp" rel="nofollow noreferrer">NAG routines</a>. C would be more flexible, and easier to understand, but Fortran is usually regarded as the best for numerics.

Which language would you propose for solving a system with:

<ul>
<li>first order differential equations</li>
<li>complex variables</li>
<li>N-dimensions </li>
</ul>

using 4th order Runge Kutta or the like.

Speed matters a lot but would sacrifice for:

<ul>
<li>Elegant (clean and short) code</li>
<li>Flexibility + scalability</li>
</ul>

I'm mostly between a Lisp and OCaml but any other suggestion is welcomed.

Thanks!

Lisp, OCaml or what for Runge Kutta?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

你会建议用哪种语言来解决一个系统的问题：一阶微分方程复变量N维使用四阶龙格库塔等。速度关系到的大容量()，但会牺牲：优雅(简洁和简短)代码灵活性+可伸缩性我主要是在Lisp和OCaml之间，但任何其他建议都是受欢迎的。谢谢!

问Lisp，OCaml，还是？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Lisp，OCaml，还是？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Lisp，OCaml，还是？
EN