{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Логические операции, булевые маски\n",
    "\n",
    "## Сравнение массивов NumPy\n",
    "\n",
    "Операторы сравнения `<`, `<=`, `>`, `>=`, `==` и `!=` перегружены для массивов `numpy` и работают аналогичные правила, как и для арифметических операторов:\n",
    "- выполняется поэлементное сравнение;\n",
    "- формы должны или совпадать или быть совместимы (`broadcastable`).\n",
    "\n",
    "Результатом операции сравнения является `ndarray` наиболее общей формы, содержащий булевые значения `True` и `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n",
      "[[False False False False]\n",
      " [False False False  True]\n",
      " [ True  True  True  True]\n",
      " [ True  True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "A = np.arange(16).reshape(4, 4)\n",
    "print(A)\n",
    "print(A >= 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В отличие от встроенных в python булевых значений, логические операции \"**И**\", \"**ИЛИ**\" и \"**НЕ**\" (логическое отрицание) осуществляются операторами `|`, `&` и `~`, а не ключевыми словами `and`, `or` и `not`. \n",
    "\n",
    "```{note}\n",
    "В самом python операторы `|`, `&` и `~` определенны для целых чисел и представляют из себя побитовые операции.\n",
    "```\n",
    "\n",
    "Логическое  \"**И**\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False],\n",
       "       [False,  True,  True,  True],\n",
       "       [ True,  True,  True, False],\n",
       "       [False, False, False, False]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A > 4) & (A < 11) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Логическое \"**ИЛИ**\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True],\n",
       "       [False, False, False, False],\n",
       "       [False, False, False, False],\n",
       "       [ True,  True,  True,  True]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A < 4) | (A > 11) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Логическое отрицание:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False False]\n",
      " [False False False False]\n",
      " [ True  True  True  True]\n",
      " [ True  True  True  True]]\n",
      "[[ True  True  True  True]\n",
      " [ True  True  True  True]\n",
      " [False False False False]\n",
      " [False False False False]]\n"
     ]
    }
   ],
   "source": [
    "mask = A > 7\n",
    "print(mask)\n",
    "print(~mask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Индексация булевымы массивами\n",
    "\n",
    "Такая булевые массивы могут быть использованы для индексации. Это часто используется для фильтрации значений и т.п."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 8  9 10 11 12 13 14 15]\n"
     ]
    }
   ],
   "source": [
    "print(A[A > 7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  8  9 10 11 12 13 14 15]\n"
     ]
    }
   ],
   "source": [
    "print(A[(A<3) | (A>7)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При этом допускается даже присваивание. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3]\n",
      " [4 5 6 7]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "A[A > 7] = 0\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно индексировать булевыми масками вдоль осей. Например, оставить только строки, напротив которых стоит `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3],\n",
       "       [4, 5, 6, 7],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1dmask = np.array([True, True, False, True])\n",
    "A[a1dmask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Или аналогично со столбцами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 3],\n",
       "       [4, 5, 7],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:, a1dmask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## np.any и np.all\n",
    " \n",
    "Функции [np.any](https://numpy.org/doc/stable/reference/generated/numpy.any.html) и [np.all](https://numpy.org/doc/stable/reference/generated/numpy.all.html) принимают на вход булевый массив и агрегируют значения в нем:\n",
    "- `np.any` возвращает `True`, если хотя бы один из элементов массива `True` или приводится к `True`; \n",
    "- `np.all` возвращает `True`, если все элементы массива `True` или приводятся к `True`. \n",
    "\n",
    "По поведению эти функции похожи на функции на функции `np.sum` и `np.prod`. Они также принимают опциональный аргумент `axis`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False False]\n",
      " [False False False False]\n",
      " [ True  True  True  True]\n",
      " [ True  True  True  True]]\n",
      "any: True\n",
      "all: False\n"
     ]
    }
   ],
   "source": [
    "print(mask)\n",
    "print(f\"any: {np.any(mask)}\")\n",
    "print(f\"all: {np.all(mask)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True,  True])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(mask, axis=1)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "8617202e12f254480e1fae3258716b685f1a56bcbf234a446366b4fd3345ed22"
  },
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}