pages tagged programming

Nesting bullet lists in footnotes

Mon, 11 May 2020 18:19:21 +0000

Test paragraph¹. Another sentence and some² word.

Footnote text
- One
- Two
More text.
```
Code block.
```
↩
Footnote text
- One
- Two
More text.
```
Code block.
```
↩

Haskell

Sat, 13 Oct 2018 03:56:52 +0000

Journal

Entering multi-line code in GHCi

Use :{ and :} to sandwich a block of code consisting of multiple lines:

Prelude> :{
Prelude| incrementInteger :: Int -> Int
Prelude| incrementInteger x = x + 1
Prelude| :}
Prelude> incrementInteger 1
2

Using the latest released version of GHC with stack

Specify the version of LTS (i.e. Long Term Support) Haskell to use by default in `$HOME/.stack/global-project/stack.yaml:

resolver: lts-8.15

As of May, 2017, the newest released version of LTS Haskell is 8.15. This version number can be found on https://www.haskell.org/downloads.

`data`, `type`, and `newtype`

https://stackoverflow.com/a/33316715

In GHCi, print the type of a symbol

  Prelude> :type Nothing
  Nothing :: Maybe a
  Prelude> :type (+)
  (+) :: Num a => a -> a -> a
  Prelude> :type print "Hello World"
  print "Hello World" :: IO ()

`Nothing` and `Maybe`

Partial application

Functions are not partial, but rather a function can be applied partially.

Function type decalaration

myFunc :: type1 -> type2 -> type3 -> type4

Pure as in 'pure functional programming languages'

Get information about a Haskell word in GHCi

Prelude> :info pure
class Functor f => Applicative (f :: * -> *) where
  pure :: a -> f a
  ...
    -- Defined in ‘GHC.Base’

Concatenating multiple strings into one using `intercalate`, `intersperse` and `concat`, and `unword`.

Function application takes precedence over any binary operator.

For example,

ourPicture = colored green (solidCircle 1) & solidCircle 2

is equivalent to

ourPicture = (colored green (solidCircle 1)) & (solidCircle 2)

Changing a prefixing function to an infix binary operator

Prelude> mod 3 2
1
Prelude> 3 `mod` 2
1

Largest integer

Prelude> :{
Prelude| myInt :: Int
Prelude| myInt = 2^63 - 1
Prelude| :}
Prelude> myInt
9223372036854775807
Prelude> myInt + 1
-9223372036854775808

Prelude> :{
Prelude| minInt :: Int
Prelude| minInt = - 2^63
Prelude| :}
Prelude> minInt
-9223372036854775808
Prelude> minInt - 1
9223372036854775807

Arithmetic expression with different types of numbers

Prelude> :{
Prelude| d :: Double
Prelude| i :: Int
Prelude| d = 1.2
Prelude| i = 1
Prelude| :}
Prelude> d+i

<interactive>:48:3: error:
    • Couldn't match expected type ‘Double’ with actual type ‘Int’
    • In the second argument of ‘(+)’, namely ‘i’
      In the expression: d + i
      In an equation for ‘it’: it = d + i
Prelude> d + fromIntegral i
2.2
Prelude>

References

https://www.stackage.org
- Lookup basic information about a word, e.g. pure: https://www.stackage.org/lts-8.15/hoogle?q=pure

Haskell

Sat, 13 Oct 2018 03:56:52 +0000

Misc

http://tryhaskell.org

Softwares

IDE's

http://code.world/haskell, an online IDE to write and run Haskell code, e.g. https://code.world/haskell#Ptxn0dmOwm9z1xqIGrwPfzQ.

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).

《Learn You a Haskell for Great Good!》 study note

Thu, 18 May 2017 23:35:08 +0000

Introduction

Haskell is a purely functional programming language.
"In purely functional programming you don't tell the computer what to do as such but rather you tell it what stuff is. … You express that in the form of functions. … "
A Haskell function cannot have side effects other than mapping its input to an output as a mathematical function.
Haskell is lazy in that it does not compute anything until it have to in order to return a value.
Haskell is statically typed.
- Type inference allows deducing the appropriate type automatically by inference on compatibility between the inputs and outputs.

Starting out

Ready, set, go!

ghci: The Glorious Glasgow Haskell Compilation System. Environment to interactively compile and run Haskell programs. Exit GHCi using :quit. GHCi documentation.
Not-equal operator: /=.
Compile-time error on incompatible types: 123 + "foobar"
Compile a program: ghci> l:myprogram.hs.
' is allowed in function name, e.g. foo'Bar is a valid function name.
Function names cannot begin with a lower-case letter.

An intro to lists

In Haskell, a strings is a lists of characters.
List and tuple syntax difference: [1, 2], (1, "foobar"). A tuple can contain elements of different types, while a list cannot. This bears some similarity with Python's lists and tuples. A difference is that in Python, lists are mutable but tuples are not.
Concatenate operation: [1, 2] ++ [3, 4], "foo" ++ "bar", ['a', 'b'] ++ ['c', 'd'].

[https://en.wikipedia.org/wiki/Cons cons] operation ::

  Prelude> 'f' : "bar"
  "fbar"
  Prelude> 1: [3, 4]
  [1,3,4]
  Prelude>

If "XXX...XXX" is a very long string, "XXX...XXX" ++ "foobar" will be slow.
[1, 2, 3] equals 1 : 2 : 3 : [].
Take parts of a list: [1, 3, 5, 7] !! 2 returns 5. Haskell lists uses zero-based numbering. take 2 [1, 3, 5, 7] gives the third element 5. drop 2 [1, 3, 5, 7] gives [1, 3, 7]. Compare this to Mathematica {1,3,5,7}<span class="createlink">3</span>, Take[{1,3,5,7}, {3}], Drop[{1,3,5,7}, {3}].
Test element membership in a list: elem 3 [2, 4, 6] and 2 \elem` [1, 3, 5, 7]`.
[[1, 2], ["foo", "bar"]] is invalid as the types of the elements of the two sub-lists are not same.
Lists compare in lexicographical order. E.g. [1, 3, 4] < [1, 4, 2].
head [1, 2, 3], tail [1, 2, 3], init [1, 2, 3], last [1, 2, 3]. Compare with Mathematica / Wolfram Langauge namings: First[{1,2,3}], Rest[{1,2,3}], Most[{1,2,3}], Last[{1,2,3}]
null [1, 2, 3], null []

Other side notes

One of the key features and advantanges of Haskell is its purity: all side-effects are encapsulated in a monad.
[https://en.wikipedia.org/wiki/Algebraic_data type Algebraic data type]:

data List a = Nil | Cons a (List a)

data Tree = Empty | Leaf Int | Node Tree Tree

Tree is a sum data type a.k.a. tagged union.

Tree is a recursive data type.

Pattern matching in Haskell:

  depth :: Tree -> Int
  depth Empty = 0
  depth (Leaf n) = 1
  depth (Node l r) = 1 + max (depth l) (depth r)

References

https://ghcformacosx.github.io/
Search a Haskell function by desired type signature, e.g. https://www.haskell.org/hoogle/?hoogle=String+-%3E+Int (And the desired function for turning an object to a String is possibly read :: Read a => String -> a).

Python division

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

In Python 2, dividing two integers will yield a rounded integer result:

$ ipython2
Python 2.7.11 (default, Jan 22 2016, 08:29:18)
Type "copyright", "credits" or "license" for more information.

IPython 4.1.2 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: 1/2
Out[1]: 0

To get a real-number result:

In [2]: 1./2
Out[2]: 0.5

In [3]: float(1)/2
Out[3]: 0.5

In Python 3, the default is the real-number result:

$ ipython
Python 3.5.1 (default, Dec  7 2015, 21:59:10)
Type "copyright", "credits" or "license" for more information.

IPython 4.1.2 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [2]: 1/2
Out[2]: 0.5

In [3]: exit
>>> elapsed time 15s

In a Python script, to use Python 3 division behavior for Python 2:

import from __future__ division;
print 1/2

Drawing polyhedra with textured faces in Mathematica

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

In Mathematica and Wolfram Language, with the feature called Texture it's easy to draw 3D solids such as polyhedra with image textures on the surface such as the faces of polyhedra. When playing with this, I drew a rhombic hexecontahedron (properties), the logo of Wolfram|Alpha with national flags on its faces:

☝ Rhombic hexecontahedron wrapped with the 60 most populous countries' national flags, one different flag drawn on each of the 60 rhombic faces. (It's somewhat odd that the most populous countries happen to have a lot of red and green colors in their national flags.)

The code is in my Git repository.

Remarks:

It was a bit tricky to understand what the option VertexTextureCoordinates is and does, and how to set it up for what I'm trying to draw. It turns out for putting the national flags on the faces of a rhombic hexecontahedron, since both are (usually) isomorphic to a square, VertexTextureCoordinates -> {{0, 0}, {1, 0}, {1, 1}, {0, 1}} is would work as it aligns the four vertices of a rectangular flag to the four vertices of a rhombic face.

Something left to be improved:

Avoid flags that's not isomorphic to the face of the given polyhedron;
Compute the suitable values of VertexTextureCoordinates to reduce or even avoid distortion of the flags;
Find a reasonable way to align national flags of shapes not isomorphic to the shape of a face of a given polyhedron, such that the main feature of the national flag wrapped on a polyhedron face is well recognizable.

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

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

With the advent of Java 8 and java.util.stream and lambda expressions in it, one can do data munging in Java 8 as the following:

Java 8:

public static void main(String[] args) {

    HashMap<Integer, Character> nucleobases = new HashMap<> ();
    nucleobases.put(1, 'A');
    nucleobases.put(2, 'G');
    nucleobases.put(3, 'T');
    nucleobases.put(4, 'C');


    range(0, 100)
            // generate a stream containing random strings of length 10
            .mapToObj(i -> randomNucleicAcidSequence(new Random(), nucleobases, 10))
            // sort the elements in the stream to natural ordering
            .sorted()
            // group strings into sub-lists and wrap them into a stream
            .collect(groupingBy(name -> name.charAt(0)))
            // print each sub-list's common initial letter and the constituent strings
            .forEach((letter, names) -> System.out.println(letter
                    + "\n\t"
                    + names.stream().collect(joining("\n\t"))));
}

public static String randomNucleicAcidSequence(Random r, Map<Integer, Character> map, int length) {
    return r.ints(1, 4).limit(length).mapToObj(
            x -> Character.toString(map.get(x))).collect(Collectors.joining());
}

↑ Code in GitHub

This is remarkbly similar to a program written in Mathematica using the munging style I use all the time:

(* There is not a built-in RandomString[…] *)
nucleobases = {"A", "G", "T", "C"};

randomNucleicAcidSequence[length_Integer] := StringJoin[nucleobases[[#]] & /@ RandomInteger[{1, 4}, length]]

Composition[
    Print[StringJoin[{#[[1]],":\n",StringJoin[Riffle[#[[2]],"\n"]]}]]& /@ # &,
    (First[Characters[Part[#, 1]]]-> #) & /@ # &,
    GatherBy[#, First[Characters[#]]&]&,
    Sort,
    Map[Function[{i}, randomNucleicAcidSequence[10]], #] &
][Range[0, 100]]

The output of both program print the mucleic acid sequences grouped by initial neuclobase:

A:
AAAATACCTC
AAATAATCAT
AACAGATACG
ACAACTACGG
ACCATCAAAT
...
C:
CAACGGGGTT
CAAGAAGAGC
CACACCCACA
CACACTCTAC
CAGGACCGGA
...
G:
GAACGTTTCA
GAACTAAGCG
GACCAGTTCT
GAGAACACGT
GAGCCGCCAC
...
T:
TAAAATTGCC
TAAGGTGAGG
TAGCCGGTTA
TAGGCGGTGA
TAGTTCGAGC
...

Data streams and algorithms for processing them is a recently hot research area in computer science. It seems to me it will be natural for Java standard library to include more and more stream algorithms in future.

Munging style for Mathematica code layout

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

pages tagged programming

Nesting bullet lists in footnotes

Haskell

Journal

Entering multi-line code in GHCi

Using the latest released version of GHC with stack

data, type, and newtype

Nothing and Maybe

Partial application

Function type decalaration

Pure as in 'pure functional programming languages'

Get information about a Haskell word in GHCi

Concatenating multiple strings into one using intercalate, intersperse and concat, and unword.

Function application takes precedence over any binary operator.

guard

Changing a prefixing function to an infix binary operator

Largest integer

Arithmetic expression with different types of numbers

References

Haskell

Misc

Softwares

IDE's

Wolfram

Programming idioms

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

Haskell and Wolfram Language syntax comparison

《Learn You a Haskell for Great Good!》 study note

Introduction

Starting out

Ready, set, go!

An intro to lists

Other side notes

References

Python division

Drawing polyhedra with textured faces in Mathematica

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

Munging style for Mathematica code layout

`data`, `type`, and `newtype`

`Nothing` and `Maybe`

Concatenating multiple strings into one using `intercalate`, `intersperse` and `concat`, and `unword`.

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