Important_Data_Structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b5f2a7fd",
   "metadata": {},
   "source": [
    "# DATA STRUCTURES IN JULIA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d524f45c",
   "metadata": {},
   "source": [
    " There are various datatypes and datastructures in julia including Arrays,Ranges,Tuples,Dictionaries and Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db1cf1cc",
   "metadata": {},
   "source": [
    "# ARRAYS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2cf708d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are various arrays including  float,integer,strings and the type any"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8c275b27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Int64}:\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = [2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9a46cfa7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Float64}:\n",
       " 2.0\n",
       " 4.0\n",
       " 3.9\n",
       " 6.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2 = [2,4,3.9,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "72e8d20a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{String}:\n",
       " \"I\"\n",
       " \"Love\"\n",
       " \"Artificial\"\n",
       " \"Intelligence\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str_array = [\"I\",\"Love\",\"Artificial\",\"Intelligence\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "832a212e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Vector{Any}:\n",
       "  \"I\"\n",
       "  \"Love\"\n",
       "  \"Artificial\"\n",
       "  \"Intelligence\"\n",
       " 2\n",
       " 3.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi_array = [\"I\",\"Love\",\"Artificial\",\"Intelligence\",2,3.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "38ac243f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Int64}:\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5\n",
       " 6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can coerce an array to be of a certain type for instance of type : float for int\n",
    "# Lets define an array \n",
    "int_arr = [2,3,4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "83878640",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×4 Matrix{Int64}:\n",
       " 1  2  3  4\n",
       " 5  6  7  8"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2d and 3 d arrays\n",
    "multi_array = [1 2 3 4;5 6 7 8]\n",
    "# This results in a 2x2 array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "17d65e90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×4 Matrix{Int64}:\n",
       " 1  2  3  4\n",
       " 5  6  7  8\n",
       " 4  3  5  6"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi_array = [1 2 3 4;5 6 7 8;4 3 5 6]\n",
    "#3 x 4 matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d191a51b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Vector{Int64}:\n",
       " 4\n",
       " 2\n",
       " 6\n",
       " 3\n",
       " 3\n",
       " 7\n",
       " 5\n",
       " 4\n",
       " 8\n",
       " 6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing of arrays\n",
    "multi_array[3:end]\n",
    "# I have the end keyword which is really convenient for julia programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9d320615",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64[]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi_array[end:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a99d1f3",
   "metadata": {},
   "source": [
    "# TUPLES "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ff59193",
   "metadata": {},
   "source": [
    "Tuples work the same as pythonic ones in that they are immutable ,interestingly julia has named tuple features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e55ba218",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = (2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "29a0a613",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3), (4, 5))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2 = ((2,3),(4,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6d7e8793",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To access any element we can do so by indexing,take an example of if we need number 3 from t1\n",
    "t2[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b00e37e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2[1][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a5b2d1c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Science = (90, 100), Biology = (70, 100), Chemistry = (90, 100))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Naming tuples\n",
    "marks = (Science=(90,100),Biology=(70,100),Chemistry=(90,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f50c52b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(90, 100)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Interestingly we can obtain any mark like calling function or using the .,example\n",
    "marks.Science"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c31a8055",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(90, 100)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "marks.Chemistry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "71192239",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(History = (80, 100), Philosophy = (70, 100), Music = (70, 100))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Suppose we have another tuple of different subjects we can merge the two ,using the merge keyword\n",
    "marks_2 = (History=(80,100),Philosophy=(70,100),Music =(70,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "faa0b434",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(80, 100)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "marks_2.History"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7ebe3d0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Science = (90, 100), Biology = (70, 100), Chemistry = (90, 100), History = (80, 100), Philosophy = (70, 100), Music = (70, 100))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_subjects = merge(marks,marks_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7f415905",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(90, 100)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_subjects.Science"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3da7288c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70, 100)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_subjects.Philosophy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0ecc979",
   "metadata": {},
   "source": [
    "#  RANGES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cb768f69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100-element Vector{Float64}:\n",
       " 0.6405293256108352\n",
       " 0.18988461034536674\n",
       " 0.4852116256448541\n",
       " 0.08964467704031209\n",
       " 0.6800948632209172\n",
       " 0.49240792692341806\n",
       " 0.6042796365933949\n",
       " 0.9950816121243262\n",
       " 0.6664260299956195\n",
       " 0.04842937748335352\n",
       " 0.657010781752317\n",
       " 0.9551891721340231\n",
       " 0.016730875702491987\n",
       " ⋮\n",
       " 0.8879177444806603\n",
       " 0.7697235075023608\n",
       " 0.15587429180458723\n",
       " 0.5807563576561278\n",
       " 0.40550762897968695\n",
       " 0.36972231232417463\n",
       " 0.6627751690723939\n",
       " 0.9637802826210713\n",
       " 0.6451475970328127\n",
       " 0.8716610549422515\n",
       " 0.5952342129867264\n",
       " 0.7532430062553087"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Suppose you need to create a range for experimental purpose ,how do you approach that\n",
    "x = rand(100)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0a1a187f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34-element Vector{Int64}:\n",
       "   1\n",
       "   4\n",
       "   7\n",
       "  10\n",
       "  13\n",
       "  16\n",
       "  19\n",
       "  22\n",
       "  25\n",
       "  28\n",
       "  31\n",
       "  34\n",
       "  37\n",
       "   ⋮\n",
       "  67\n",
       "  70\n",
       "  73\n",
       "  76\n",
       "  79\n",
       "  82\n",
       "  85\n",
       "  88\n",
       "  91\n",
       "  94\n",
       "  97\n",
       " 100"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We use the collect keyword to get a range \n",
    "x = collect(1:3:100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "68f07e0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11-element Vector{Int64}:\n",
       "   0\n",
       "  10\n",
       "  20\n",
       "  30\n",
       "  40\n",
       "  50\n",
       "  60\n",
       "  70\n",
       "  80\n",
       "  90\n",
       " 100"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " y= collect(0:10:100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6356cb60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11-element Vector{Int64}:\n",
       " 100\n",
       "  90\n",
       "  80\n",
       "  70\n",
       "  60\n",
       "  50\n",
       "  40\n",
       "  30\n",
       "  20\n",
       "  10\n",
       "   0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If you intend to change such that you obtain 100 first ,the following is the code\n",
    "collect(100:-10:0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85bd7a51",
   "metadata": {},
   "source": [
    "# DICTIONARIES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4770823c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Symbol, Int64} with 3 entries:\n",
       "  :Car3 => 30000\n",
       "  :Car1 => 10000\n",
       "  :Car2 => 20000"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionaries are made in the key value pair format\n",
    "julia_dict = Dict(:Car1=>10000,:Car2=>20000,:Car3=>30000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "365aeaae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16-element Vector{Symbol}:\n",
       "    :Car3\n",
       " #undef\n",
       " #undef\n",
       " #undef\n",
       "    :Car1\n",
       " #undef\n",
       " #undef\n",
       " #undef\n",
       " #undef\n",
       " #undef\n",
       " #undef\n",
       "    :Car2\n",
       " #undef\n",
       " #undef\n",
       " #undef\n",
       " #undef"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operations are the same as that of the Python programming language\n",
    "julia_dict.keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "c788e784",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# haskey function to check whether a given key exists in the dictionary,true if exists else it returns false\n",
    "haskey(julia_dict,:Car1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "06c2ee8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "haskey(julia_dict,:Car4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "0935d827",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Symbol, Int64} with 2 entries:\n",
       "  :Car4 => 20990\n",
       "  :Car5 => 30000"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "julia_dict_2 = Dict(:Car4=>20990,:Car5=>30000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "31ac36fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{Symbol, Int64} with 5 entries:\n",
       "  :Car3 => 30000\n",
       "  :Car4 => 20990\n",
       "  :Car5 => 30000\n",
       "  :Car1 => 10000\n",
       "  :Car2 => 20000"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "combined_dict = merge(julia_dict,julia_dict_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "59405a10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "haskey(combined_dict,:Car7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e733b465",
   "metadata": {},
   "source": [
    "# SETS IN JULIA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "026080b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A set is a variable holder just as an array,in julia sets have been created on the principles of set theory,use the Set keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "c7620977",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Symbol} with 5 elements:\n",
       "  :Phantom\n",
       "  :Wakanda\n",
       "  :Peter\n",
       "  :Avengers\n",
       "  :DespicableMe"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "favorite_movies = Set([:Wakanda,:Avengers,:Phantom,:DespicableMe,:Peter])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "753e8e24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Symbol} with 6 elements:\n",
       "  :Grammys\n",
       "  :Spiderman\n",
       "  :Peter\n",
       "  :Infinity\n",
       "  :Interstellar\n",
       "  :DrStrange"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "favorite_movies2 = Set([:Grammys,:Peter,:Spiderman,:Infinity,:Interstellar,:DrStrange])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "61fe338b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Symbol} with 10 elements:\n",
       "  :Phantom\n",
       "  :Grammys\n",
       "  :Spiderman\n",
       "  :Infinity\n",
       "  :Avengers\n",
       "  :DespicableMe\n",
       "  :DrStrange\n",
       "  :Wakanda\n",
       "  :Peter\n",
       "  :Interstellar"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can perform unions on sets and differences,and intersections \n",
    "all_movies = union(favorite_movies,favorite_movies2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "41a79b61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Symbol} with 1 element:\n",
       "  :Peter"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersect(favorite_movies,favorite_movies2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "ea411333",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Symbol} with 4 elements:\n",
       "  :Phantom\n",
       "  :Wakanda\n",
       "  :Avengers\n",
       "  :DespicableMe"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setdiff(favorite_movies,favorite_movies2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "72d43432",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Symbol} with 5 elements:\n",
       "  :Phantom\n",
       "  :Wakanda\n",
       "  :Peter\n",
       "  :Avengers\n",
       "  :DespicableMe"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add elements into a set\n",
    "favorite_movies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "44e6f54e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Set{Symbol} with 6 elements:\n",
       "  :TaiChi\n",
       "  :Phantom\n",
       "  :Wakanda\n",
       "  :Peter\n",
       "  :Avengers\n",
       "  :DespicableMe"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "push!(favorite_movies,:TaiChi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0286e3d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca1dd801",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.5",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}