Merge branch 'main' into isunordered/abey1

Author: abey1

content/numpy/concepts/ndarray/terms/byteswap/byteswap.md

@@ -0,0 +1,117 @@
+---
+Title: 'byteswap()'
+Description: 'Swaps the byte order of each element in a NumPy ndarray.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Array'
+  - 'Data'
+  - 'NumPy'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`byteswap()`** method reverses the byte order of every element in a NumPy array. This is used when converting data between systems with different endianness (byte-ordering conventions). The operation either returns a new array or modifies the original one in place when `inplace=True`.
+
+## Syntax
+
+```pseudo
+ndarray.byteswap(inplace=False)
+```
+
+**Parameters:**
+
+- `inplace` (optional): When set to `True`, the byte order of the existing array is swapped in place. When `False`, a new array with swapped bytes is returned.
+
+**Return value:**
+
+Returns a new ndarray with swapped byte order, unless `inplace=True`, in which case the original array is modified and returned.
+
+## Example 1
+
+In this example, the array's byte order is swapped to convert the data into the opposite endianness:
+
+```py
+import numpy as np
+
+arr = np.array([1, 256, 1024], dtype=np.int32)
+
+print("Original array:")
+print(arr)
+print("Original dtype:", arr.dtype)
+
+swapped = arr.byteswap()
+
+print("\nAfter byteswap():")
+print(swapped)
+print("Swapped dtype:", swapped.dtype)
+```
+
+The output of this code is:
+
+```shell
+Original array:
+[   1  256 1024]
+Original dtype: int32
+
+After byteswap():
+[16777216    65536   262144]
+Swapped dtype: int32
+```
+
+## Example 2
+
+This example demonstrates `byteswap(inplace=True)` and shows how the original data is altered directly:
+
+```py
+import numpy as np
+
+arr = np.array([100, 200, 300], dtype=np.int32)
+
+print("Before inplace byteswap:", arr)
+
+arr.byteswap(inplace=True)
+
+print("After inplace byteswap:", arr)
+```
+
+The output of this code is:
+
+```shell
+Before inplace byteswap: [100 200 300]
+After inplace byteswap: [1677721600 -939524096  738263040]
+```
+
+## Codebyte Example
+
+Use the codebyte below to inspect how `byteswap()` affects a 2-D array and observe the internal memory representation change:
+
+```codebyte/python
+import numpy as np
+
+matrix = np.array([[1, 2], [3, 4]], dtype=np.int16)
+
+print("Original:")
+print(matrix)
+
+swapped = matrix.byteswap()
+
+print("\nByteswapped:")
+print(swapped)
+```
+
+## Frequently Asked Questions
+
+### 1. What is the function of byteswap() in Python?
+
+The `byteswap()` method reverses the byte order of every element in a NumPy array. It is commonly used when preparing data for systems with different endianness or when interpreting binary data from external sources.
+
+### 2. What are bytes and bytearrays in Python?
+
+A `bytes` object in Python is an immutable sequence of byte values, while a bytearray is a mutable version of the same concept. Both store raw binary data and are often used for file handling, networking, and low-level memory operations.
+
+### 3. How to shuffle a NumPy ndarray?
+
+A NumPy array can be shuffled using `np.random.shuffle()` for in-place row-wise shuffling or `np.random.permutation()` to return a shuffled copy. These functions randomize the order of elements while preserving the array’s structure.

content/pytorch/concepts/tensor-operations/terms/logical-or/logical-or.md

@@ -0,0 +1,100 @@
+---
+Title: '.logical_or()'
+Description: 'Computes the element-wise logical OR between two tensors.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Booleans'
+  - 'PyTorch'
+  - 'Tensor'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.logical_or()`** function performs an element-wise logical OR operation between two [tensors](https://www.codecademy.com/resources/docs/pytorch/tensors). Each input value is converted to a Boolean value (zero → `False`, non-zero → `True`) before the operation. The output is a Boolean tensor where each element is `True` if at least one of the corresponding input elements is `True`.
+
+## Syntax
+
+```pseudo
+torch.logical_or(input, other, out)
+```
+
+**Parameters:**
+
+- `input`: A tensor whose elements are treated as Boolean.
+- `other`: A tensor broadcastable with input.
+- `out` (optional): A tensor to store the result.
+
+**Return value:**
+
+Returns a Boolean tensor where each element is `True` if at least one of the corresponding input elements is `True`.
+
+## Example 1
+
+In this example, `.logical_or()` evaluates pairs of values from two 2-D tensors and returns a Boolean matrix showing which positions satisfy the OR condition:
+
+```py
+import torch
+
+a = torch.tensor([[0, 1], [2, 0]])
+b = torch.tensor([[3, 0], [0, 5]])
+
+result = torch.logical_or(a, b)
+
+print("Tensor A:\n", a)
+print("\nTensor B:\n", b)
+print("\nA OR B:\n", result)
+```
+
+The output of this code is:
+
+```shell
+Tensor A:
+ tensor([[0, 1],
+        [2, 0]])
+
+Tensor B:
+ tensor([[3, 0],
+        [0, 5]])
+
+A OR B:
+ tensor([[True, True],
+        [True, True]])
+```
+
+## Example 2
+
+In this example, a 1-D tensor is combined with a scalar using broadcasting to show how `.logical_or()` can apply a Boolean condition efficiently across all elements:
+
+```py
+import torch
+
+x = torch.tensor([0, 4, 0, 7])
+y = torch.tensor(1)  # scalar
+
+result = torch.logical_or(x, y)
+
+print(result)
+```
+
+The output of this code is:
+
+```shell
+tensor([True, True, True, True])
+```
+
+## Frequently Asked Questions
+
+### 1. What are the tensor operations in PyTorch?
+
+Tensor operations in PyTorch include arithmetic, logical operations, reductions, reshaping, indexing, broadcasting, and matrix operations. These operations run efficiently on CPU or GPU and form the core building blocks of neural network workflows.
+
+### 2. Why use tensor instead of NumPy?
+
+Tensors support automatic differentiation and execute seamlessly on GPUs, which makes them suited for deep learning workloads. They also integrate tightly with PyTorch's computation graph, while NumPy arrays operate only on the CPU and lack gradient support.
+
+### 3. What does cpu() do in PyTorch?
+
+The `.cpu()` method moves a tensor or model from a GPU device to the system’s CPU. This is useful for running operations on hardware without CUDA support or preparing data for libraries that operate only on CPU-based arrays.