- Update main branch

Author: georgeXaguilar

bin/concept-of-the-week.txt

@@ -1 +1 @@
-content/uiux/concepts/convergent-thinking/convergent-thinking.md
+content/uiux/concepts/quantitative-research/quantitative-research.md

content/cpp/concepts/unordered-set/terms/bucket/bucket.md

@@ -0,0 +1,75 @@
+---
+Title: 'Bucket()'
+Description:  ‘Uses a hash function internally to organize elements into various “buckets” to facilitate fast lookups. Allows a programmer to inspect the internal distribution of elements.’
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Data Structures'
+  - 'Elements'
+  - 'Hash Maps'
+  - 'Sets'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+# bucket()
+
+In C++, the `bucket()` function returns the index of the bucket in which a specific element is stored within an [`unordered_set`](https://www.codecademy.com/resources/docs/cpp/unordered-set).
+
+It can be used to understand the internal hash table structure, check the distribution of elements, or implement custom traversal logic.
+
+## Syntax
+### Syntax to locate specific element
+```psuedo
+unordered_set.bucket(x);
+```
+
+**Parameters:** 
+ - `x`: The element value you are locating.
+
+**Return Value:**
+
+The `bucket()` function returns the index of the bucket containing the specified element. If the element is not present, it returns the index for the bucket where the element would be placed based on its hash value.
+
+## Example: Using .bucket() to locate a specific element
+
+```cpp
+#include <iostream>
+#include <string>
+#include <unordered_set>
+
+int main() {
+    std::unordered_set<std::string> benders = {"earth","air","water","fire"};
+
+//Find bucket index for a specific element
+    std::cout << "airbenders are in bucket: " << benders.bucket("air") << std::endl;
+
+return 0;
+}
+```
+The output for this code is: 
+```cpp
+airbenders are in bucket: 0
+``` 
+
+> **Note:** The output may vary depending on the specific C++ implementation and hash function.
+
+
+## Codebyte Example: Iterating Through a Set
+
+
+```codebyte/cpp
+#include <iostream>
+#include <string>
+#include <unordered_set>
+
+int main() {
+    std::unordered_set<std::string> houses = {"gryffindor", "hufflepuff", "slytherin", "ravenclaw"};
+      
+      for (const std::string& x: houses) {
+    std::cout << x << " house is in bucket: " << houses.bucket(x) << std::endl;
+  }
+return 0;
+}
+```

content/pytorch/concepts/tensor-operations/terms/log2/log2.md

@@ -0,0 +1,78 @@
+---
+Title: '.log2()'
+Description: 'Computes the base-2 logarithm of each element in the input tensor and returns a new tensor with the results.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Elements'
+  - 'Methods'
+  - 'PyTorch'
+  - 'Tensors'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+The **`.log2()`** method in PyTorch returns a new [tensor](https://www.codecademy.com/resources/docs/pytorch/tensors) by computing the logarithm base 2 of each element in the input tensor. This operation is useful in numerous data-science and machine-learning workflows where values are interpreted on a log scale (e.g., information theory, binary magnitude comparisons).
+
+## Syntax
+
+```pseudo
+torch.log2(input, *, out=None) → Tensor
+```
+
+**Parameters:**
+
+- `input` (Tensor): The tensor whose elements are to be transformed by base-2 logarithm.
+- `out` (Tensor, optional): A tensor to store the output; must have the same shape as input if provided.
+
+**Return value:**
+
+Returns a new tensor of the same shape as `input` where each element is `log₂(input[i])`.
+
+## Example 1: Basic Usage of `.log2()`
+
+In this example, the base-2 logarithm is computed for a tensor containing powers of 2:
+
+```py
+import torch
+
+# Define a tensor
+input_tensor = torch.tensor([2.0, 4.0, 8.0, 16.0, 32.0])
+
+# Compute base-2 logarithm
+output_tensor = torch.log2(input_tensor)
+
+print(output_tensor)
+```
+
+The output of this code is:
+
+```shell
+tensor([1., 2., 3., 4., 5.])
+```
+
+## Example 2: Applying `.log2()` on Random Values
+
+In this example, a tensor with random positive values is transformed using base-2 logarithm to analyze data on a log scale:
+
+```py
+import torch
+
+# Generate a tensor of random positive values
+data = torch.rand(5) * 10 + 1
+
+# Apply log2 transformation
+log_tensor = torch.log2(data)
+
+print(data)
+print(log_tensor)
+```
+
+The output of this code is:
+
+```shell
+tensor([10.5500,  9.2777, 10.9371,  1.3551,  5.2609])
+tensor([3.3992, 3.2138, 3.4512, 0.4384, 2.3953])
+```