DEV Community: sofaki000

Run envoy proxy with docker

sofaki000 — Fri, 07 Feb 2025 12:52:22 +0000

Hey friends, today we will do a short introduction how to run envoy proxy with docker. We will work with the basic blocks of envoy, which are listeners, clusters and filters.

Prerequisites

download docker

Run envoy with docker

docker run --name=proxy-with-admin -d -p 9901:9901 -p 10000:10000 envoyproxy/envoy:v1.25.6

Why adding -p 9901:9901?
This exposes the 9901 container image to your host. This way you can access the admin portal in http://localhost:9901/.

From docker desktop, you can see in envoy.yaml which contains the configuration of your envoy, that admin portal is exposed on 9901 port on your container.

Send request to envoy

Envoy uses listeners to accept client requests. These requests are then forwarded to clusters, which represent your backend services.

In the envoy.yaml, we see the following configuration for listeners:

  listeners:
  - name: listener_0
    address:
      socket_address:
        protocol: TCP
        address: 0.0.0.0
        port_value: 10000

This means that your listener is on port 10000. We have exposed this port with the Docker command: -p 10000:10000.

Therefore when you hit http://localhost:10000/ on your local machine, you reach the Envoy listener. When an Envoy listener receives a request, the Envoy filters execute.

In the filters section of our envoy.yaml we see:

   filter_chains:
    - filters:
      - name: envoy.filters.network.http_connection_manager
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
          scheme_header_transformation:
            scheme_to_overwrite: https
          stat_prefix: ingress_http
          route_config:
            name: local_route
            virtual_hosts:
            - name: local_service
              domains: ["*"]
              routes:
              - match:
                  prefix: "/"
                route:
                  host_rewrite_literal: www.envoyproxy.io
                  cluster: service_envoyproxy_io
          http_filters:
          - name: envoy.filters.http.router
            typed_config:
              "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router

From the "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
we see the type of filter we have applied, which is a HTTP connection manager more here

Your cluster (aka your backend) is service_envoyproxy_io.

Using Your Own envoy.yaml Configuration

If you want to use your own envoy.yaml configuration, you need to have an envoy.yaml file and provide it in the container image you are running.

Run this command in the folder where you have your envoy.yaml:

docker run --name=proxy-with-admin -d -p 9901:9901 -p 10000:10000 -v envoy.yaml:/etc/envoy/envoy.yaml envoyproxy/envoy:v1.25.6
The command -v .envoy.yaml:/etc/envoy/envoy.yaml is used to mount a file or directory from your local machine into a container. In this case, it mounts the local file .envoy.yaml to the path /etc/envoy/envoy.yaml inside the container. This ensures that the container uses the configuration file from your local environment.

References

- https://iceburn.medium.com/i-tried-getting-started-with-envoy-d6680f69bc3

3 CDK best practises

sofaki000 — Sat, 13 May 2023 19:14:29 +0000

Let's explore some best practises for getting started. As always, feedback on the content is always welcomed :D

Avoid editting the physical and logical names of your constructs.

Physical name of a resource is what you see on AWS console. Logical name of a resource is the resource name in AWS Cloudformation template. The logical name is the construct id we provided with an extra suffix added by the CDK.

const bucket = new s3.Bucket(this, 'thisIsTheConstructId', { bucketName: 'thePhysicalName', });

You can edit the physical name of a construct by overriding the name property of the construct (for s3 buckets, the bucketName prop). Assigning physical names to resources has some disadvantages in AWS CloudFormation. Most importantly, any changes to deployed resources that require a resource replacement, such as changes to a resource's properties that are immutable after creation, will fail if a resource has a physical name assigned. If you end up in that state, the only solution is to delete the AWS CloudFormation stack, then deploy the AWS CDK app again. See the AWS CloudFormation documentation for details.

When it is required to add a physical name? In some cases, like when creating an AWS CDK app with cross-environment references.

You should also avoid changing the logical ID of a resource after it has been created. AWS CloudFormation identifies resources by their logical ID. Therefore, if you change the logical ID of a resource, AWS CloudFormation creates a new resource with the new logical ID, then deletes the existing one. Depending on the type of resource, this might cause service interruption, data loss, or both.

Use grant methods to assign privileges

AWS constructs make least-privilege permissions achievable by offering APIs to express permission requirements.
Try to avoid to manually create IAM permission statements when a grant method fits your use case.

The following example creates the permissions to allow a Lambda function's execution role to read and write objects to a particular Amazon S3 bucket. If the Amazon S3 bucket is encrypted with an AWS KMS key, this method also grants permissions to the Lambda function's execution role to decrypt with the key.

bucket.grantReadWrite(lambdaFun)

If a specific grant method isn't available for the particular use case, you can use a generic grant method to define a new grant with a specified list of actions.

The following example shows how to grant a Lambda function access to the Amazon DynamoDB CreateBackup action.

table.grant(func, 'dynamodb:CreateBackup');

Don't forget to define removal policies

Resources that maintain persistent data, such as databases, Amazon S3 buckets, and Amazon ECR registries, have a removal policy. The removal policy indicates whether to delete persistent objects when the AWS CDK stack that contains them is destroyed. The values specifying the removal policy are available through the RemovalPolicy enumeration in the AWS CDK core module.

Resources besides those that store data persistently might also have a removalPolicy that is used for a different purpose. For example, a Lambda function version uses a removalPolicy attribute to determine whether a given version is retained when a new version is deployed. These have different meanings and defaults compared to the removal policy on an Amazon S3 bucket or DynamoDB table.

RemovalPolicy.RETAIN (DEFAULT) = Keep the contents of the resource when destroying the stack. The resource is orphaned from the stack and must be deleted manually. If you attempt to re-deploy the stack while the resource still exists, you will receive an error message due to a name conflict.
RemovalPolicy.DESTROY = The resource will be destroyed along with the stack.

Just be careful with S3: even if removal policy of a bucket is set to DESTROY, AWS CloudFormation does not remove Amazon S3 buckets that contain files. Attempting to do so is an AWS CloudFormation error. To have the AWS CDK delete all files from the bucket before destroying it, set the bucket's autoDeleteObjects property to true.

Happy coding folks!

References:
If you would like to explore more CDK best practises, AWS docs are an excellent place. You can find the basic concepts here and some best practises here.

Heap and Stack in JS basics

sofaki000 — Sun, 01 May 2022 13:08:15 +0000

Javascript knows two types of memories: Stack and Heap

Stack

easy-to-access memory
Only items for which the size is known in advance can go onto the stack
Numbers,strings,booleans go to the stack

Heap

For items of which the exact size and structure can't be pre-determined.
Objects and arrays can be changed at runtime, therefore they go to heap

For each heap item, the exact address is stored in a pointer which points at the item in the heap. This pointer in turn is stored on the stack.
For reference types, only pointers are stored on the stack.

Example 1
So for example, if you have the variable:

var person={name:"Sofia"}

Only a pointer to the person object is stored in that variable

Example 2

var person = { name: 'Sofia' }
var newPerson = person
newPerson.name = 'John'
console.log(person.name)

This will print "John", becasue we never copied the person object itself to newPerson. We only copied the pointer, which still points at the same address in memory! Hence changing newPerson.name also changes person.name because newPerson points at the exactly same object!
You're pointing at the same object, you didn't copy the object.

How you copy the actual value? The spread operator comes to the rescue

var person = { name: 'Max' }
var copiedPerson = { ...person }

Getting started with pthreads

sofaki000 — Sun, 13 Mar 2022 07:49:22 +0000

Installing pthreads library
Compiling pthread programs
Pthreads API

Installation

Installing pthreads library on linux:

sudo apt-get install libpthread-stubs0-dev

Compilation

You can compile threaded programms with gnu compiler with the following command:

1)

gcc -pthread file.c

2)

gcc -pthread file.c -o thread -lpthread

where:
-lpthread command will tell the compiler to execute the program with pthread.h library.
gcc is the compiler command.
file.c is the name of c program source file.
-o is option to make object file.
thread is the name of object file.

Pthreads API

All identifiers in the threads library begin with pthread_.

Some frequently used methods are:

1) pthread_ = Threads themselves and miscellaneous subroutines
2) pthread_attr_ = Thread attributes objects
3) pthread_mutex_ = Mutexes
4) pthread_mutexattr_ = Mutex attributes objects.

Also the pthread.h header file should be included in each source file using the Pthreads library.

Hypothesis Testing with matlab

sofaki000 — Sun, 21 Nov 2021 14:08:52 +0000

Introduction

In this article we will explore some matlab functions for hypothesis testing in data analysis.

ttest = One-sample and paired-sample t-test

h = ttest(x) returns a test decision for the null hypothesis that the data in x comes from a normal distribution with mean equal to zero and unknown variance, using the one-sample t-test. The alternative hypothesis is that the population distribution does not have a mean equal to zero. The result h is 1 if the test rejects the null hypothesis at the 5% significance level, and 0 otherwise.

example
h = ttest(x,y) returns a test decision for the null hypothesis that the data in x – y comes from a normal distribution with mean equal to zero and unknown variance, using the paired-sample t-test.

example
h = ttest(x,y,Name,Value) returns a test decision for the paired-sample t-test with additional options specified by one or more name-value pair arguments. For example, you can change the significance level or conduct a one-sided test.

example
h = ttest(x,m) returns a test decision for the null hypothesis that the data in x comes from a normal distribution with mean m and unknown variance. The alternative hypothesis is that the mean is not m.

Example: Test the null hypothesis from sample data A with mean equal to zero at the 1% significance level and calculate confidence interval of mean.

clear;
clc; 
A  = [41 46 47 47 48 50 50 50 50 50 50 50 48 50 50 50 50 50 50 50 52 52 53 55 50 50 50 50 52 52 53 53 53 53 53 57 52 52 53 53 53 53 53 53 54 54 55 68]; 
alpha = 0.01; 
[h,p,ci] = ttest(A,0,'Alpha',0.01)
fprintf('CI for mean(A)=[%2.3f,%2.3f] \n', ci(1),ci(2));

Result:
CI for mean(A)=[50.017,52.817]

vartest = chi-square variance test

h = vartest(x,v) returns a test decision for the null hypothesis that the data in vector x comes from a normal distribution with variance v, using the chi-square variance test. The alternative hypothesis is that x comes from a normal distribution with a different variance. The result h is 1 if the test rejects the null hypothesis at the 5% significance level, and 0 otherwise.
h = vartest(x,v,Name,Value) performs the chi-square variance test with additional options specified by one or more name-value pair arguments. For example, you can change the significance level or conduct a one-sided test.

Input arguments:

- x — Sample data (vector | matrix | multidimensional array)
- v — Hypothesized variance (scalar value)

Name-Value Arguments

Specify optional comma-separated pairs of Name,Value arguments. Name is the argument name and Value is the corresponding value. Name must appear inside quotes. You can specify several name and value pair arguments in any order as Name1,Value1,...,NameN,ValueN.

- Alpha — Significance level (0.05 (default) | scalar value in the range (0,1))
- Dim — Dimension,first nonsingleton dimension (default) | positive integer value

Output arguments:

- h — Hypothesis test result 1 | 0
If h = 1, this indicates the rejection of the null hypothesis at the Alpha significance level.

If h = 0, this indicates a failure to reject the null hypothesis at the Alpha significance level.

- p — p-value
p-value of the test, returned as a scalar value in the range [0,1]. p is the probability of observing a test statistic as extreme as, or more extreme than, the observed value under the null hypothesis. Small values of p cast doubt on the validity of the null hypothesis.

- ci — Confidence interval
Confidence interval for the true variance, returned as a two-element vector containing the lower and upper boundaries of the 100 × (1 – Alpha)% confidence interval.

Example Program to calculate confidence interval of variance
and standard deviation of a matrix using vartest:

 A  = [41 46 47 47 48 50 50 50 50 50 50 50 48 50 50 50 50 50 50 50 52 52 53 55 50 50 50 50 52 52 53 53 53 53 53 57 52 52 53 53 53 53 53 53 54 54 55 68]; 
alpha = 0.05; 
variance = var(A)
[h,pvar,civarV]= vartest(A ,variance, alpha);
fprintf('CI for var(A)=[%2.3f,%2.3f] \n', civarV(1),civarV(2));
fprintf('CI for sigma(A)=[%2.3f,%2.3f] \n',sqrt(civarV(1)),sqrt(civarV(2)));

Some theory:
Chi-Square Variance Test
The chi-square variance test is used to test whether the variance of a population is equal to a hypothesized value.

The test statistic is

T=(n−1)[(s/ σ)^2]

where n is the sample size, s is the sample standard deviation, and σ is the hypothesized standard deviation. The denominator is the ratio of the sample standard deviation to the hypothesized

standard deviation. The further this ratio deviates from 1, the more likely you are to reject the null hypothesis. The test statistic T has a chi-square distribution with n – 1 degrees of freedom under the null hypothesis.

chi2gof = Chi-square goodness-of-fit test

Some theory:
The Chi-square goodness of fit test is a statistical hypothesis test used to determine whether a variable is likely to come from a specified distribution or not. It is often used to evaluate whether sample data is representative of the full population.

Description:

h = chi2gof(x) returns a test decision for the null hypothesis that the data in vector x comes from a normal distribution with a mean and variance estimated from x, using the chi-square goodness-of-fit test. The alternative hypothesis is that the data does not come from such a distribution. The result h is 1 if the test rejects the null hypothesis at the 5% significance level, and 0 otherwise.

h = chi2gof(x,Name,Value) returns a test decision for the chi-square goodness-of-fit test with additional options specified by one or more name-value pair arguments. For example, you can test for a distribution other than normal, or change the significance level of the test.

Example:

clear;
clc; 

binomialdist = makedist('Binomial'); 
normaldist = makedist('Normal');
b = random(binomialdist,100,1);
n = random(normaldist,100,1);

%Returns a test decision for the null hypothesis that the data in 
%vector comes from a normal distribution with a mean and variance
 %estimated from the vector
h1 = chi2gof(b);
h2 = chi2gof(n) 
%returns a test decision for the chi-square goodness-of-fit test for a
%binomial distribution
h3 = chi2gof(b,'CDF',binomialdist);

fprintf("h1 = %d\n",h1); % false
fprintf("h2 = %d\n",h2); % true
fprintf("h3 = %d\n",h3); % true

Result:
h1 = 1
h2 = 0
h3 = 0

Data analysis with Matlab: distributions

sofaki000 — Sat, 20 Nov 2021 19:31:14 +0000

Introduction:

Explore different distributions (normal, poisson, student,exponential) using matlab.

Normal distribution

normrnd = Normal random numbers

r = normrnd(mu,sigma) generates a random number from the normal distribution with mean parameter mu and standard deviation parameter sigma.

r = normrnd(mu,sigma,sz1,...,szN) generates an array of normal random numbers, where sz1,...,szN indicates the size of each dimension.

Arguments:
mu — Mean
sigma — Standard deviation

More on normal distribution on a separate article

Poisson distribution

poissrnd = generates random numbers from Poisson distribution.
r = poissrnd(lambda) generates random numbers from the Poisson distribution specified by the rate parameter lambda.

lambda can be a scalar, vector, matrix, or multidimensional array.

r = poissrnd(lambda,sz1,...,szN) generates an array of random numbers from the Poisson distribution with the scalar rate parameter lambda, where sz1,...,szN indicates the size of each dimension.

Examples:

r_scalar = poissrnd(20)
r_scalar = 9

2)
Generate a 2-by-3 array of random numbers from the same distribution by specifying the required array dimensions.

lambda = 20
r_array = poissrnd(lambda ,2,3)
r_array = 2×3

    13    14    18
    26    16    21

lambda = 10:2:20
lambda = 1×6

    10    12    14    16    18    20

Generate random numbers from the Poisson distributions.

r = poissrnd(lambda)
r = 1×6

    14    13    14     9    14    31

poisspdf= Poisson probability density function

Parameters:

x — Values at which to evaluate Poisson pdf
lambda — Rate parameters

Compute the Poisson probability density function values at each value from 0 to 10. These values correspond to the probabilities that a disk has 0, 1, 2, .., 10 flaws.

Examples:

flaws = 0:10;
y = poisspdf(flaws,2);

tV = [0:100]';
lambda = 10; 
pois = poisspdf(tV,lambda);

Student's distribution

tcdf = Student's t cumulative distribution function

p = tcdf(x,nu) returns the cumulative distribution function (cdf) of the Student's t distribution with nu degrees of freedom, evaluated at the values in x.

Arguments:
x — Values at which to evaluate cdf
nu — Degrees of freedom

tinv = Student's t inverse cumulative distribution function

Examples:

1)
Find the 95th percentile of the Student's t distribution with 50 degrees of freedom.

p = .95;   
nu = 50;   
x = tinv(p,nu)
x = 1.6759

Exponential distribution

exprnd = calculates exponential random numbers

Examples:

r = exprnd(mu)
r = exprnd(mu) generates a random number from the exponential distribution with mean mu.

r = exprnd(mu,sz1,...,szN)
 generates an array of random numbers from the exponential distribution, where sz1,...,szN indicates the size of each dimension.

exppdf = Exponential probability density function

1) y = exppdf(x) returns the probability density function (pdf) of the standard exponential distribution, evaluated at the values in x.

Compute the density of the value 5 in the standard exponential distribution.

y1 = exppdf(5) 
y1 = 0.0067

2) y = exppdf(x,mu) returns the pdf of the exponential distribution with mean mu, evaluated at the values in x.

Compute the density of the value 5 in the exponential distributions specified by means 1 through 5.

y2 = exppdf(5,1:5)
y2 = 1×5

    0.0067    0.0410    0.0630    0.0716    0.0736

Arguments:

x — Values at which to evaluate pdf
mu — mean

Histograms

1) histogram = Histogram plot

2) histfit = Histogram with a distribution fit

histfit(data) plots a histogram of values in data using the number of bins equal to the square root of the number of elements in data and fits a normal density function.

Construct a histogram with a normal distribution fit.
(bins are the number of bars you will see in your hist)

r = normrnd(10,1,100,1); 
histfit(r)

example
histfit(data,nbins) plots a histogram using nbins bins and fits a normal density function.
Construct a histogram using six bins with a normal distribution fit.

r = normrnd(10,1,100,1);
histfit(r,6)

Clearing environment

clc = clears command window
clear = Remove items from workspace, freeing up system memory

General Useful Commands

mean = calculates average or mean value of array
nargin = returns the number of function input arguments
ttest = One-sample and paired-sample t-test

More on ttest

The one-sample t-test is a parametric test of the location parameter when the population standard deviation is unknown.

The test statistic is:

t= (x−μ)/(s/squar(n))

where x is the sample mean, μ is the hypothesized population mean, s is the sample standard deviation, and n is the sample size. Under the null hypothesis, the test statistic has Student’s t distribution with n – 1 degrees of freedom.

Arguments of ttest:

Alpha — Significance level

0.05 (default) | scalar value in the range (0,1)

Dim — Dimension

first nonsingleton dimension (default) | positive integer value
Dimension of the input matrix along which to test the means consisting of 'Dim' and a positive integer value. For example, specifying 'Dim',1 tests the column means, while 'Dim',2 tests the row means.
3)

Tail — Type of alternative hypothesis

'both' (default) | 'right' | 'left'
Type of alternative hypothesis to evaluate, specified as the comma-separated pair consisting of 'Tail' and one of:

'both' — Test against the alternative hypothesis that the population mean is not m.

'right' — Test against the alternative hypothesis that the population mean is greater than m.

'left' — Test against the alternative hypothesis that the population mean is less than m.

Output Arguments of ttest:

Hypothesis test result

Hypothesis test result, returned as 1 or 0.

If h = 1, this indicates the rejection of the null hypothesis at the Alpha significance level.

If h = 0, this indicates a failure to reject the null hypothesis at the Alpha significance level.

p — p-value,scalar value in the range [0,1]

p-value of the test, returned as a scalar value in the range [0,1]. p is the probability of observing a test statistic as extreme as, or more extreme than, the observed value under the null hypothesis. Small values of p cast doubt on the validity of the null hypothesis.

ci — Confidence interval

vector
Confidence interval for the true population mean, returned as a two-element vector containing the lower and upper boundaries of the 100 × (1 – Alpha)% confidence interval.

stats — Test statistics

structure
Test statistics, returned as a structure containing the following:

tstat — Value of the test statistic.

df — Degrees of freedom of the test.

sd — Estimated population standard deviation. For a paired t-test, sd is the standard deviation of x – y.

Matlab plots tutorial

sofaki000 — Sat, 20 Nov 2021 11:17:05 +0000

Introduction

In this tutorial we will look at some basic functionalities of matlab figures. We will see some examples and understand how to use functions such as plot and stem.

figure creates a new figure window using default property values. The resulting figure is the current figure.

Example:

figure(Name,Value) modifies properties of the figure using one or more name-value pair arguments. For example, figure('Color','Red') sets the background color to red (same as figure('Color','r')

Creating one discrete and one 2D line plot in the same figure

figure("Color", "c"); %adds cyan color at the background of matlab % figure 
%Creates a vector of 100 evenly spaced points in the interval 
%[-5,5].
Y = linspace(-5,5,50);
plot(Y, "r:") % plots Y against an implicit set of x-coordinates.
% adds red color to line (from r) and makes it dotted (from :)
hold on % use hold on to add a second plot
stem(Y, "c") % plott discrete sequence data
% c makes line have cyan color

Adding grid to your figures:

grid= Display or hide axes grid lines

1) grid on = displays the major grid lines for the current axes

2) grid off = removes all grid lines from the current axes or chart.

3) grid minor = Display the minor grid lines.

scatter = Scatter plot
tiledlayout = Create tiled chart layout

Example:

tiledlayout(m,n) = creates a tiled chart layout for displaying multiple plots in the current figure. The layout has a fixed m-by-n tile arrangement that can display up to m*n plots.

Example no 2:

clc;
clear; 
figure("Color", "c"); 
x = linspace(0,3*pi,200); %Create a vector of 100 points in the interval [0,3π,200].
y = cos(x) + rand(1,200);
t = tiledlayout(2,2); 

title(t,'Title of our figure') % add title
xlabel(t,'X label')% add x label
ylabel(t,'Y label')% add y label
t.TileSpacing = 'compact'; %Decrease the amount of space between the tiles by setting the TileSpacing property to 'compact'
t.Padding = 'compact'; %decrease the space between the edges of the layout and the edges of the figure by setting the Padding property to 'compact'.

% add your plots in the same figure:
ax1 = nexttile;
ax1.XColor = [1 1 1];
ax1.YColor = [1 0 0];
scatter(ax1,x,y);
grid on
title('Sample 1');

ax2 = nexttile;
scatter(ax2,x,y,'filled','d');
title('Sample 2');

nexttile(t);
bar([10 22 31 43 52])
title('Sample 3');

nexttile(t);

x = linspace(-10,10,200); %Create x as 200 linearly spaced values between -10 and 10.
y = cos(x); % Create y as the cosine of x.
plot(x,y)
%Change the tick value locations along the x-axis and y-axis. 
%Specify the locations as a vector of increasing values. The values do not need to be evenly spaced.
xticks([-3*pi -2*pi -pi 0 pi 2*pi 3*pi])
xticklabels({'-3\pi','-2\pi','-\pi','0','\pi','2\pi','3\pi'}) %Also, change the labels associated with each tick value along the x-axis. To include special characters or Greek letters in the labels, use TeX markup, such as \pi for the π symbol
yticks([-1 -0.8 -0.2 0 0.2 0.8 1])

Matlab matrix-basics cheatsheet

sofaki000 — Sat, 20 Nov 2021 09:26:22 +0000

Matlab basics

MATLAB is an abbreviation for "matrix laboratory." While other programming languages mostly work with numbers one at a time, MATLAB is designed to operate primarily on whole matrices and arrays.

All MATLAB variables are multidimensional arrays, no matter what type of data. A matrix is a two-dimensional array often used for linear algebra.

To create an array with four elements in a single row, separate the elements with either a comma (,) or a space.

a = [1 2 3 4]
result:
a = 1×4

     1     2     3     4

To create a matrix that has multiple rows, separate the rows with semicolons.

a = [1 3 5; 2 4 6; 7 8 10]
a = 3×3

     1     3     5
     2     4     6
     7     8    10

Another way to create a matrix is to use a function, such as ones, zeros, or rand. For example, create a 5-by-1 column vector of zeros.

z = zeros(5,1)

z = 5×1

     0
     0
     0
     0
     0

The matrix operators for multiplication, division, and power each have a corresponding array operator that operates element-wise. For example, raise each element of a to the third power:

a.^3
ans = 3×3

           1          27         125
           8          64         216
         343         512        1000

Dot (.) is used to access each individual element of the matrix.

ex: a.^3 -> take each element of a matrix and raise it to the third power.

Accessing elements in the array

A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
A = 4×4

     1     2     3     4
     5     6     7     8
     9    10    11    12
    13    14    15    16

There are two ways to refer to a particular element in an array. The most common way is to specify row and column subscripts, such as:

A(4,2)= 14

Less common, but sometimes useful, is to use a single subscript that traverses down each column in order:

A(8) = 14

To refer to multiple elements of an array, use the colon operator, which allows you to specify a range of the form start:end. For example, list the elements in the first three rows and the second column of A:

A(1:3,2)
ans = 3×1

     2
     6
    10

The colon alone, without start or end values, specifies all of the elements in that dimension. For example, select all the columns in the third row of A:

A(3,:)
ans = 1×5

     9    10    11    12     0

Clearing environment

clc = clears command window
clear = Remove items from workspace, freeing up system memory

For reproducibility

rng default

When Matlab generates random numbers, they're not truly random; they are based on a pseudo-random number generating algorithm. The rng command controls the seed, or starting point, for this value. The "default" values resets it to the original value that MATLAB starts with; this evolves over time. You can see this behaviour if you do something like called rand(10,1), then calling rng('default') then repeating the rand command. It will generate exactly the same "random" numbers.

OpenCilk tutorial

sofaki000 — Mon, 15 Nov 2021 11:41:53 +0000

What is Parallel Programming?

In very simple terms, it is the use of multiple resources, in this case, processors, to solve a problem. This type of programming takes a problem, breaks it down into a series of smaller steps, delivers instructions, and processors execute the solutions at the same time.It is also a form of programming that offers the same results as concurrent programming but in less time and with more efficiency.

OpenCilk tutorial

Be aware that opencilk doesn't work for windows.
First we will download the docker image:

wget https://github.com/OpenCilk/opencilk-project/releases/download/opencilk%2Fv1.0/docker-opencilk-v1.0.tar.gz

Then load the image :(which loads the image from a tar archive. It restores both images and tags.)

docker load < docker-opencilk-v1.0.tar.gz

2) Run a simple c program to confirm opencilk is installed:

#include <stdio.h>
#include <stdlib.h>
#define cilk_spawn _Cilk_spawn // the includes neccessary for openCilk
#define cilk_sync  _Cilk_sync
#define cilk_for   _Cilk_for

int main(){
printf("Hello world");
}

3)Quick overview:
Cilk extends C and C++ with three keywords: cilk_spawn, cilk_sync, and cilk_for

cilk_spawn and cilk_sync:

example 1:

int64_t fib(int64_t n) {
  if (n < 2) return n;
  int x, y;
  x = cilk_spawn fib(n - 1);
  y = fib(n - 2);
  cilk_sync;
  return x + y;
}

In the usage of cilk_spawn, parallel work is created when cilk_spawn precedes the invocation of a function, thereby causing the function to be spawned.The code immediately following the spawn — is allowed to execute in parallel with the child, instead of waiting for the child to complete as is done in C/C++.
In the example fib function, the cilk_spawn spawns the recursive invocation of fib(n-1), allowing it to execute in parallel with its continuation, which calls fib(n-2).
The cilk_sync is a local "barrier," not a global one as. In fib, the cilk_sync prevents the execution of fib from continuing past the cilk_sync until the spawned invocation of fib(n-1) has returned.

cilk_for:
example 1:

void daxpy(int n, double a, double *x, double *y) {
 cilk_for (int i = 0; i < n; ++i) {
    y[i] = a * x[i] + y[i];
  }
}

The cilk_for parallel-loop construct indicates that all iterations of the loop are allowed to execute in parallel. At runtime, these iterations can execute in any order, at the discretion of the runtime scheduler.

example 2:

void mm(const double *restrict A,
        const double *restrict B,
        double *restrict C,
        int64_t n) {
  cilk_for (int64_t i = 0; i < n; ++i) {
    cilk_for (int64_t j = 0; j < n; ++j) {
      for (int64_t k = 0; k < n; ++k) {
        C[i*n + j] += A[i*n + k] * B[k*n + j];
      }
    }
  }
}
```



To sum up, a good start would be using cilk_for to replace all the for in your synchronous code. Also using cilk_spawn and cilk_sync
for all your recursive calls.