Hey! Continuing on with the C++ STLs series, this time we are going to be taking a look at vectors.

If a newbie, you should think of vectors as a replacement for arrays. Any place where you would generally use an array can be swapped out by a vector. Vectors are most efficient if you are continuously adding and deleting elements.

The main difference between the two being that vectors, unlike arrays, are dynamic i.e. they can keep expanding as more data needs to be stored.

However, it must be noted that vectors consume more memory than arrays.

Show me the code💻

Iterators

These point to an address in the vector, generally the beginning or end

syntax: vector-name.begin();
        vector-name.end();

vInt.begin();
vChar.end();

Declaring a vector

syntax: vector<data-type> vector-name;

vector<int> vInt;
vector<char> vChar;

Declaring a vector with number of elements

syntax: vector<data-type> vector-name(number_of_elements);

vector<int> vInt(10);
vector<char> vChar(20);

By default, Integer vectors declared along with number of elements will be initialized with ‘0’ in each field, and Char vectors with ‘’(empty char).

Declaring with number of elements and default value

syntax: vector<data-type> vector-name(#elements, default_value);

vector<int> vInt(10, -1);
vector<char> vChar(20, 'a');

Declaring with initial values

syntax: vector<data-type> vector-name = {e1, e2, e3, e4....};

vector<int> vInt = {1, 2, 3, 4};
vector<char> vChar = {'a', 'b', 'c'};

Declaring a 2-D vector

syntax: vector<vector<data-type>> vector-name;

vector<vector<int>> vInt;
vector<vector<char>> vChar;

Initialize vector with another vector

vector<int> num = {1,2,3,4,5,6};
    
vector<int> arr(num.begin(), num.end());

Assigning one vector to another (after declaration)

vector<int> arr1, arr2;
arr1 = {num.begin(), num.end()};

arr2 = vector<int>{num.begin(), num.end()};

Initialize 2-D vector with 1-D vector

syntax: vector<vector<data-type>> vector-name(number of rows, 1-D vector);

vector<int> num = {1,2,3,4};
vector<vector<int>> vInt1(2, num);
vector<vector<int>> vInt2(2, {num.begin(), num.end()});
vector<vector<int>> vInt3(2, vector<int>(5,0));

Inserting element to the end of the vector

syntax: vector-name.push_back(element);

vInt.push_back(11);
vChar.push_back('X');

Inserting element at a specific position using iterators

num.insert(num.begin(), 2);
num.insert(num.end(), 2);

Delete an element from the end of the vector

syntax: vector-name.pop_back();

vInt.pop_back();
vChar.pop_back();

Delete all the elements in the vector

syntax: vector-name.clear();

vInt.clear();
vChar.clear();

Sorting a vector

sort(v.begin(), v.end());
sort(v.begin(), v.end(), greater<int>());

Passing a comparator like greater<int> will override the default comparator and sort the vector in descending order.

Accessing elements with []

Usage of the [] square brackets operator is the same as in an array

syntax: vector-name[index];

vInt[3];
vChat[2];

Iterating through vector using iterators

for(auto it = num.begin(); it!=num.end(); it++)
       cout<<*it<<" ";

Front() & Back()

vInt.front();
vChar.end();

These two functions return the first and the last element of the vector respectively.

Swap elements of two vectors

vector<int> a{1,2,3};
vector<int> b{4,5,6);

a.swap(b);

C++11 specific

cbegin() & cend();

vector-name.cbegin();
vector-name.cend();

These are mostly similar to begin() & end() with the only difference being that these iterators cannot be used to modify and element. They have Read-Only access.

These are most of the commonly used operations of vectors. As you can see there are quite a few things that can be done with them. So go ahead and try these out yourself!

Thanks for reading this article. Leave a clap👏 if you learnt something.

You can connect with me on through my Website or LinkedIn. Cheers!🎉

Hey! Welcome to the first chapter in the C++ STLs series. Here we will explore in depth about different STLs provided by C++

But first, What is are STLs? 😯

STL stands for Standard Template Library. It is a set of template classes that have been provided to us for easy integration of standard data structures and algorithms like linked-lists, stacks, arrays, sorting, searching etc. Read more about them here.

In this article we are going to tackle the one data-structure that has proved immensely useful for me over the years of competitive coding — unordered_map.

It can be visualized as a list in which each element in-turn contains two sub-elements — key and value. Internally it uses something called a hash-function which takes in your key value, churns it through complex equations and computes a hash-value. This hash-value is used to internally store the value provided by the user.

It is because of this hash-value that locating individual items later in the data-structure’s life-cycle becomes much faster.

This is why the average cost of search, delete and insert is O(1).

NOTE: The worst case for searching an element go up-to O(n) depending on the Hash-function used and the probability of collisions but it is very unlikely to happen with modern compilers.

Show me the code 💻

Declaring an unordered_map

syntax: unordered_map<key-datatype, value-datatype> umap-name;

unordered_map<int, int> intToInt;

unordered_map<char, int> charToInt;

Inserting elements

syntax: umap-name[key] = value;
        umap-name.insert(make_pair(key, value));

intToInt[420] = 69;
charToInt['a'] = 2;
intToInt.insert(make_pair(1,1));
charToInt.insert(make_pair('a',2));

If the value data-type is Integer, then the default value will be set to ‘0’ which can let us do interesting things like

int nums[] = {2, 3, 4, 5, 2, 3};
    
for(auto num: nums){
    intToInt[num]++;
}

The code snippet above will let us count the number of occurrences of each element using the increment operator without having to initialize the unordered_map first.

Accessing all elements of umap

for(auto it: umap){
    cout<<umap.first<<" "<<umap.second<<"\n";
}

for(auto p = umap.begin(); p!=umap.end(); p++){
    cout<<p->first<<" "<<p->second<<"\n";
}

It must be obvious but umap.first & p->first lets you access the first element or the key and umap.second & p->second lets you access the second element or the value.

Finding a key exists in unordered_map

if(umap.find(key)!=umap.end())
    cout<<key<<" was found\n";
else
    cout<<key<<" was not found\n";

umap.find(key) returns an iterator to the position of the key in the unordered_map if it exists, or umap.end() if it does not exist.

Find key and access corresponding value

auto it = umap.find(key);

if(it!=umap.end()){
    cout<<"key is: "<<it->first<<" value is: "<<it->second<<endl;
}

Erase element from unordered_map

umap.erase(key);

umap.erase(iterator);

umap.erase(iterator_begin, iterator_end);

These are most of the commonly used operations of unorderd_map. So go ahead and try these out yourself!

Thanks for reading this article. Leave a clap👏 if you learnt something.

You can connect with me on through my Website or LinkedIn. Cheers!🎉

Make your Ubuntu workflow even smoother and flex on them Windows fanbois

In this article I will quickly go through how to set custom applications to open on startup and also fix them to their predefined workspaces without the touch of a button.

First you need to select the applications you will typically use every time you boot into your Ubuntu machine. For this example I have selected Firefox Web Browser, VS Code, Spotify and Hyper(a terminal alternative that I highly recommend you check out for its looks).

So first off you need to select the Super Key, this will most likely be the Windows Key on your machine. This will bring up the Search Bar, here you need to search for “Startup Applications” and select the icon that shows up.

In the window that shows up, select Add.

You can leave the Name and Comment empty as they don’t affect its working. In the Command section you need to enter the name of the application, here are the ones I found for the apps I used -

Firefox(firefox), Spotify(spotify), Hyper(hyper), VS Code(code).

You can get more information about finding the command for your application of choice here.

Right now your selected applications will open on Startup but will all crowd on the default workspace. To have them automatically stick to separate workspaces every time they startup, we need to install a tool called Auto Move Windows.

Ubuntu 16.04 — This tool comes as a part of gnome-tweak-tool. To install it just run the following command on your terminal

sudo apt-get install gnome-tweak-tool

Ubuntu 18.04 — The tool is no longer included with gnome-tweak-tool. Instead go to Ubuntu Software and search for “Auto Move Windows”.

Next press the Super Key again and search for “Tweaks”.

Go to Extensions and Turn On “Auto Move Windows”. Click on the Settings Icon that appears next to the Turn On button.

Here you can select Add Rule and search for an application and press the ‘+’ or ‘-’ symbols to select the default workspace for that app.

After you’re done your list should looks something like this

That’s it for this article folks! Thanks for reading and do comment if you felt this was useful for you. Any pointers on things I have inadvertently gone wrong with is appreciated!

Here’s the original Ask Ubuntu post for fixing workspaces.Connect with me on Linkedin or check out my website.

Kalpan Mukherjee

Don’t forget to give me your 👏 !

In this article we shall explore the process of me and my team developing a web application to predict the probability of an electricity outage in Bangalore. Results can be reproduced in any city as long as sufficient data can be collected.

PART 1 : Putting together the data

We found publicly available unscheduled power outage data from BESCOM’s website. Though not an elegant solution, due to the website loading all the 50,000+ rows all at once, a simple Ctrl+A, Ctrl+C and Ctrl+V into an excel sheet saves us from writing an elaborate scrapping code.

Loading this into our python code is fairly straight forward. Our file is saved as BESCOM-electricity-data-outrage.xlsx.

   Sl. No.    ...     Updated By
0      1.0    ...         Sushma
1      2.0    ...         Sushma
2      3.0    ...         Sushma
3      4.0    ...         SUSHMA
4      5.0    ...      Devaraj R

[5 rows x 12 columns]

To see all the individual columns, we use

array(['Sl. No.', 'Circle', 'Division', 'Subdivision', 'Substation',
       'From', 'To', 'LC Duration', 'Feeders', 'Areas Affected',
       'Reason For LC', 'Updated By'], dtype=object)

As most of these attributes do not add a lot of information to our understanding, to make our task simpler and easier to visualize, we will only keep the columns Sl. No., Division, From and LC Duration.

           Division                From     LC Duration
0          HSR Division 2019-11-06 21:07:00  0 days 1 hours
1          HSR Division 2019-11-06 16:00:00  0 days 2 hours
2  Koramangala Division 2019-11-06 14:00:00  0 days 2 hours
3          HSR Division 2019-11-06 14:29:00  0 days 1 hours
4           Indiranagar 2019-11-06 13:00:00  0 days 2 hours

Next we need to add data about whether a particular day was a holiday or not. The intuition being that there is an increased electricity consumption on a holiday thus a higher chance of an outage. For this we first find the earliest and oldest date which is contained in our dataset.

Timestamp('2019-11-06 21:07:00')
Timestamp('2014-05-05 02:40:00')

Now we find all the public holidays within this range and add them to a separate excel sheet holidayData.xlsx.

The next step is to map these holidays into our existing dataset. For this we create another column called Holiday in our dataset and assign all the rows to zeros. Going through the dates we update the column to ‘1’ is the date appears in holidayData.xlsx.

Holiday  Division   From  LC Duration   Date                                   
    0.0     16136  16179        16179  16179
    1.0      1116   1117         1117   1117

Next we will map the population of the the various Divisions with higher population divisions having a theoretically higher chance of suffering from power outage.

First we find the list of unique Divisions

array(['HSR Division', 'Koramangala Division', 'Indiranagar',
       'Shivajinagar', 'Hebbal', 'Whitefield', 'Malleshwaram',
       'Rajaji Nagara Division', 'Jayanagar', 'Jalahalli',
       'Kengeri Division', 'R R NAGAR', 'Vidhanasoudha',
       'Peenya Division', nan], dtype=object)

We now find the estimated population for each of these regions. This task will have varied accuracy depending on if this data is publicly available. In our case the last census was done in 2011 so we have to extrapolate the population to reflect the current total population of Bangalore. As there are only 14 regions, instead of adding this data into another excel file, we will enter the values in a dictionary. Then we create another column in the dataset called Population and assign it the same values as Division. We then use the replace function in python to replace the keys in Population with the values in div_pop_dict.

0    105265.0
1    105265.0
2     63987.0
3    105265.0
4     58830.0
Name: Population, dtype: float64

Going on ahead, we have found the daily minimum and maximum temperature between the date range we mentioned before. This data is stored in weather_data_max_min.xlsx. We will load the dataset and change the datetime values into dates.

         Date  Max Temp  Min Temp
0  2014-01-01      18.7      14.8
1  2014-01-02      27.3      15.4
2  2014-01-03      27.7      13.1
3  2014-01-04      29.5      12.0
4  2014-01-05      29.6      14.1

Now we follow the same process as with the population dataset i.e. creating a dictionary with dates and temperature values and replacing outage dates with min/max temperatures.

  Max Temp Min Temp
0     34.3     15.3
1     34.3     15.3
2     34.3     15.3
3     34.3     15.3
4     34.3     15.3

These are all the features that we will be working with for this example.

We need to, now, create labels for classification. Right now we have details for the combination of features that produce and outage. However we need to feed data about which conditions do not cause outage into the model for it to properly understand the distinction and formulate rules accordingly.

How we are going to approach this particular problem is by selecting each row where we have the date and time of when and where an outage occurs, and labeling that as ‘1’ for outage. For all the other time durations, the label for the exact same combination of features except time is labelled as ‘0’ for not outage. To further illustrate this point we shall take an example:

Say the following row is selected:

Then it is labelled as ‘1’ for outage as shown below:

Notice the time when this particular outage has occurred is roughly between 2100–2200 hours. Hence we can conclude that there might have been no outage in the time duration between 0000–2100 and 2200–0000. Hence we can reproduce the row with these time durations and label them as ‘0’ for not outage. Obtaining:

As the final step before training, we need to one-hot encode the Divisions value. What this means is, the Divisions(Indiranagar, Koramangala, HSR Layout…) as such mean nothing to a computer. So we form separate columns for each of these Divisions which can have 0/1 for each row. For example, say a row is formed for the Division of Indirangar, a value of 0 in a row would mean that this particular row does not have Indiranagar as its Division and as value of 1 would indicate that it is. This lets the computer understand the data in its own terms and form better patterns. For an even in-depth understanding of One-Hot Encoding you can read this article.

This gives us the following columns where we can notice that in each row, only 1 column has the value ‘1’ denoting the division.

PART 2 : Training the data

Before training the data, we need to scale it. What this means is that different features have different ranges of values and a Neural Network generally works best is the value given as an input to it is in the range of -1 to +1 or 0 to 1. Hence we scale the individual features on their own scale to bring down all the values between a given range while keeping their intrinsic differences.

This fits the scaler to the data by finding the mean and standard deviation of the columns and then transforming the columns. When another dataset needs to be scaled to be given into the Neural Network for prediction, we should not fit the scaler again but just transform it and feed into the Neural Net.

Next up, we need to split the dataset into a training and testing set. The training set is used to train the model and the testing set is evaluate the accuracy of the model.

Now its time for us to define the Neural Network model. We have chosen a sequential model with 3 hidden layers for our job.

After defining the model, our hard work is done and now it is time to watch our model train in satisfaction:

Epoch 1/20
81987/81987 [==============================] - 3s 35us/step - loss: 0.4935 - accuracy: 0.7443
Epoch 2/20
81987/81987 [==============================] - 3s 33us/step - loss: 0.4333 - accuracy: 0.7874
Epoch 3/20
81987/81987 [==============================] - 3s 33us/step - loss: 0.4259 - accuracy: 0.7900
Epoch 4/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.4186 - accuracy: 0.7923
Epoch 5/20
81987/81987 [==============================] - 3s 32us/step - loss: 0.4147 - accuracy: 0.7949
Epoch 6/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.4121 - accuracy: 0.7977
Epoch 7/20
81987/81987 [==============================] - 3s 32us/step - loss: 0.4097 - accuracy: 0.7983
Epoch 8/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.4080 - accuracy: 0.7988
Epoch 9/20
81987/81987 [==============================] - 3s 32us/step - loss: 0.4058 - accuracy: 0.8007
Epoch 10/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.4041 - accuracy: 0.8015
Epoch 11/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.4039 - accuracy: 0.8020
Epoch 12/20
81987/81987 [==============================] - 3s 32us/step - loss: 0.4020 - accuracy: 0.8024
Epoch 13/20
81987/81987 [==============================] - 3s 32us/step - loss: 0.4004 - accuracy: 0.8043
Epoch 14/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.3989 - accuracy: 0.8046
Epoch 15/20
81987/81987 [==============================] - 3s 32us/step - loss: 0.3984 - accuracy: 0.8056
Epoch 16/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.3974 - accuracy: 0.8057
Epoch 17/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.3964 - accuracy: 0.8062
Epoch 18/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.3952 - accuracy: 0.8067
Epoch 19/20
81987/81987 [==============================] - 3s 32us/step - loss: 0.3944 - accuracy: 0.8075
Epoch 20/20
81987/81987 [==============================] - 3s 31us/step - loss: 0.3934 - accuracy: 0.8080

Testing the trained model:

20497/20497 [==============================] - 1s 34us/step
Out[80]: [0.38760558974482917, 0.7936800527572632]

We have achieved a training accuracy of around 80% and testing accuracy of around 79%. This can be bettered by tweaking the Neural Network Architecture.

That’s it for this article folks! Thanks for reading and do comment if you felt this was useful for you. This is also my first Medium article, so any pointers on things I have inadvertently gone wrong with is appreciated!

You can find the complete project on GitHub. Connect with me on Linkedin or check out my website.

Kalpan Mukherjee

Don’t forget to give me your 👏 !

Predicting Electricity Outage with Keras and Python was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.