In [1]:

```
/// Setup MathJax and HTML helpers
@"<script src=""https://raw.githubusercontent.com/mathjax/MathJax/master/latest.js?config=TeX-AMS-MML_CHTM""></script>" |> Util.Html |> Display
let html x = { Html = x }
let h1 text = { Html = "<h1>" + text + "</h1>" }
let h2 text = { Html = "<h2>" + text + "</h2>" }
let h3 text = { Html = "<h3>" + text + "</h3>" }
let ul text = { Html = "<ul><li>" + text + "</li></ul>" }
let ul3 text = { Html = "<ul><li><h3>" + text + "</h3></li></ul>" }
let img url = { Html = "<img src=\"" + url + "\"" + " style=\"align:center\" />" }
let uli text url = { Html = "<ul><li>" + text + "<img src=\"" + url + "\"" + " style=\"align:center\" />" + "</li></ul>" }
let uli2 text url = { Html = "<h2><ul><li>" + text + "<img src=\"" + url + "\"" + " style=\"align:center\" />" + "</li></ul></h2>" }
let uli3 text url = { Html = "<h3><ul><li>" + text + "<img src=\"" + url + "\"" + " style=\"align:center\" />" + "</li></ul></h3>" }
let inline (^+^) (x:HtmlOutput) (y:HtmlOutput) = { Html = x.Html + y.Html }
```

In [2]:

```
// Use the Sylvester.Tensors package from NuGet
#load "Paket.fsx"
Paket.Package["Sylvester.Arithmetic"; "Sylvester.Tensors"; "Sylvester.DataFrame"; "FSharp.Interop.Dynamic"]
#load "Paket.Generated.Refs.fsx"
```

In [20]:

```
open System
open System.Collections.Generic
open System.Linq;
open FSharp.Interop.Dynamic
open Sylvester.Data
open Sylvester.Arithmetic
open Sylvester.Arithmetic.N10
open Sylvester.Arithmetic.Collections
open Sylvester.Tensors
```

- ### From Trinidad W.I.

In [4]:

```
uli2 "West Indies" "https://upload.wikimedia.org/wikipedia/commons/9/98/Caribbean_general_map.png"
```

Out[4]:

In [31]:

```
uli2 "Indians came to Trinidad in the 19th century as indentured labourers" "https://thepeopleafterslavery.files.wordpress.com/2014/03/indentured-labourers-2.png"
```

Out[31]:

In [6]:

```
uli2 "Today Trinidad is multi-ethnic and multi-cultural" "http://currentriggers.com/wp-content/uploads/2016/11/4-17.jpg"
```

Out[6]:

In [25]:

```
uli2 "Divali and other religious festivals celebrated by all" "https://www.guardian.co.tt/image-3.1974716.c274fa76ed?size=512"
```

Out[25]:

In [9]:

```
uli2 "Cricket!" "https://akm-img-a-in.tosshub.com/indiatoday/images/story/201810/AP18297590913026.jpeg?P8W81HcX8oQiGA9xATv_s0lOWQKR3LH9"
```

Out[9]:

- An F# DSL for scientific computing focused on safety, expressiveness, and interoperability
- Take the best bits of typed functional programming and apply it to scientific and mathematical computing
- Use F# features to create a more advanced type system for scientific computing

- Dominated by C/C++, Fortran, Java, Matlab, Python, R, Julia,
- Older languages are statically typed and procedural
- Newer languages are dynamically typed and have object-oriented features
- All are imperative languages that depend on mutable state and variables
- Newer languages like Python and Julia rely heavily on meta-programming

- Functional first:
- Everything is an expression
- Functions as first-class citizens
- Higher-order functions
- Immutable variables
- Avoid side-effects
- Pattern matching
- User-defined operators

- Best of both worlds:
- Functional + object-oriented
- Immutable + mutable variables
- Static + dynamic types using the .NET DLR

- Classes, interfaces, inheritance, polymorphism
- Type extensibility with object expressions, extension methods
- Powerful meta-programming capabilities: type providers, computation expressions
- Interoperabilty - Can interoperate with any library or language with C FFI
- C++, Python, Java
- NumPy, Keras, TensorFlow, Torch

In [10]:

```
let titanic = new CsvFile("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")
titanic.["Pclass"].First().Type <- typeof<int>
let dt = Frame(titanic)
query {
for r in dt do
groupBy r?Pclass into g
sortBy g.Key
select (
let survived = (g.Where(fun p -> p?Survived = "1").Count()) |> float
let died = (g.Where(fun p -> p?Survived = "0").Count()) |> float
let ctotal = survived + died
let psurvived = round(100.0 * survived / ctotal)
let pdied = round(100.0 * died / ctotal)
(g.Key, pdied, psurvived)
)} |> Util.Table
```

Out[10]:

- Built on .NET runtime and SDK
- Comprehensive open-source tooling and environments - .NET Core / VS Code / Jupyter,...et.al
- Huge open-source community providing libraries, resources, support
- Microsoft fully committed to open source .NET and regularly releases libraries like ML.NET

In [11]:

```
let v1 = Vec<1000>.Rand //Create a vector of length 1000
let v2 = Vec<500>.Rand //Create a vector of length 500
v1 + v2 //Can we do this?
```

- E.g. A vector or array type that depends on its length
- More advanced program verification than regular types
- More errors can be caught before the program is run

- Types can depend on most
*runtime*values - Idris, Agda, ATS, F*....
- Programmers write proof-carrying code

The Future of Programming is Dependent Types... https://medium.com/background-thread/the-future-of-programming-is-dependent-types-programming-word-of-the-day-fcd5f2634878

Idris, a language that will change the way you think about programming...https://crufter.com/idris-a-language-that-will-change-the-way-you-think-about-programming

...but

- Still a niche area in programming
- Languages like Idris and ATS have a relatively small user community
- Lack of tooling, libraries, resources, commercial support

- http://okmij.org/ftp/Computation/lightweight-dependent-typing.html
- Attempt to bring safety benefits of dependent typing to mainstream languages
- Began with Dependent ML - precursor to ATS

Dependent ML (DML) is a conservative extension of the functional programming language ML. The type system of DML enriches that of ML with a restricted form of dependent types. This allows many interesting program properties such as memory safety and termination to be captured in the type system of DML and then be verified at compiler-time.

- Values must be statically known before evaluation

- Type-level arithmetic on natural number dimensions
- Addition, subtraction, multiplication, equal to, greater than, et..al

- Define function constraints which accept only objects of certain dimensions e.g only 3x3 real matrices
- Define function constraints which accept objects with dimensions in a certain range e.g matrix functions that only accept square matrices
- Sylvester can express type-level constraints and conditions simply without elaborate logical apparatus

- Many languages like C++ and D support type-level arithmetic
- C++ can use static numeric values as template parameters
- Both languages can use static checks and compiler asserts to do type level static checks

- Types can vary with values and not simply fail statjc checks
- Do not rely on compiler asserts
- Types are part of the problem domain e.g. arithmetic, linear algebra
- Rich set of type operators and constraints and checks e.g arithmetic comparison operators

In [14]:

```
// Create typed instance of some natural numbers
let a = new N<1000>()
let b = new N<900>()
a +< b
```

Out[14]:

In [15]:

```
a +> b
```

Out[15]:

In [16]:

```
a +!= b
```

Out[16]:

In [17]:

```
a +== b
```

Out[17]:

In [18]:

```
check((b * a) +== zero) //Causes type error
```

In [19]:

```
check ((a - b) +> zero) // But this is ok
```

In [21]:

```
zero - a //This results in another type, not a compiler error
```

Out[21]:

In [ ]:

```
```