#Array Shape Manipulation

import numpy as np

# Create arrays of different shapes
array_1d = np.array([1, 2, 3, 4, 5, 6])
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
array_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

print("1D array:")
print(f"Array: {array_1d}")
print(f"Shape: {array_1d.shape}")
print(f"Dimensions: {array_1d.ndim}")
print(f"Size: {array_1d.size}")
print()

print("2D array:")
print(f"Array:\n{array_2d}")
print(f"Shape: {array_2d.shape}")
print(f"Dimensions: {array_2d.ndim}")
print(f"Size: {array_2d.size}")
print()

print("3D array:")
print(f"Array:\n{array_3d}")
print(f"Shape: {array_3d.shape}")
print(f"Dimensions: {array_3d.ndim}")
print(f"Size: {array_3d.size}")

import numpy as np

# Create 1D array
array_1d = np.arange(12)
print("Original 1D array:", array_1d)
print("Shape:", array_1d.shape)
print()

# Reshape to 2D array
array_2d_3x4 = array_1d.reshape(3, 4)
print("Reshaped to 3x4:")
print(array_2d_3x4)
print("Shape:", array_2d_3x4.shape)
print()

array_2d_4x3 = array_1d.reshape(4, 3)
print("Reshaped to 4x3:")
print(array_2d_4x3)
print("Shape:", array_2d_4x3.shape)
print()

# Reshape to 3D array
array_3d = array_1d.reshape(2, 2, 3)
print("Reshaped to 2x2x3:")
print(array_3d)
print("Shape:", array_3d.shape)
print()

# Auto-calculate dimension using -1
auto_reshape = array_1d.reshape(3, -1)  # Auto-calculate columns
print("Auto-calculate dimension (3, -1):")
print(auto_reshape)
print("Shape:", auto_reshape.shape)

auto_reshape2 = array_1d.reshape(-1, 4)  # Auto-calculate rows
print("Auto-calculate dimension (-1, 4):")
print(auto_reshape2)
print("Shape:", auto_reshape2.shape)

import numpy as np

array = np.arange(12)
print("Original array:", array)

# Reshape must preserve total element count
try:
    # This will error because 3*5 = 15 ≠ 12
    wrong_reshape = array.reshape(3, 5)
except ValueError as e:
    print(f"Error: {e}")

# Correct reshape
correct_reshape = array.reshape(3, 4)
print("Correct reshape:")
print(correct_reshape)
print()

# Reshape returns view, not copy
original = np.arange(6)
reshaped = original.reshape(2, 3)

print("Original array:", original)
print("Reshaped array:")
print(reshaped)
print("Shares memory:", np.shares_memory(original, reshaped))

# Modifying reshaped array affects original
reshaped[0, 0] = 999
print("After modifying reshaped:")
print("Original:", original)
print("Reshaped:")
print(reshaped)

import numpy as np

# Create 2D array
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Original 2D array:")
print(array_2d)
print()

# flatten() - returns copy
flattened = array_2d.flatten()
print("flatten() result:", flattened)
print("Shares memory:", np.shares_memory(array_2d, flattened))

# Modifying flatten result doesn't affect original
flattened[0] = 999
print("After modifying flatten result:")
print("Original:", array_2d)
print("flatten result:", flattened)
print()

# ravel() - returns view (if possible)
array_2d = np.array([[1, 2, 3], [4, 5, 6]])  # Recreate
raveled = array_2d.ravel()
print("ravel() result:", raveled)
print("Shares memory:", np.shares_memory(array_2d, raveled))

# Modifying ravel result affects original
raveled[0] = 888
print("After modifying ravel result:")
print("Original:", array_2d)
print("ravel result:", raveled)

import numpy as np

array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Original array:")
print(array_2d)
print()

# C-style flattening (row-major, default)
c_order = array_2d.flatten('C')
print("C-style flatten (row-major):", c_order)

# Fortran-style flattening (column-major)
f_order = array_2d.flatten('F')
print("Fortran-style flatten (column-major):", f_order)

# Demo 3D array flattening
array_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print("\n3D array:")
print(array_3d)
print("Shape:", array_3d.shape)

print("C-style flatten:", array_3d.flatten('C'))
print("F-style flatten:", array_3d.flatten('F'))

import numpy as np

# 2D array transpose
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Original array:")
print(array_2d)
print("Shape:", array_2d.shape)
print()

# Using .T attribute
transposed_T = array_2d.T
print("Using .T transpose:")
print(transposed_T)
print("Shape:", transposed_T.shape)
print()

# Using transpose() method
transposed_method = array_2d.transpose()
print("Using transpose() method:")
print(transposed_method)
print("Shape:", transposed_method.shape)
print()

# Using np.transpose() function
transposed_func = np.transpose(array_2d)
print("Using np.transpose() function:")
print(transposed_func)
print("Shape:", transposed_func.shape)

import numpy as np

# 3D array transpose
array_3d = np.arange(24).reshape(2, 3, 4)
print("Original 3D array:")
print(array_3d)
print("Shape:", array_3d.shape)
print()

# Default transpose (reverses all axes)
default_transpose = array_3d.T
print("Default transpose:")
print(default_transpose)
print("Shape:", default_transpose.shape)
print()

# Specify axis order for transpose
# Original axis order: (0, 1, 2) -> New order: (2, 0, 1)
custom_transpose = array_3d.transpose(2, 0, 1)
print("Custom transpose (2, 0, 1):")
print(custom_transpose)
print("Shape:", custom_transpose.shape)

import numpy as np

# Create sample arrays
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
array3 = np.array([7, 8, 9])

print("Array 1:", array1)
print("Array 2:", array2)
print("Array 3:", array3)
print()

# Horizontal concatenation (1D arrays)
hstack_result = np.hstack([array1, array2, array3])
print("Horizontal concatenation:", hstack_result)

# Vertical concatenation (creates 2D array)
vstack_result = np.vstack([array1, array2, array3])
print("Vertical concatenation:")
print(vstack_result)
print()

# Using concatenate
concat_result = np.concatenate([array1, array2, array3])
print("concatenate result:", concat_result)

import numpy as np

# Create 2D arrays
array2d_1 = np.array([[1, 2], [3, 4]])
array2d_2 = np.array([[5, 6], [7, 8]])

print("Array 1:")
print(array2d_1)
print("Array 2:")
print(array2d_2)
print()

# Horizontal concatenation (along columns)
hstack_2d = np.hstack([array2d_1, array2d_2])
print("Horizontal concatenation:")
print(hstack_2d)
print()

# Vertical concatenation (along rows)
vstack_2d = np.vstack([array2d_1, array2d_2])
print("Vertical concatenation:")
print(vstack_2d)
print()

# Using concatenate with axis
concat_axis0 = np.concatenate([array2d_1, array2d_2], axis=0)
print("Concatenate along axis 0 (rows):")
print(concat_axis0)
print()

concat_axis1 = np.concatenate([array2d_1, array2d_2], axis=1)
print("Concatenate along axis 1 (columns):")
print(concat_axis1)

import numpy as np

# Create 2D arrays
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])

print("Array 1:")
print(array1)
print("Array 2:")
print(array2)
print()

# Depth concatenation (along third axis)
dstack_result = np.dstack([array1, array2])
print("Depth concatenation:")
print(dstack_result)
print("Shape:", dstack_result.shape)
print()

# Using stack to create new axis
stack_axis0 = np.stack([array1, array2], axis=0)
print("Stack along axis 0:")
print(stack_axis0)
print("Shape:", stack_axis0.shape)
print()

stack_axis1 = np.stack([array1, array2], axis=1)
print("Stack along axis 1:")
print(stack_axis1)
print("Shape:", stack_axis1.shape)

import numpy as np

# 1D array splitting
array_1d = np.arange(12)
print("Original array:", array_1d)
print()

# Equal split
split_equal = np.split(array_1d, 3)  # Split into 3 equal parts
print("Split into 3 equal parts:")
for i, part in enumerate(split_equal):
    print(f"  Part {i+1}: {part}")
print()

# Split at specified points
split_points = np.split(array_1d, [3, 7])  # Split at indices 3 and 7
print("Split at indices 3 and 7:")
for i, part in enumerate(split_points):
    print(f"  Part {i+1}: {part}")
print()

# Using array_split (allows unequal splits)
array_split_result = np.array_split(array_1d, 5)  # Split into 5 parts (unequal)
print("Unequal split into 5 parts:")
for i, part in enumerate(array_split_result):
    print(f"  Part {i+1}: {part}")

import numpy as np

# Create 2D array
array_2d = np.arange(24).reshape(4, 6)
print("Original 2D array:")
print(array_2d)
print("Shape:", array_2d.shape)
print()

# Horizontal split (along columns)
hsplit_result = np.hsplit(array_2d, 3)  # Split into 3 columns
print("Horizontal split (3 columns):")
for i, part in enumerate(hsplit_result):
    print(f"  Part {i+1}:")
    print(part)
print()

# Vertical split (along rows)
vsplit_result = np.vsplit(array_2d, 2)  # Split into 2 rows
print("Vertical split (2 rows):")
for i, part in enumerate(vsplit_result):
    print(f"  Part {i+1}:")
    print(part)

import numpy as np

# Create 1D array
array_1d = np.array([1, 2, 3, 4, 5])
print("Original 1D array:", array_1d)
print("Shape:", array_1d.shape)
print()

# Add dimension
# Using np.newaxis
array_row = array_1d[np.newaxis, :]  # Add row dimension
array_col = array_1d[:, np.newaxis]  # Add column dimension

print("Add row dimension:")
print(array_row)
print("Shape:", array_row.shape)
print()

print("Add column dimension:")
print(array_col)
print("Shape:", array_col.shape)
print()

# Using np.expand_dims
expand_axis0 = np.expand_dims(array_1d, axis=0)
expand_axis1 = np.expand_dims(array_1d, axis=1)

print("expand_dims axis=0:")
print(expand_axis0)
print("Shape:", expand_axis0.shape)
print()

print("expand_dims axis=1:")
print(expand_axis1)
print("Shape:", expand_axis1.shape)
print()

# Remove dimensions
array_with_extra_dim = np.array([[[1, 2, 3, 4, 5]]])
print("Array with extra dimensions:")
print(array_with_extra_dim)
print("Shape:", array_with_extra_dim.shape)

# Using squeeze to remove length-1 dimensions
squeezed = np.squeeze(array_with_extra_dim)
print("After removing extra dimensions:")
print(squeezed)
print("Shape:", squeezed.shape)

import numpy as np

# Create 3D array
array_3d = np.arange(24).reshape(2, 3, 4)
print("Original 3D array:")
print(array_3d)
print("Shape:", array_3d.shape)
print()

# Swap axes
swapped = np.swapaxes(array_3d, 0, 2)  # Swap axis 0 and axis 2
print("Swap axis 0 and axis 2:")
print(swapped)
print("Shape:", swapped.shape)
print()

# Move axis
moved = np.moveaxis(array_3d, 0, -1)  # Move axis 0 to last position
print("Move axis 0 to last:")
print(moved)
print("Shape:", moved.shape)

import numpy as np

# Simulate RGB image data (height, width, channels)
height, width, channels = 4, 6, 3
image = np.random.randint(0, 256, (height, width, channels), dtype=np.uint8)

print(f"Original image shape: {image.shape}")
print(f"Image data type: {image.dtype}")
print("Image data (first 2 rows):")
print(image[:2])
print()

# Convert to different channel order (HWC -> CHW)
image_chw = np.transpose(image, (2, 0, 1))
print(f"Converted to CHW format: {image_chw.shape}")
print()

# Extract single channel
red_channel = image[:, :, 0]
green_channel = image[:, :, 1]
blue_channel = image[:, :, 2]

print(f"Red channel shape: {red_channel.shape}")
print("Red channel data:")
print(red_channel)
print()

# Recombine channels (change order: RGB -> BGR)
bgr_image = np.stack([blue_channel, green_channel, red_channel], axis=2)
print(f"BGR image shape: {bgr_image.shape}")
print()

# Batch processing (add batch dimension)
batch_size = 2
batch_images = np.stack([image, image], axis=0)  # Duplicate image to create batch
print(f"Batch images shape: {batch_images.shape}")

# Flatten image for machine learning
flattened_image = image.reshape(-1, channels)  # Flatten to (pixels, channels)
print(f"Flattened image shape: {flattened_image.shape}")

import numpy as np

# Simulate time series data: 30 days, 24 hours each, 3 sensors
days, hours, sensors = 30, 24, 3
data = np.random.normal(20, 5, (days, hours, sensors))  # Temperature data

print(f"Original data shape: {data.shape}")
print(f"Data range: {data.min():.1f} - {data.max():.1f}")
print()

# Reorganize data: group by sensor
sensor_data = np.transpose(data, (2, 0, 1))  # (sensors, days, hours)
print(f"Grouped by sensor: {sensor_data.shape}")

# Calculate daily averages for each sensor
daily_averages = np.mean(sensor_data, axis=2)  # Average over hours dimension
print(f"Daily averages shape: {daily_averages.shape}")
print("Sensor 1 first 5 days averages:", daily_averages[0, :5])
print()

# Reorganize to weekly data (assuming starting Monday)
weeks = days // 7
weekly_data = data[:weeks*7].reshape(weeks, 7, hours, sensors)
print(f"Weekly data shape: {weekly_data.shape}")

# Calculate weekly averages
weekly_averages = np.mean(weekly_data, axis=(1, 2))  # Average over days and hours
print(f"Weekly averages shape: {weekly_averages.shape}")
print("Weekly averages per sensor:")
for week in range(weeks):
    print(f"  Week {week+1}: {weekly_averages[week]}")
print()

# Flatten data for statistical analysis
flat_data = data.reshape(-1, sensors)
print(f"Flattened data shape: {flat_data.shape}")
print("Overall statistics per sensor:")
for i in range(sensors):
    sensor_values = flat_data[:, i]
    print(f"  Sensor {i+1}: mean={np.mean(sensor_values):.2f}, "
          f"std={np.std(sensor_values):.2f}")

import numpy as np

# Create matrices
matrix_a = np.array([[1, 2, 3], [4, 5, 6]])
matrix_b = np.array([[7, 8], [9, 10], [11, 12]])

print("Matrix A:")
print(matrix_a)
print(f"Shape: {matrix_a.shape}")
print()

print("Matrix B:")
print(matrix_b)
print(f"Shape: {matrix_b.shape}")
print()

# Matrix multiplication
matrix_product = np.dot(matrix_a, matrix_b)
print("Matrix product A × B:")
print(matrix_product)
print(f"Shape: {matrix_product.shape}")
print()

# Transpose in matrix operations
# A^T × A (commonly used in least squares)
ata = np.dot(matrix_a.T, matrix_a)
print("A^T × A:")
print(ata)
print(f"Shape: {ata.shape}")
print()

# Create symmetric matrix
symmetric = np.array([[1, 2, 3], [2, 4, 5], [3, 5, 6]])
print("Symmetric matrix:")
print(symmetric)
print("Is symmetric:", np.allclose(symmetric, symmetric.T))

import numpy as np
import time

# Create large arrays to test performance
size = 1000
array_c = np.random.random((size, size))
array_f = np.asfortranarray(array_c)  # Fortran order

print(f"C-order array flag: {array_c.flags['C_CONTIGUOUS']}")
print(f"Fortran-order array flag: {array_f.flags['F_CONTIGUOUS']}")
print()

# Test row access performance
start_time = time.time()
for i in range(100):
    _ = array_c[i, :].sum()  # Access rows
c_row_time = time.time() - start_time

start_time = time.time()
for i in range(100):
    _ = array_f[i, :].sum()  # Access rows
f_row_time = time.time() - start_time

print(f"C-order row access time: {c_row_time:.4f} seconds")
print(f"F-order row access time: {f_row_time:.4f} seconds")
print()

# Test column access performance
start_time = time.time()
for i in range(100):
    _ = array_c[:, i].sum()  # Access columns
c_col_time = time.time() - start_time

start_time = time.time()
for i in range(100):
    _ = array_f[:, i].sum()  # Access columns
f_col_time = time.time() - start_time

print(f"C-order column access time: {c_col_time:.4f} seconds")
print(f"F-order column access time: {f_col_time:.4f} seconds")