Variables Title slide variables

Content What is a variable? Data types Mutability (constant vs variable) Scope and visibility Preallocation Content of the presentation: What is a variable? Data types Mutability (constant vs variable) Scope and visibility Preallocation

What is a variable Location where a value is stored Variable: a Address Value 000 NULL 001 5 002 8 003 Variable: a A variable is the location of where a value is stored. So for the computer the variable represent a physical address in the memory, in which the value (that we associate with the variable) is stored.

What is a variable Location where a value is stored Every variable has: Type (statically typed languages) Variable name (identifier) Value Every variable has an associated type (in statically typed languages), a variable name and a value. So in the java example of ‘int a = 5;’, int is the type, a is the variable name and 5 is the value.

Data types Integer (int) Floating point number (float) Name Shorthand What Integer int Whole numbers Floating-point number float 32-bit number with digits after decimal place Double precision float double 64-bit number with digits after decimal place Boolean (logical in MATLAB) bool (logical in MATLAB) Value that’s either true or false (0 or 1) Array (1D is a vector) ~ A list of variables, depending on the language this can be further divided into lists, arrays, vectors, queues, etc. Character char A single (ASCII) character String string or str A list or array of characters Integer (int) Floating point number (float) Double precision float (double) There are many different types, this slide lists the most important ones: Integer (int): whole numbers Floating-point number (float): 32-bit number with digits after decimal place Double precision float (double): 64-bit number with digits after decimal place Boolean (bool; logical in MATLAB): Value that’s either true or false (0 or 1) Array (1D usually called a vector, sometimes list): A list of variables, depending on the language this can be further divided into lists, arrays, vectors, queues, etc. Character (char): A single (ASCII) character String (string or str): A list or array of characters

Typing Statically typing Languages: C (Igor), Java, PEARL Variable has one type Type preassigned Programming languages can roughly be divided into two: statistically typed languages and dynamically typed languages Statistically typed languages, such as C, Java and PEARL have the type associated with the variable. The type is preassigned, usually explicitly in the language (etc. int a = 5; (Java), where a is associated with the type int)

Typing Statically typing Dynamically typing Languages: C (Igor), Java, PEARL Variable has one type Type preassigned Dynamically typing Languages: MATLAB, Python, R, Perl Value has one type Type of variable may change Secondly there are dynamically typed languages, such as MATLAB, Python, R and Perl. They have the type associated with the value, not the variable, so the type of the variable may change.

Type casting Explicitly converting type of a variable or value Only in dynamically typed languages Especially relevant for numerical types Reasons for casting: Increase precision/memory Reduce precision Cast base type to derived type Type casting is the act of transforming the type of a variable or value. The type of a variable can only be changed in dynamically typed languages. I find this especially useful for numerical types, for example if I want to increase my precision (cast from int to double, or double to float) or decrease my precision (double to int). Another application is to cast base types to derived types (object-oriented programming)

Mutability Variable Constant Value dynamically assigned Value may change during run-time Constant Value assigned at initialization Value cannot be changed In explicit languages, different levels of mutability exist for variables. A variable is dynamically assigned, and thus the value may change during run-time. An constant is assigned at initialization and cannot be changed during run-time. An identifier shows the mutability (i.e. const float PI = 3.14; is a constant).

Mutability Depending on the language more subtypes available Other languages don’t have constant modifiers Workarounds if needed Use naming conventions: ALL_CAPS Some languages offer more subtypes of mutability (e.g. java has protected). Other languages don’t allow constants. There are usually workarounds, but otherwise you could use the naming convention of using ALL_CAPS for constants.

Mutability: why use constants? Users are stupid! Reminder for yourself Physical constants (pi, N of Avogadro, etc) Why would you use constants? If your program is going to be used by users, they will find a way to mess up variables. It is also good as a reminder for yourself that certain variables should not be changed. Lastly, it is often used for physical constants such as pi, the number of Avogadro, etc.

Scope Lifetime of a variable MATLAB is an exception Important for memory allocations The scope determines the lifetime of a variable; or another way to look at it, were the computer can read the variable. Matlab is an exception and will have its own slide. Scope is important for memory allocations, and it’s good to keep an eye on it.

Scope Output: ? In this Java example, a for-loop is shown where the println displays the value of i. The question is what the output in each case is. For(int I = 0; I < 10; i++) { System.out.println(i); } Output: ?

What is happening? Memory cleared: Memory for an int allocated Initialization: i is created Memory cleared: Space in memory available for new assignments In the same example, it shows that I is created within the for-loop in the line ‘int I = 0;, at which point memory is allocated for it. After the loop has ran, this memory will be cleared, so I no longer exists in the second println. The scope of I is the for-loop, in only exists inside the forloop, not outside of it. i no longer exists

Function example Output: ? Output: ? The same goes for funcions. In this example a function myFunction is declared, which takes an integer and adds 100 to it, after which it returns it. If I make a variable int a = 100 and apply the function to it: res = myFunction(a);, what is the value of res and the value of a afterwards? Res will be 200, while a will remain 100.

Levels of scope Blocks (not all languages!) Functions Module/Class Global Different levels of scope exist. Some languages have block scope, where every block of code (usually denoted using curly brackets), has its own scope. Functions have their own scope (variables within a function cannot be accessed unless they are exported. Modules and classes usually have their own scope. Lastly the global scope means a variable is always available.

Scope modifiers Most language allow you to make a variable global Automatic if outside function Only use in dire need! In most languages there are ways to make the variables global, or define the scope of a variable. Usually you do not want to make a variable global, so only use it in dire need. This is matlab example using the function: function addValue(v) global i; i = i + v; end When executing the lines: i = 0; addValue(5); disp(i) addValue(3); What values of I will be displayed? The values will be added to i, because it is global, so this global I will be modified. It will thus be 5 and then 8.

MATLAB Workspace shows scope Variables don’t get deleted after for-loop Each function has it’s own workspace Matlab is a special case, because the scope is explicit in the workspace. It furthermore doesn’t delete variables after a loop. However, it does have function scope, where each function has its own workspace, showing variables in its scope (access using debug function). Variables initiated, so available in scope

A word on preallocation You might have gotten this error (MATLAB): What’s going on here? A word on preallocation. You might have gotten a MATLAB warning that you have a variable that changes size on every loop iteration. This warning suggests you should preallocate.

Allocation example Allocate space for empty list (say 8 bit) Add int to the allocated space, so need 8 bits more Memory not always linear! An example of allocation in matlab: newArray = []; For I = 1:10 newArray = [newArray, i]; End In this case, the size of newArray changes on each iteration. After initialization it’s an empty list (roughly 8 bits). On each iteration, the computer has to find an extra 8 bits for the value that is added. Since memory is not always linear, this can take a lot of overhead. On small iterations like this, it’s not a big problem, but it will be on very big iterations (e.g. a million times).

What to do? No problem if small array Preallocate the largest possible number of values What can you do about this? As said, it’s not a big problem for smaller arrays and smaller iterations, so usually it’s fine to leave it. However, a better practice is the allocate the largest amount of values you think will be added to the array, e.g.: newArray = nan(10,1);

What to do? No problem if small array Preallocate the largest possible number of values Preallocate in chunks (i.e. every 1000 values add an extra 1000 values) Another solution is to preallocate in chunks. So instead of letting the computer find memory on each iteration, preallocate say a 1000 values, and each time you hit this limit, preallocate another 1000.

Summary What is a variable? Data types Location where a value is stored Data types Statically vs dynamically Type casting Mutability (constant vs variable) Single value for a variable Scope and visibility Memory allocation MATLAB: use functions! Preallocation May speed up your code Summary, things we discussed: What is a variable? Location where a value is stored Data types Statically vs dynamically Type casting Mutability (constant vs variable) Single value for a variable Scope and visibility Memory allocation MATLAB: use functions! Preallocation May speed up your code