NumPy Data Analysis Challenge

Calculate Total Sales

Create a function get_total_sales(sales_data) that:

• Returns total sales across all months, stores, and categories using np.sum()
• Must return a single number (scalar)

def get_total_sales(sales_data):
    """Calculate total sales across all dimensions."""
    # Must use: np.sum() with no axis parameter
    pass

Monthly Sales Totals

Create a function get_monthly_sales(sales_data) that:

• Returns a 1D array of 12 elements (one per month)
• Each element is the total sales for that month (summed across stores and categories)
• Must use np.sum() with correct axis parameter

def get_monthly_sales(sales_data):
    """Return array of total sales per month (shape: 12,)"""
    # Must use: np.sum(sales_data, axis=(1, 2))
    pass

Store Performance Analysis

Create a function get_store_performance(sales_data) that:

• Returns a 1D array of 5 elements (one per store)
• Each element is the total annual sales for that store
• Must sum across months and categories

def get_store_performance(sales_data):
    """Return array of total sales per store (shape: 5,)"""
    # Must use: np.sum(sales_data, axis=(0, 2))
    pass

Category Performance

Create a function get_category_performance(sales_data) that:

• Returns a 1D array of 4 elements (one per category)
• Each element is the total annual sales for that category
• Must sum across months and stores

def get_category_performance(sales_data):
    """Return array of total sales per category (shape: 4,)"""
    # Must use: np.sum(sales_data, axis=(0, 1))
    pass

Calculate Growth Rates

Create a function calculate_month_over_month_growth(monthly_sales) that:

• Takes the monthly sales array from function 2
• Calculates month-over-month growth percentage
• Returns array of 11 elements (Feb growth compared to Jan, Mar to Feb, etc.)
• Formula: ((current - previous) / previous) * 100
• Must use array slicing: monthly_sales[1:] - monthly_sales[:-1]

def calculate_month_over_month_growth(monthly_sales):
    """Return array of growth percentages (shape: 11,)"""
    # Must use: slicing and element-wise operations
    pass

Find Best and Worst Performers

Create a function find_extremes(sales_data) that:

• Finds best and worst performing store indices using np.argmax() and np.argmin()
• Finds best and worst performing category indices
• Finds best and worst performing month indices
• Returns a dictionary with keys: 'best_store', 'worst_store', 'best_category', 'worst_category', 'best_month', 'worst_month'
• All values should be integer indices

def find_extremes(sales_data):
    """Return dict of best/worst indices for stores, categories, months."""
    # Must use: np.argmax(), np.argmin() on aggregated data
    pass

Calculate Statistics

Create a function calculate_statistics(sales_data) that:

• Returns a dictionary with keys: 'mean', 'median', 'std', 'min', 'max'
• All statistics calculated across entire array
• Must use: np.mean(), np.median(), np.std(), np.min(), np.max()

def calculate_statistics(sales_data):
    """Return dict of statistical measures across all data."""
    pass

Apply Broadcasting

Create a function normalize_by_store(sales_data) that:

• Normalizes each store's sales by dividing by that store's total sales
• Returns array of same shape (12, 5, 4) with normalized values
• Must use broadcasting to divide 3D array by 1D store totals

def normalize_by_store(sales_data):
    """Normalize sales by each store's total using broadcasting."""
    # Hint: store_totals = get_store_performance(sales_data)
    # Then use broadcasting to divide
    pass

Filter Data with Boolean Indexing

Create a function count_high_sales(sales_data, threshold) that:

• Counts how many sales entries exceed the given threshold
• Must use boolean indexing: sales_data > threshold
• Returns an integer count

def count_high_sales(sales_data, threshold):
    """Count entries above threshold using boolean indexing."""
    # Must use: boolean mask and np.sum()
    pass

Calculate Covariance Matrix

Create a function calculate_covariance(returns) that:

• Takes the returns array (252, 5)
• Returns the 5×5 covariance matrix using np.cov()
• Must transpose returns before passing to np.cov()

def calculate_covariance(returns):
    """Calculate covariance matrix of stock returns."""
    # Must use: np.cov(returns.T) or np.cov(returns, rowvar=False)
    pass

Calculate Correlation Matrix

Create a function calculate_correlation(returns) that:

• Returns the 5×5 correlation matrix using np.corrcoef()
• Must transpose returns before passing to np.corrcoef()

def calculate_correlation(returns):
    """Calculate correlation matrix of stock returns."""
    # Must use: np.corrcoef(returns.T) or np.corrcoef(returns, rowvar=False)
    pass

Portfolio Return Calculation

Create a function calculate_portfolio_return(returns, weights) that:

• Takes returns array (252, 5) and weights array (5,)
• Calculates daily portfolio returns using matrix multiplication: returns @ weights
• Returns 1D array of 252 daily portfolio returns

def calculate_portfolio_return(returns, weights):
    """Calculate portfolio returns using matrix multiplication."""
    # Must use: @ operator or np.dot()
    pass

Portfolio Variance

Create a function calculate_portfolio_variance(weights, cov_matrix) that:

• Calculates portfolio variance using formula: weights.T @ cov_matrix @ weights
• Returns a scalar (portfolio variance)
• Must use matrix multiplication

def calculate_portfolio_variance(weights, cov_matrix):
    """Calculate portfolio variance using quadratic form."""
    # Must use: weights @ cov_matrix @ weights
    pass

Matrix Inversion

Create a function invert_matrix(matrix) that:

• Takes a square matrix as input
• Returns its inverse using np.linalg.inv()
• If matrix is singular (non-invertible), return None
• Use try/except to handle singular matrices

def invert_matrix(matrix):
    """Invert matrix or return None if singular."""
    # Must use: np.linalg.inv() with try/except
    pass

Solve Linear System

Create a function solve_system(A, b) that:

• Solves the linear system Ax = b
• Returns the solution vector x
• Must use np.linalg.solve() (not matrix inversion)

def solve_system(A, b):
    """Solve linear system Ax = b."""
    # Must use: np.linalg.solve(A, b)
    pass

Calculate Eigenvalues

Create a function get_eigenvalues(matrix) that:

• Takes a square matrix as input
• Returns the eigenvalues sorted in descending order
• Must use np.linalg.eig() and np.sort()

def get_eigenvalues(matrix):
    """Return sorted eigenvalues (descending order)."""
    # Must use: np.linalg.eig() then sort
    pass

Matrix Determinant

Create a function calculate_determinant(matrix) that:

• Returns the determinant of a square matrix
• Must use np.linalg.det()

def calculate_determinant(matrix):
    """Calculate matrix determinant."""
    # Must use: np.linalg.det()
    pass

Matrix Transpose and Dot Product

Create a function transpose_and_multiply(A, B) that:

• Computes A.T @ B (transpose of A multiplied by B)
• Must use .T attribute and @ operator
• Returns the result matrix

def transpose_and_multiply(A, B):
    """Compute A.T @ B."""
    # Must use: A.T @ B
    pass

Create Jupyter Notebook

Create a single notebook called numpy_analytics.ipynb containing all 18 functions listed above.

• Organize your notebook with clear markdown headers for each part
• Each function must have a docstring explaining what it does
• Include test cells that demonstrate each function working
• Add markdown cells explaining your approach

Include Test Demonstrations

In your notebook, add cells that:

• Imports your numpy_analytics module
• Generates the sales and portfolio datasets
• Calls each of your 18 functions
• Prints the results clearly with labels

Create README

Create README.md that includes:

• Your name and assignment title
• Instructions to run your code
• List of all 18 functions with brief descriptions
• Any challenges you faced and how you solved them

Create requirements.txt

numpy==1.24.0

Repository Structure

Your GitHub repository should look like this:

datacorp-numpy-analytics/
├── README.md
├── requirements.txt
└── numpy_analytics.ipynb    # All 18 functions with test demonstrations

Submit via Form

Once your repository is ready:

• Make sure your repository is public or shared with your instructor
• Click the "Submit Assignment" button below
• Fill in the submission form with your GitHub repository URL