pages tagged mathematica

Wolfram

Sat, 20 May 2017 21:53:47 +0000

Programming idioms

Caching the result of a time-comsuming computation in a symbol's `DownValue`

ClearAll[f]
f[x_] := f[x] = (Pause[5]; Print["Time consuming definition run!"]; 1);

In[31]:= DownValues[f]
Out[31]= {HoldPattern[f[x_]]:>(f[x]=(Pause[5];Print[Time consuming definition run!];1))}

In[32]:= f[1]//AbsoluteTiming//Timing
f[1]//AbsoluteTiming//Timing
During evaluation of In[32]:= Time consuming definition run!
Out[32]= {0.061456,{5.00291,1}}
Out[33]= {7.*10^-6,{1.*10^-6,1}}

In[34]:= DownValues[f]
Out[34]= {HoldPattern[f[1]]:>1,HoldPattern[f[x_]]:>(f[x]=(Pause[5];Print[Time consuming definition run!];1))}

Haskell and Wolfram Language syntax comparison

Fri, 19 May 2017 02:50:12 +0000

description	Haskell	Wolfram	comment
defining a named function with explicitly named arguments	`incrementInteger :: Int -> Int incrementInteger n = n + 1`	`incrementInteger[n_Integer] := n + 1;`
defining a named function with lambda expression	`incrementInteger :: Int -> Int incrementInteger = \n -> n + 1`	`incrementInteger = Function[{n}, n + 1];`
defining a function with a function name as one of the arguments	`Prelude> increment = \x -> x+1 Prelude> double = \x -> 2*x Prelude> thenDouble someFunc = double . someFunc Prelude> thenDouble increment 3 8`	`In[1]:= double = Function[x, 2x]; increment = Function[x, x + 1]; thenDouble[someFunc_] := Composition[double, someFunc]; In[4]:= thenDouble[increment] Out[4]= Function[x, 2 x]@Function[x, x + 1] In[5]:= (thenDouble[increment])[3] Out[5]= 8`
defining a function with locally definded intermediate functions	`Prelude> :{ Prelude> myFunc1 x = Prelude> let y = sin x Prelude> in cos y Prelude> :} Prelude> myFunc1 pi 1.0 Prelude> :{ Prelude> myFunc2 x = Prelude> cos y Prelude> where Prelude> y = sin x Prelude> :} Prelude> myFunc2 pi 1.0`	`In[1]:= myFunc[x_]:=With[{f=Sin[x]},Cos[f]] myFunc[Pi] Out[2]= 1`	Alternatively, instead of using `With` (for symbolic replacement), use `Module` (for lexical scoping) or `Block` (for dynamic scoping).

Wolfram Language (Mathematica) package structure

Tue, 16 May 2017 23:59:39 +0000

When creating a package in Wolfram Language (Mathematica), the typical structure looks like the following:

path/to/MyPackage/:

.
├── Documentation
│   └── English
│       ├── Guides
│       │   └── MyPackage.nb
│       ├── ReferencePages
│       │   └── Symbols
│       │       ├─── MySymbol1.nb
│       │       └─── MySymbol2.nb
│       └── Tutorials
|           ├── MyTutorial1.nb
│           └── MyTutorial2.nb
├── FrontEnd
│   ├── Palettes
│   │   ├── MyPalette1.nb
│   │   └── MyPalette2.nb
│   └── SystemResources
│       └── Bitmaps
│           └── MyPackage
│               ├── XXX.png
│               └── YYY.png
├── Kernel
│   ├── MyPackageFile1.wl
│   ├── MyPackageFile2.wl
│   ├── MyPackage.wl
│   └── init.m
├── PacletInfo.m
└── PacletInfoTemplate.m

Installing and configuring Mathematica

Tue, 16 May 2017 23:59:39 +0000

`$UserBaseDirectory/Kernel/init.m`

Make a symbolic link from a version controlled init.m to $UserBaseDirectory/Kernel/init.m. It 1) defines some environment variables such as

SetEnvironment["$DropboxDirectory" -> FileNameJoin[{$HomeDirectory, "Dropbox"}]]

and 2) loads some packages that I use frequently enough that loading them every time is convenient:

<< meng`

`$UserBaseDirectory/SystemFiles/FrondEnd/Stylesheets`

Make a symbolic link from a version controlled directory of stylesheets path/to/Stylesheets/ to $UserBaseDirectory/SystemFiles/FrondEnd/Stylesheets so your own stylesheets is readily accessible from menu Format > Stylesheets and you can keep them update-to-date with its version control repository.

Install SSL certificates

Sometimes, in order to operate with some Web sites with functions like URLFetch, additional SSL certificates associated with the site needs to be appended in

FileNameJoin[{$InstallationDirectory, "SystemFiles", "Links", "HTTPClient", "SSL", "cacert.pem"}]

This will allow HTTPClient to use the SSL certificate for authentication.

`FrequentlyRunCommands.nb`

I have a notebook where I record all the frequently run commands for quick reuse. It can be set to automatically open when Mathematica starts.

Format → Option Inspector
choose "Global Preference"
Global Options → File Locations → AutoOpenNotebooks
Set value to "/path/to/notebook.nb"; separate notebooks by linebreaks

Preferences

Mail server

Preferences > Internet Connectivity > Mail Settings.

Interface

Preferences > Interface > Show open/close icon for cell groups

Uninstalling

See Wolfram documentation.

When having multiple versions installed, to uninstall one of them, delete

/usr/local/Wolfram/Mathematica/VERSION

Replace VERSION with the version number you would like to delete.

Munging style for Mathematica code layout

Tue, 16 May 2017 23:59:39 +0000

This is a description to a programming and code formatting style for Mathematica programs that I call "munging style code layout".

Any self-contained part of a Mathematica program is a Mathematica expression. As the oft-mentioned idiom said, in Mathematica, "everything is an expression". The appearance of a Mathematica expression is function[arg1, arg2, ...] ("functions", composite expressions) or simply foobar ("symbols", atomic expressions). This is true for any part of a Mathematica program at any depth.

Any Mathematica function is essentially a nested structure of the above building blocks. Complex Mathematica program tends to have deeply nested expressions like

f4[arg41, f3[arg31, arg32, f2[arg21, f1[input], ...], ...], arg43, ...] (* comment explaining what f1, f2, f3, f4 does *)

Imagine a complex Mathematica program having hundreds of above expressions, sometimes nesting each other. It is hard to read or understand code formatted this way because one needs to constantly jumping out and back into the brackets [ ... ]. This is a stack) data structure stored in one's brain that one has to frequently navigate.

Over the time I have gradually established a particular formatting style for complex Mathematica functions with such deep nested structure. I think it helps writing and understanding my Mathematica programs. I call it munging style code layout. It's nothing but putting small parts of the code onto separate lines and use Composition to chain them up:

Composition[
    f4[arg41, #, arg43, ...]&, (* comment for what f4 does *)
    f3[arg31, arg32, #, ...]&, (* comment for what f3 does *)
    f2[arg21, #, ...]&, (* comment for what f2 does *)
    f1 (* comment for what f1 does *)
][input]

I call it munging because it overall operates on a compact initial input argument, typically represented by a Mathematica symbol, and process it step by step and little by little, for multiple steps before returning a final desired output.

This way of laying out the code has a few advantages:

The program body will spread out to multiple lines naturally according to each step's logic. The code is still logically nested, but not visually nested.
Each munging step can be commented at the end of line, so it's easier to write and read the comment. One line of code is structurally and logically simple, so each line's comment will be short too. As a result, the comments for the complete program should also be easier to read and understand.
It is easier to write and debug code. A typical scenario is

Write the first simple step

Composition[ 
    f1[arg11, #, arg13]& (* comment for what f1 does *)
][input]

Run it and verify the first step does what it should do, then add a second step, and comment as you code:

Composition[ 
    f2[arg21, #, ...]&, (* comment for what f2 does *)
    f1[arg11, #, arg13]& (* comment for what f1 does *)
][input]

Notice, when writing the body of f2[...], one needs not to edit around f1[....], but on a separate new line. This may not sound like a big deal, but, according to my personal experience, it eliminates a lot of chances of messing up with f1[...] when typing f2[...]. If one decides the f2 just typed down shouldn't stay, he can just simply select the whole line of of f2 -- typically a keyboard-only operation or a mouse-only operation depending on the programmer's habit and the editor -- and delete it without worrying about messing up any part of f1[...] or needing to copy f1[...] out safely. So there is an ergonomic advantage to separate f1[...] and f2[...] into different lines. You write your code in small chunks, and manage the chunks as compositing terms of the entire logic.

In addition, one can easily print out the intermediate value in-between two steps by simply inserting a NOP step:

Composition[ 
    f2[arg21, #, ...]&, (* comment for what f2 does *)
    (Print@#; #)&,  (* NOP step to print out intermediate value for debugging *)
    f1 (* comment for what f1 does *)
][input]

When you have more steps added, you might find the first few steps aren't perfect, now you can insert NOP step to print out more intermediate values:

Composition[
    ...,
    f4[arg41, #, arg43, ...]&, (* comment for what f4 does *)
    (Print@#; #)&,
    f3[arg31, arg32, #, ...]&, (* comment for what f3 does *)
    (Print@#; #)&,
    f2[arg21, #, ...]&, (* comment for what f2 does *)
    f1 (* comment for what f1 does *)
][input]

Notice inserting these NOP steps again doesn't require editing at lines of the actual code (f1[...]&, f2[...]&, ...). So there is natural and convenient separation of debugging code and real code.

All of this may appear to be too trivial a matter to document. But I found Mathematica code is harder to format than most other programming languages, partially because the character of Mathematica language (functional and symbolic) and partially because neither Mathematica notebook nor Wolfram Workbench provides sophisticated and robust automatic code formatting/indentation. This little formatting rule seems to help me writing better Mathematica code, sometimes also faster and easier in doing so.

Munging data streams with functional programming and lambda expressions in Java 8

use cheaper functions when possible

Tue, 16 May 2017 23:59:39 +0000

Mathematica is functional and has high code density. It tends to lead one to use more powerful function than the task really necessarily requires. Because high code density typically means it needs to check many things to figure out default (or Automatic) values, it slows down the program unnecessarily sometimes.

`Join` vs. `Flatten`

Use Join to join lists, not Flatten, if you know it's safe. Join is faster and uses less memory.

In[6]:= Quit[]
In[1]:= data=Table[RandomVariate[NormalDistribution[],100],{20}];
In[2]:= m1=MemoryInUse[];
Do[t=Flatten[data,1],{10000}]//AbsoluteTiming
m2=MemoryInUse[];
m2-m1
Out[3]= {3.9662268,Null}
Out[5]= 74704

Compare it to

Join@@list
In[2]:= m1=MemoryInUse[];
Do[t=Join@@data,{10000}]//AbsoluteTiming
m2=MemoryInUse[];
m2-m1
Out[3]= {0.1730099,Null}
Out[5]= 36240

White space characters in Wolfram Language / Mathematica

Tue, 17 Mar 2015 06:50:27 +0000

In Wolfram Language / Mathematica, there are the following escaped characters that end with Space:

$WhiteSpaceCharacters = {
"\[AutoSpace]",
"\[COMPATIBILITYKanjiSpace]",
"\[InvisibleSpace]",
"\[LetterSpace]",
"\[MediumSpace]",
"\[NegativeMediumSpace]",
"\[NegativeThickSpace]",
"\[NegativeThinSpace]",
"\[NegativeVeryThinSpace]",
"\[NonBreakingSpace]",
"\[RawSpace]",
"\[ThickSpace]",
"\[ThinSpace]",
"\[VeryThinSpace]"
}

These can be found by evaluating ?\[*Space] in a Mathematica notebook.

To actually obtain these in copiable text was not straightforward for me as I did not find a programmable way to generate the above list. Instead, I copied the cell expression out (by selecting the output cell, pressing Ctrl+Shift+E, and copying out the text), and then run ack to extract any strings that start is sandwiched with \[ and ]:

17:09:43 meng@meng2maclap:~/Temp$ ack -o "\\\\\\\\\[.*Space\]" cellexpr.txt | sort | uniq

AutoSpace
COMPATIBILITYKanjiSpace
InvisibleSpace
LetterSpace
MediumSpace
NegativeMediumSpace
NegativeThickSpace
NegativeThinSpace
NegativeVeryThinSpace
NonBreakingSpace
RawSpace
ThickSpace
ThinSpace
VeryThinSpace

Curiously, only \[AutoSpace], \[NonBreakingSpace], \[RawSpace] satisfy StringMatchQ[#, RegularExpression["[[:whitespace:]]"]]&.

See the CDF file for details.

Wolfram-related Twitter accounts and the alike

Sat, 07 Mar 2015 02:37:38 +0000

news, blogs, comprehensive
- Wolfram: @WolframResearch
- Wolfram Japan: @WolframJapan
- Wolfram China: @WolframChina
- Wolfram Education: @WolframEdu
- Wolfram Careers: @WolframCareers
- Stephen Wolfram: @stephen_wolfram
- Conrad Wolfram: @conradwolfram
- Wolfram NKS: @WolframNKS
- Wolfram Blog
- Stephen Wolfram Blog
Wolfram Language / Mathematica
- MathematicaTip: @MathematicaTip
- Mathematica SE: @StackMma
- Tweet-a-Program: @wolframtap, archive on Tumblr
- Mathematica Cookbook: @salmangano
- Wolfram Tip: @WolframTip
- Sina Weibo:
  - 面向教育的Mathematica: @面向教育的Mathematica
  - Mathematica_李想: @Mathematica_李想
  - Mathematica 中文使用者: @Mathematica中文使用者
  - Wolfram 语言编程珠玑: @WolframTip
- Mathematica StackExchange community blog
Wolfram|Alpha
- Wolfram|Alpha: @Wolfram_Alpha
- Wolfram Fun Facts: @WolframFunFacts
- Wolfram|Alpha Can't: @wacnt
- WolframAlpha queries: @WA_queries
- Wolfram_Alpha: @Wolfram_Alpha
- Wolfram|Alpha Tumblr
- Wolfram|Alpha blog

pages tagged mathematica

Wolfram

Programming idioms

Caching the result of a time-comsuming computation in a symbol's DownValue

Haskell and Wolfram Language syntax comparison

Wolfram Language (Mathematica) package structure

Installing and configuring Mathematica

$UserBaseDirectory/Kernel/init.m

$UserBaseDirectory/SystemFiles/FrondEnd/Stylesheets

Install SSL certificates

FrequentlyRunCommands.nb

Preferences

Mail server

Interface

Uninstalling

Munging style for Mathematica code layout

use cheaper functions when possible

Join vs. Flatten

White space characters in Wolfram Language / Mathematica

Wolfram-related Twitter accounts and the alike

Caching the result of a time-comsuming computation in a symbol's `DownValue`

`$UserBaseDirectory/Kernel/init.m`

`$UserBaseDirectory/SystemFiles/FrondEnd/Stylesheets`

`FrequentlyRunCommands.nb`

`Join` vs. `Flatten`