2.Diziler-Matrisler.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diziler,Matrisler ve Kullanılabilecek Diğer Fonksiyonlar\n",
    "Dizi ve matrisler alışkın olduğumuz **[]** köşeli parantez yapısı ile belirtilmiş.  \n",
    "Dizi tanımı ise **Array{Tip,(boyut))** şeklinde: burada tip **Any**, **String**, **Char**, **Int64**, **Float64** vb. tipleri temsil ederken boyut 1 ile n'e kadar olan tuple listesi ile temsil edilir.  \n",
    "Dizi tanımlarken açık olarak tipte belirtebiliriz:\n",
    "- Tip[tip_eleman1,tip_eleman2]\n",
    "- Tip[] #boş tip dizisi\n",
    "Örneğin:  \n",
    "- dizi1D=[1,2,3]\n",
    "    - Array{Int64,1} türünde bir dizi döndürür.\n",
    "- matris2D=[1.0 2 3; **reshape(rand(3)*10,(1,3))**]\n",
    "    - Array{Float64,2} türünde 1x3 matris döndürür. Dizi oluşturulurken arada boşluk bırakılması sütunları temsil eder. \n",
    "    - Sütunlardan sonra ; işareti ile alt satıra geçilir.\n",
    "    - **rand(boyut,boyut,..) ya da rand(sayi)*** : *sayi* kadar ya da *boyut x boyut x boyut x ..* boyutlarında  [0,1] aralığında değerler döndürür.\n",
    "        - Kardeşi diyebileceğimiz **randn(boyut,boyut,...) ya da randn(sayi)** ise normal dağılımlı (ortalaması=0, standart sapması=1 olan değerler döndürür.\n",
    "        - Buradaki (1,3); 1,3 şeklinde de yazılabilirdi.\n",
    "- dizi_dizisi=[[1,2,3,4],collect(4:7)]\n",
    "    - Array{Array{Int64,1},1} - Dizi tipli bir dizi  \n",
    "    - **collect()** range objelerini array olarak döndürür\n",
    "        - Bunun diğer bir yöntemi de [baslangic:(adim:)son...] olarak yazılmasıdır.\n",
    "    - **Range (aralık)** objeleri *baslangic:adım:son* olarak belirlenebilir.\n",
    "        - Bu objeler **for** yapılarında ya da dizi oluşturmada kolaylık sağlar\n",
    "        - Son geri dönen sıralı diziye dahildir.\n",
    "- dizi_comprehension = [ i+j for i in 1:5, j in 1:10]\n",
    "    - Lambda fonksiyonlarına benzer bir dille yazılan bu ifadelere comprehension deniyor.\n",
    "        - [ işlem for birinci_par in (range|iterable), ikinci_par in (range|iterable),...]\n",
    "- size(dizi veya matris) : (satır,sütun)\n",
    "- ndims(dizi veya matris) : boyut döndürür\n",
    "- **reshape(array,(boyut1,boyut2,..))** verilen diziyi boyut şeklinde sütun ve satır yapısına dönüştürür.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Array{Int64,1}:\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  4\n",
       "  5\n",
       "  6\n",
       "  7\n",
       "  8\n",
       "  9\n",
       " 10"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#=\n",
    "for rakam in 1:10 \n",
    "    print(rakam)\n",
    "end\n",
    "=#\n",
    "\n",
    "# for rakam in 1:10 print(rakam) end\n",
    "#sizce rakamlar ne ile dolu? \n",
    "#ipucu: \";\" işaretini kaldırın veya typeof(rakamlar)\n",
    "rakamlar=[println(rakam) for rakam in 1:10];\n",
    "#typeof(rakamlar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Int64,1}"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizi1D=[1,2,3];\n",
    "matris2D=[1.0 2 3; reshape(rand(3)*10,1,3)];\n",
    "dizi_dizisi=[[1,2,3,4],collect(4:7)]; \n",
    "dizi_comprehension = [ i+j for i in 1:5, j in 1:10]\n",
    "string_dizi=[\"bu\",\"bir\",\"string\",\"dizisidir\"];\n",
    "intdizi=Int64[1,2,4];\n",
    "dizi1D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×3 Array{Float64,2}:\n",
       " 1.0      2.0      3.0\n",
       " 5.89789  6.09755  9.00343"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matris2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Array{Int64,1},1}:\n",
       " [1, 2, 3, 4]\n",
       " [4, 5, 6, 7]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizi_dizisi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×10 Array{Int64,2}:\n",
       " 2  3  4  5   6   7   8   9  10  11\n",
       " 3  4  5  6   7   8   9  10  11  12\n",
       " 4  5  6  7   8   9  10  11  12  13\n",
       " 5  6  7  8   9  10  11  12  13  14\n",
       " 6  7  8  9  10  11  12  13  14  15"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizi_comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{String,1}:\n",
       " \"bu\"\n",
       " \"bir\"\n",
       " \"string\"\n",
       " \"dizisidir\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_dizi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 4"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intdizi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dizi verilerine ulaşma, veri ekleme ve çıkarma\n",
    "Python tarzı bir index yöntemi var.  İndeksler 1 ile başlar.\n",
    "a=Float64[1.0, 2.0, 3.0]\n",
    "- a[[2,3]] # 2.0 3.0\n",
    "- pop!(dizi) : son elementi çıkar # [1.0, 2.0]\n",
    "- popfirst!(dizi) : ilk elementi çıkar # [2.0]\n",
    "- push!(a,1) # [2.0, 1.0]\n",
    "- pushfirst!(a,2) # [2.0, 2.0, 1.0]\n",
    "- append!(dizi1,dizi2) veya append!(dizi,değer)\n",
    "- deleteat!(dizi,silinecek_element_idx)\n",
    "- sort(dizi,by=func) : dizi'nin sıralanmış halini döndür ama diziyi değiştirme\n",
    "- sort!(dizi) : sırala ve diziyi değiştir\n",
    "- deger in dizi *veya* in(değer,dizi) : *deger* dizide var mı yok mu\n",
    "- join(dizi, ayrac) : dizi degerlerini arasına ayrac koyarak cıkar \n",
    "- dizi[1:end] : dizinin sonuna kadar al\n",
    "- shuffle(!)(dizi) : karıştırmak için ama ilk önce Random kütüphanesi yüklenmeli. \n",
    "- isempty(dizi) , empty!(dizi) : dizi boş mu? , diziyi boşalt\n",
    "- findall(koşul,dizi) : koşula uyan değerleri döndür. # findall(x -> x==aranan_değer, dizi)\n",
    "- firstindex() / lastindex()\n",
    "- length(a) : boyutların çarpımı ile gelen uzunluk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "2.7740931007094094\n"
     ]
    }
   ],
   "source": [
    " for i in (dizi_dizisi[1][1],intdizi[3],matris2D[2,3])\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tipik dizi türleri içinde fonksiyonlar vardır:\n",
    "- zeros((Tip),boyut1,boyut2,...)\n",
    "- ones((Tip,)boyut1,boyut2,...)\n",
    "- trues(boyut1,boyut2,...) , falses(boyut1,boyut2,...)\n",
    "Dizileri doldurmak içinde *fill(doldurulacak_item,(boyutlar))* fonksiyonu kullanılır.\n",
    "Ya da *repeat(dizi,(boyutlar))* şeklinde diziyi boyutlar içerisinde yayabiliriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Array{Int64,2}:\n",
       " 2  2\n",
       " 2  2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "birler=fill(1,2,2) # ya da ones(Int,2,2)\n",
    "fill!(birler,2) \n",
    "# Ünlem işareti özel bir operatördür. \n",
    "# Bir fonksiyonun sonunda ! var ise bu önceden belirlenmiş bir değişkenin fonksiyondan dönen değerler ile değişeceğini işaret eder.\n",
    "birler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 2.0\n",
       " 6.097552280307632"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matris2D[:,2] #ikinci sütunu al"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 1.0\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matris2D[1,:] #birinci satırı al"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Güzel bir örnek olarak şu verilebilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×5 Array{Int64,2}:\n",
       " 8  2  2  10   8\n",
       " 5  4  6   4  10\n",
       " 4  5  5   2   2\n",
       " 6  6  3  10   4\n",
       " 5  9  5   8   5"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=rand(1:10,(5,5)) #random 1:10 arası değerler ile 5x5 matris oluştur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×5 BitArray{2}:\n",
       " 0  0  0  0  0\n",
       " 1  0  0  0  0\n",
       " 0  1  1  0  0\n",
       " 0  0  0  0  0\n",
       " 1  0  1  0  1"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.==5 #A matrisinde değerleri 5 olanları bul ve true false matrisi döndür"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×5 Array{Int64,2}:\n",
       " 8  2  2  10   8\n",
       " 6  4  6   4  10\n",
       " 4  6  6   2   2\n",
       " 6  6  3  10   4\n",
       " 6  9  6   8   6"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[A.==5].=6; #true false ile seçili olan indisleri 6 yap\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matris ve vektör işlemleride yine $+,*,-, '$ (Transpose) vb. operatörleri ile yapılabilmektedir. Boyutların işlem için geçerli olmasına dikkat edin yeter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([8 8; 12 12], [2 2; 9 9])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A,B= [2 2; 3 3], [1 1; 3 3];\n",
    "matrisCarpım,elementselCarpım= A*B, A.*B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vektör ve matrisleri birleştirmek için **hcat(matris veya vektör,matris veya vektör) ve vcat(matris veya vektör,matris veya vektör)** fonksiyonları kullanılır. \n",
    "- [A;B] = vcat(A,B) # v dikey (vertical)\n",
    "- [A B] = hcat(A,B) # h yatay (horizontal)\n",
    "- [A B; C D;] = hvcat()\n",
    "- Eğer bir matrisi vektöre dönüştürmek isterseniz **vec(matris)** kullanılabilir."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.1",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}