JSON

A JSON document is in plain-text and may contain:

• basic types:
  • Number: 2 or 4.1
  • String: "I am a string"
  • Boolean: true or false
  • null: to denote an empty value
• attribute-value pairs (e.g. "firstName": "John")
• "arrays" (ordered lists), e.g. "myNumbers": ["12", "7", "4"]
• "objects" (collection of name-value pairs), e.g.

{

  "address": {
     "streetAddress": "21 2nd Street",
     "city": "New York"
  }

}

The order in arrays is expected to be preserved, but not the one of the elements in an object.

Defining an element (e.g. an attribute-value pair) more than once is allowed, and the last instance thereof will be the one kept.

For instance:

{
 "tcp_port": 8084,
 "tcp_port": 8085,
 [...]
}

Here, once the document is parsed, tcp_port will be considered equal to 8085.

$ jq type my_document.json
"object"

{
  "firstName": "John",
  "__comment": "This is a comment!",
  "lastName": "Smith",
  "isAlive": true,
  "age": 27,
  "address": {
    "streetAddress": "21 2nd Street",
    "city": "New York",
    "state": "NY",
    "postalCode": "10021-3100"
  },
  "phoneNumbers": [
    {
      "type": "home",
      "number": "212 555-1234"
    },
    {
      "type": "office",
      "number": "646 555-4567"
    }
  ],
  "children": [],
  "spouse": null
}

YAML

YAML is a data serialization language for all programming languages.

We prefer the .yaml extension to the .yml one.

No tabulation should be used for indentation, only spaces, and preferably a fixed amount of them; we used to prefer 4, now 2, since it allows to properly align the items listed with a dash (e.g. "- I am an item").

With Emacs, the Yaml Mode may be of help.

Syntax

Putting a semicolon at the end of statement prevents the console from printing the corresponding value (answer, variable assignment, etc.).

Value Ranges

Ranges can be expressed thanks to:

• MIN:STEP_SIZE:MAX, like in: x = -10:2:10 resulting in 11 points
• or linspace(MIN, MAX, STEP_COUNT), like in: x = linspace(-10, 10, 11) to produce the same list as before

Array-based Functions

Many functions are defined so that they can be called also with arrays of parameters, instead of just standalone values. For that, a dot/period-based syntax has been introduced so that each element of an input vector is applied to the function in turn. A key understanding is that such a dot applies not to variables but to operators; for example 2*x.^2+1 shall not be read as 2*(x.)^2+1 but as 2*x(.^)2+1.

As an example, a \(\phi\) function can be defined [1] as \(\phi(x) = e^{x}/(1+e^{x})\):

function retval = phi (x)
 retval = exp(x)./(1+exp(x));
endfunction

Then this function can be called either with a standalone value:

phi(1)
ans = 0.7311

or with an array thereof (a vector):

phi([1,2])
ans =
  0.7311   0.8808

Outputs

Beware to the lower-precision of textual outputs, which may be misleading (e.g. use format long with Octave to request 15 significant figures).

Script Files

Rather than being directly interpreted (e.g. from a pasted text), a series of statements can be gathered in a script file (a bit different from a function file [2]) that can be loaded and executed afterwards.

Their conventional extension in m (e.g. foobar.m), due to the MATLAB legacy.

Avoid dashes in the script filenames, as it may be interpreted as minus; prefer underscores (e.g. phi_exp.m rather than phi-exp.m).

An example of script, named phi_exp.m:

# An initial comment prevents Octave from thinking that this
# is a function file:
1;

# The function name can be freely chosen, it does not have to
# correspond to the script filename:
#
function retval = phi_exp (x)
   retval = exp(x) ./ (1+exp(x))
endfunction

xs = -10:10
ys = phi_exp(xs)

plot(xs,ys)

title ("A function phi to map values V to a probability-suitable ]0,1[ interval")
ylabel ("\phi(V)")
xlabel ("V")
grid on

Provided that such a script is located in a well-known directory of the tool (typically its working directory), it can be executed simply by entering its filename without extension; for example:

octave:1> phi_exp
warning: function 'phi_exp' defined within script file 'xxx/phi_exp.m'
xs =
 -10   -9   -8   [...]

Then a script can be run from the command-line; for example:

$ octave --eval phi_exp.m --persist
# OR
$ octave phi_exp.m

Defining a Function

Let's suppose we want to define \(my\_func: x \rightarrow 2.x^{2}+1\).

For that, in Scilab's shell, enter:

--> function [y] = my_func(x)
  > y = 2*x^2+1
  > endfunction

Then:

--> my_func(5)
 ans  =
   51.

Plotting a Function

Let's define the support of our function, here computed from 0 to 10 with 50 values: my_xs = linspace(0, 10, 50). Then just execute plot(my_xs, my_func).

We experienced rendering issues that prevented a proper display of plots.

Defining a Function

As already seen, so that it can operate on single values or arrays, a \(\phi(x) = e^{x}/(1+e^{x})\) function can be defined as:

function retval = phi (x)
  retval = exp(x)./(1+exp(x))
endfunction

Plotting a Function

We consider first a function of a single variable.

Let my_xs = 0:0.2:10 define [3] the support / display range of our function; then:

my_ys = my_func(my_xs)
plot(my_xs, my_ys)

A key point is to understand that, for all plots (plot, mesh, surf, etc.), the last element to be specified is not the function to which the previous elements are to be applied, but directly the final values to plot.

Extra display settings can be added afterwards:

title ("This is my title")
ylabel ("My ordinate label")
xlabel ("My abscissa label")
grid on

This results in:

The image can be saved either by using the Save As GUI menu and typically selecting PNG, or directly from the console/scripts thanks to the following command: print("my_plot.png", "-dpng").

To obtain a list of all the different values in a selection

The objective is to determine the set of the different (unique) values in a selection (typically a whole column).

Once the selection has been defined, select the Data -> More Filters -> Standard Filter menu item, set the Field name dropdown to "-none -" and, in the panel for Options settings, enable No duplications.

Then each resulting selected row while have a unique value in the selected column (the other rows will still exist but not be selected).

Often it might be convenient to sort this selection afterwards; the up/down arrow icons may be used, and keeping the Current selection is generally used (rather than extending it).