Mathematica高级编程深入指南

需积分: 9 4 浏览量更新于2024-07-22 收藏 3.33MB PDF 举报

"Mathematcia Programming Advanced Introduce - 由Leonid Shifrin编写的Mathematica高级编程介绍，涵盖核心语言部分，基于Creative Commons许可的著作。" Mathematica编程高级介绍是一本由Leonid Shifrin编写的经典教材，专注于Mathematica的高级编程概念。这本书分为几个部分，旨在帮助读者深入理解Mathematica的核心语言和编程技巧。第一部分：核心语言在这一部分中，作者首先阐述了Mathematica编程的第一个基本原则，即一切都是表达式。这包括： 1.1.1 原子和内置的AtomQ谓词：在Mathematica中，所有数据都是由基本的不可分解单元——原子组成的。AtomQ函数用于判断一个对象是否是原子，这是理解Mathematica数据结构的基础。 1.1.2 Mathematica的正常（复合）表达式：除了原子，Mathematica的表达式是由更复杂的结构组成，这些结构可以是函数调用、列表、规则等。这些表达式构成了Mathematica计算的基础。 1.1.3 内置函数的字面等价物和操作：书中讨论了如何表示和使用内置函数的字面形式，这对于理解和自定义函数行为至关重要。书中还涵盖了其他主题，如表达式的结构、模式匹配、函数的定义和调用、变量作用域、控制流结构、错误处理以及数据结构，如列表、关联数组和图形。此外，它可能还包括数学运算、符号计算、数值计算、可视化和动态界面创建等内容。作者Leonid Shifrin是一位资深的Mathematica专家，他在Brunel University工作，并通过他的电子邮件地址（leonid@mathprogramming-intro.org）与读者保持联系。书中的内容经过他的数字签名确认，确保了内容的完整性和权威性。这本书遵循Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License，意味着读者可以自由地分享、复制和改编内容，但不能用于商业目的，且需保持作者的署名权。 "Mathematcia Programming Advanced Introduce" 是一本面向进阶用户的Mathematica编程指南，通过深入解析核心语言和编程技术，帮助用户充分利用Mathematica的强大功能进行复杂计算和数据分析。



5.3.1.2 Imitating Thread..............................................................................................................257



5.3.1.3 Performance study: redoing the Mapping-a-function-with-several-arguments ..............258

example with Thread



5.3.1.4 Performance study: redoing a supplying-function-arguments example with Thread .....259



5.3.1.5 Simple encoding - using Thread to create a list of rules................................................260



5.3.1.6 Unsorted union problem revisited ................................................................................262



5.3.2.4.1 Replacing the main diagonal in the square matrix........................................................269



5.3.2.4.2 Appending sublists of a nested list.................................................................................271

 5.3.2.4.3 Deleting from each sublist of a nested list given number of elements at the.................272

beginning

 5.3.2.4.4 A digression : stricter error - checking............................................................................273



5.3.2.4.5 Rotating each sublist in a nested list differently.............................................................274



5.3.2.4.6 Imitating Transpose.......................................................................................................275



5.3.3.2 Imitating Inner................................................................................................................277



5.3.3.3 Creating a list of rules....................................................................................................277



5.3.3.4 Comparing two lists......................................................................................................278



5.3.3.5 Reconstructing a number from its factorized form.........................................................279



5.3.4.3 Binary numbers..............................................................................................................281



5.3.4.4 Table of values for trigonometric functions....................................................................281



5.3.4.5 Creating interpolations for functions of several variables..............................................282



5.3.4.6 Imitating Outer..............................................................................................................285



5.4.1.4 Imitating Nest................................................................................................................293



5.4.1.5 Approximating the square root of a number.................................................................294



5.4.1.6 Generating Hermite polynomials...................................................................................296



5.4.2.3 Restricted random sequences.......................................................................................303



5.4.2.4 Visualizing poker probabilities.......................................................................................304



5.4.2.5 Generating distinct random numbers............................................................................307



5.4.2.6 The Collatz problem......................................................................................................309



5.5.2.1 Partial sums revisited....................................................................................................320



5.5.2.2 Position intervals for list splitting...................................................................................321



5.5.2.3 Splitting the list into sublists of specified lengths (generalized Take operation)...........321



5.5.2.4 Imitating a factorial function..........................................................................................322



5.5.2.5 Imitating FromDigits......................................................................................................323



5.5.2.6 Powers of a differential operator..............................................................................324



5.5.2.7 Autocorrelated random walks..................................................................................325



5.5.2.8 Linked lists and the fast accumulation of results.....................................................327



5.5.2.9 Joining linked lists....................................................................................................329



5.5.3.1 Random changes in the list......................................................................................330



5.5.3.2 Running standard deviation for an increasing or running list of data .....................331



5.6.2 The Collatz problem revisited...................................................................................342



5.6.4 Deleting numbers from the list revisited...................................................................343



5.6.5 Approximating the square root of a number revisited...............................................344



5.6.8 Local (relative) maxima in a list revisited .................................................................348



5.7.1.4 Picking list elements randomly with prescribed probabilities....................................351

Case studies



4.7.6 Changing the weights of words.......................................................................................176



5.3.2.3 Checking lists for equality...............................................................................................265



5.3.4.7 Creating ordered subsets for a given set........................................................................286



5.4.1.7 Sorting a list of numbers.................................................................................................297



5.4.2.7 Automatic and programmatic construction of patterns - patterns for poker ...................311

combinations revisited (not NestWhile - related)



5.4.2.8 Fibonacci numbers.........................................................................................................314



5.5.4 Gram - Schmidt orthogonalization..................................................................................333



5.5.5 Local maxima for a list....................................................................................................339



5.6.7 Merging overlapping intervals - Functional vs. Rule-based............................................345



6.2 Checking if a square matrix is diagonal..........................................................................355



6.3 Extracting matrix diagonals.............................................................................................362



6.4 Generating complex random Wishart matrices...............................................................376



6.5 Sorting, mapping and membership tests.........................................................................381

Preface



The history of this project

I started using Mathematica about 10 years ago for my Masters thesis. Since then, I have been using it

occasionally during my PhD, until about 3 years ago. At that point, just for curiosity, I tried to use Mathe-

matica for a small side project which had nothing to do with the field of my professional activity

(theoretical physics). And then, I have suddenly discovered that behind all the built - in commands and

simple procedural programming constructs there is a much more powerful programming language (the

fact of course well-known by then to lots of people, but not to me). I was hooked and spent some time

experimenting with its different features and then read a few books to get a deeper insight into it. At that

time, it was mostly for my own amusement, since ways in which I used Mathematica professionally did

not require even a fraction of the full power of this language. However, the character of my work has

changed since, and it’s been about one and a half years now that I use Mathematica heavily on a daily

basis and very frequently need the full power it can give me, in terms of speed, numerical and symbolic

capabilities. And I can safely say that without the knowledge of how to program in it properly, most of my

recent scientific results would be a lot harder to get. At some point, I decided to create some notes on

Mathematica programming, mainly for myself, and also to somehow organize the code that I have accumu-

lated so far for various projects. But as the notes started to expand, it occurred to me that with some more

effort I could convert them into a text possibly useful for other people. So, that’s how it started.



The audience for this book

When writing this book I mostly had in mind people who want to understand Mathematica program-

ming, and particularly those Mathematica users who would like to make a transition from a user to a

programmer, or perhaps those who already have some limited Mathematica programming experience but

want to improve their command of the system. Expert Mathematica programmers will probably find little

new information in the book - may be, the last chapter could be of some interest to them.

The first part of the audience for this book are scientists who would like to understand Mathematica

programming better, to take advantage of the possibilities it offers. The second part are (software) engi-

neers who may consider Mathematica as a tool for a prototype design. In this context, Mathematica can

serve as a tool of "experimental programming", especially useful in projects where some non-trivial

computations/research have to accompany programming.



Why Mathematica?

At the end of the day, there is nothing that can be done in Mathematica and absolutely can not be done in

other programming environments. For many problems however, especially those involving symbolic

programming, solving a problem in a language such as C or C++ will be eventually equivalent to reimple-

menting a subset of Mathematica (or other system for symbolic manipulations) needed to solve the

problem. The point is that many things are done in Mathematica with less or a lot less effort and time,

because a lot of both generic and specific functionality is already built in Mathematica. And because it is

so general, I expect this statement to be true for almost any field where some computations, prototype or

program design and development, simulations etc are used. Mathematica seems to be an ideal tool for

development of toy - models, prototypes, or just ideas. While Mathematica may be also quite useful for

validating some ideas or solutions, as well as to power some quite complex technologies also in their final

form, my feeling is that it may be most useful as a tool of experimental research (or programming), where

the answer (or design) is not known in advance.

For the scientific part of my audience, it is probably easier to argue in favour of Mathematica, since the

end product in science is usually a solution of certain problem, and Mathematica serves as a tool of

research. Its value here is that it has many built-in functions and commands which allow to do a lot of

things quickly.

On the other hand, there are many great programming languages, environments and tools. Many of them

have an added advantage of being free and open source. For the programming and prototype design

purposes, one may well question the advantages of using a proprietary software, which also is intrinsically

built in a way that does not allow to make an executable directly (it would require to package the entire

kernel together with your code and lead to a very large size of an executable. The Mathematica Player

technology seems to be a step in this direction).

Here are 10 good reasons to use Mathematica:

1. Multiparadigm language: the richness of the language allows to pick for any problem a programming

paradigm or style which corresponds to it most directly. You spend most of the time thinking about the

problem rather than implementation. The very high level of the language means that a lot of work is done

for you by the system.

2. Interactivity. Mathematica is an interpreted language, which allows interactive and incremental pro-

gram development. The Mathematica front - end adds another layer of interactivity, being able to display

various forms of input and output (and this can be controlled programmatically). Yet another layer of

interactivity is added by many new features of version 6.

3. Programming in the large. The typically small size and high level of abstraction of the code allows a

single person to manage substantial projects. There is also a built-in support for large projects through the

system of packages.

3. Built-ins. Availability of thousands of built-in functions makes it possible to do sophisticated analysis

very quickly. Extended error message system (each built-in function can issue a lot of error messages on

improper inputs) greatly simplifies debugging.

4. Genericity, higher-order functions and tight system integration. The very general principles of Mathe-

matica, its uniform expression structure, generic nature of many built-in functions, and tight integration of

all components allows to use all other built-in functions much easier than one would use libraries in other

languages. The Help system is also uniform and it is immediate to learn the functionality of any built-in

function that you have never used before.

4. Genericity, higher-order functions and tight system integration. The very general principles of Mathe-

matica, its uniform expression structure, generic nature of many built-in functions, and tight integration of

all components allows to use all other built-in functions much easier than one would use libraries in other

languages. The Help system is also uniform and it is immediate to learn the functionality of any built-in

function that you have never used before.

6. Visualizations. Great dynamic and visualization capabilities (especially in version 6).

7. Cross-platform. The Mathematica code developed in one environment or OS will work in exactly the

same way in all others where Mathematica is available.

8. Connectivity: the developers keep increasing the number of file formats which Mathematica can

understand and process. Also, tools like MathLink , J/Link , database connectivity etc. allow one to con-

nect Mathematica to external programs

9. Backward compatibility: since the version 1 and up to these days developers are careful to maintain

very high level of backwards compatibility. This means that one should not worry too much that solutions

developed in the current version will need a rewrite to work on the future versions (apart from possible

improvements related to availability of new built - in functions, if one is so inclined).

10. Support for parallel and distributed computing.

In addition to this, version 6 front - end contains a built - in mini - IDE (text highlighting which is aware of

the syntax of built - in commands, allows to automatically track scope of variables, etc.; package creating

and testing greatly simplified; interactive debugger). These features make version 6 a full-blown develop-

ment environment - I personally found it much more fun to develop code in it than in the previous ver-

sions. Also, there is Eclipse - based Wolfram Workbench IDE for development of larger projects.



The choice of the material

Since the first part of the tutorial is devoted to the core language of Mathematica (or, if you wish, impor-

tant built - in commands), the choice of material and even examples in this part are necessarily mostly

"standard". This means that there will be a lot of overlaps with many existing sources, and many things are

actually explained in much more detail elsewhere. I have included small discussions of some tidbits based

on personal experience with certain specific cases, where I felt appropriate.

One more comment due here is that I made an emphasis on the functional subset of Mathematica lan-

guage, which means that the book is geared more towards software development. The rule - based

approach is covered but perhaps under - represented, which I hope to remedy in the next part (s) of this

tutorial. Here I just want to emphasize that while the functional layer of Mathematica is nice for writing

fast and compact programs, it is the rule-based engine that gives Mathematica real uniqueness, power and

generality.

剩余407页未读，继续阅读

MathematicMatrix

粉丝: 0
资源: 4

Mathematica高级编程深入指南

Mathematica programming: an advanced introduction

Advanced ABAP Programming for SAP

Introduce to Java Programming 8th

怎么定义introduce方法

用C#定义一个抽象类Person，其包含抽象的Introduce方法。定义一个Student类，继承Person类，并实现Introduce方法。

用c#定义一个抽象类Person，其包含抽象的Introduce方法。定义一个Student类，继承Person类，并实现Introduce方法。

用c# 定义一个抽象类Person，其包含抽象的Introduce方法。定义一个Student类，继承Person类，并实现Introduce方法。

怎么定义introduce myself 方法

需要有一个Introduce类，在此类里调用对象实现输出

最新资源