Skip to content

Chapter 21: Math for AI - Using System.Math for Sigmoids and Distance

Theoretical Foundations

In the previous chapters, you learned how to store data in variables and manipulate them using arithmetic operators. You learned how to make decisions using if statements and how to repeat actions using loops. In Chapter 20, you learned to manage dynamic collections using List<T>. Now, we transition into the mathematical foundations required for Artificial Intelligence (AI). AI is, at its core, a series of mathematical operations performed on data. To build AI algorithms, we need precise, reliable tools for calculation. This is where System.Math becomes essential.

The Real-World Analogy: The Carpenter's Calculator

Imagine you are a carpenter. In previous chapters, you learned how to hammer nails (basic arithmetic) and saw wood (loops and logic). You can build a simple box. However, to build a complex structure like a house, you need more than just a hammer; you need a precise calculator and a level.

System.Math is that calculator. It provides pre-built, highly optimized functions for complex mathematical tasks. Instead of trying to invent a new way to calculate the square root of a number (which is mathematically complex and prone to error), you use the Math.Sqrt() function provided by C#. This allows you to focus on the structure of your AI (the logic) rather than the mechanics of the math.

Why Math is Critical for AI

In AI, we often deal with "features"—these are individual pieces of data (like the price of a house, the temperature in a room, or the pixel intensity of an image). To make these features useful for an AI model, we often need to transform them.

  1. Normalization: Data often comes in vastly different ranges. For example, house prices might range from 50,000 to 1,000,000, while the number of bedrooms ranges from 1 to 5. An AI model struggles to compare these directly. We use math to scale them down to a common range (like 0 to 1).
  2. Activation Functions: In neural networks (a type of AI), we need to decide if a neuron should "fire" or not. We use mathematical functions like the Sigmoid to squash a number between 0 and 1, representing a probability.
  3. Distance Measurement: To classify data, AI often looks at how "close" a new data point is to existing known data points. We calculate this using geometry, specifically Euclidean distance.

Accessing System.Math

To use the math functions, you don't need to create a new instance of a class. As you learned in Chapter 19, System.Math is a static class. This means all its methods are shared and available globally. You simply need to reference the System namespace at the top of your file.

using System;

class Program
{
    static void Main()
    {
        // We can now use Math methods directly
        double result = Math.Sqrt(16.0); // result is 4.0
    }
}

Core Mathematical Functions

Let's explore the specific functions allowed in this chapter and how they apply to AI logic.

1. Absolute Values (Math.Abs)

The absolute value removes the negative sign from a number, returning its magnitude.

  • Mathematical Definition: \(|x|\)
  • C# Syntax: Math.Abs(number)

Why AI needs this: In AI, errors are often calculated as the difference between a prediction and the actual value. This difference can be positive or negative. However, when calculating the total error (like "Mean Absolute Error"), we don't care if the prediction was too high or too low—only how far off it was. We sum the absolute values of these errors.

double actualTemperature = 25.5;
double predictedTemperature = 23.0;

double error = actualTemperature - predictedTemperature; // 2.5
double absoluteError = Math.Abs(error); // 2.5

// If predicted was 28.0, error would be -2.5, but Abs makes it 2.5.

2. Exponents and Powers (Math.Pow)

This function raises a number to a specified power.

  • Mathematical Definition: \(x^y\)
  • C# Syntax: Math.Pow(base, exponent)

Why AI needs this: Exponents are used everywhere in AI, particularly in statistics and probability.

  • Squaring: Used in calculating variance and standard deviation (measuring how spread out data is).
  • e^x: The natural exponential function is the heart of the Sigmoid activation function (which we will build later).

Example: If you need to calculate the squared distance between two points (a fundamental concept in geometry), you square the difference.

double difference = 5.0;
double squaredDifference = Math.Pow(difference, 2); // 25.0

3. Square Roots (Math.Sqrt)

The square root function finds the number that, when multiplied by itself, gives the original number.

  • Mathematical Definition: \(\sqrt{x}\)
  • C# Syntax: Math.Sqrt(number)

Why AI needs this: Square roots are essential for calculating Euclidean Distance. Imagine two points on a graph: Point A at (1, 2) and Point B at (4, 6). To find the straight-line distance between them, we use the Pythagorean theorem: \(c = \sqrt{a^2 + b^2}\).

AI uses this to determine how similar two data points are. If the distance is small, the points are similar.

double xDiff = 3.0; // 4 - 1
double yDiff = 4.0; // 6 - 2

// First, square the differences
double xSquared = Math.Pow(xDiff, 2); // 9
double ySquared = Math.Pow(yDiff, 2); // 16

// Add them together
double sumOfSquares = xSquared + ySquared; // 25

// Take the square root to get the distance
double distance = Math.Sqrt(sumOfSquares); // 5.0

Building AI Components with System.Math

Now, let's combine these concepts to build two critical AI components: the Sigmoid Activation and Euclidean Distance.

The Sigmoid Activation Function

In AI, a neuron often outputs a number based on its input. However, raw numbers can be very large or very small (e.g., -5000 or +5000). We need to map these numbers to a probability range between 0 and 1. The Sigmoid function does this perfectly.

The Formula: $\(S(x) = \frac{1}{1 + e^{-x}}\)$ Where \(e\) is Euler's number (approximately 2.71828).

Implementation: We can calculate \(e^{-x}\) using Math.Pow(Math.E, -x).

using System;

public class ActivationFunctions
{
    public static double Sigmoid(double x)
    {
        // Calculate e raised to the power of -x
        // Math.E is a constant representing Euler's number
        double eToThePowerOfNegativeX = Math.Pow(Math.E, -x);

        // Calculate the denominator: 1 + e^-x
        double denominator = 1.0 + eToThePowerOfNegativeX;

        // Return 1 divided by the denominator
        return 1.0 / denominator;
    }
}

Usage in AI Logic: If a neuron has an input of 2.0, the Sigmoid output is 0.88. If the input is -2.0, the output is 0.11. This allows the AI to say, "I am 88% confident this is true."

Euclidean Distance

As mentioned earlier, AI often classifies data by finding the "nearest neighbor." We do this by calculating the distance between the new data point and existing data points.

Let's write a method that takes two points (represented as arrays of double) and returns the distance between them.

Logic Steps:

  1. Ensure both points have the same number of dimensions (e.g., both are 2D or both are 3D).
  2. Loop through each dimension.
  3. Calculate the difference, square it, and add it to a running total.
  4. Take the square root of the total.
using System;

public class Geometry
{
    // We assume point1 and point2 have the same length (dimensions)
    public static double CalculateEuclideanDistance(double[] point1, double[] point2)
    {
        double sumOfSquares = 0.0;

        // We use a for loop to iterate through each dimension (x, y, z, etc.)
        // This relies on knowledge from Chapter 9 (for loops) and Chapter 11 (Arrays)
        for (int i = 0; i < point1.Length; i++)
        {
            double difference = point1[i] - point2[i];
            double squaredDifference = Math.Pow(difference, 2);
            sumOfSquares += squaredDifference;
        }

        // Finally, take the square root of the sum
        return Math.Sqrt(sumOfSquares);
    }
}

Data Normalization

Before feeding data into an AI model, it is best practice to normalize it. This ensures that one feature (like salary) doesn't overpower another (like age) simply because the numbers are larger.

Min-Max Normalization: This technique scales all values to a range of 0 to 1. $\(x' = \frac{x - \min(x)}{\max(x) - \min(x)}\)$

Implementation: To do this, we need to find the minimum and maximum values in a dataset. We can use Math.Min and Math.Max (which are part of System.Math), or we can calculate them manually using loops.

Let's write a method that normalizes an array of values. We will need to find the min and max first.

using System;

public class Normalizer
{
    public static double[] Normalize(double[] data)
    {
        // 1. Find Min and Max
        double min = data[0];
        double max = data[0];

        // Loop through the array to find the actual min and max
        for (int i = 1; i < data.Length; i++)
        {
            // We can use Math.Min and Math.Max here
            min = Math.Min(min, data[i]);
            max = Math.Max(max, data[i]);
        }

        // 2. Calculate the range
        double range = max - min;

        // 3. Create a new array to hold normalized values
        double[] normalizedData = new double[data.Length];

        // 4. Apply the formula to each element
        for (int i = 0; i < data.Length; i++)
        {
            // (x - min) / range
            normalizedData[i] = (data[i] - min) / range;
        }

        return normalizedData;
    }
}

Combining Concepts: A Simple Decision Logic

Let's look at a practical example using these math functions to make a decision. Imagine we are building a simple AI that decides whether to approve a loan based on a "risk score."

  1. We calculate a raw score (this might come from complex calculations).
  2. We normalize the score to be between 0 and 1 using a Sigmoid-like logic or simple scaling.
  3. We use Math.Abs to check if the applicant's financial history is too volatile.
using System;

public class LoanDecision
{
    public static void MakeDecision(double rawScore, double volatility)
    {
        // 1. Normalize the raw score using Sigmoid
        // We use the Sigmoid method defined earlier (conceptually)
        // For this example, let's inline the math:
        double probability = 1.0 / (1.0 + Math.Pow(Math.E, -rawScore));

        // 2. Check volatility using Absolute Value
        // If volatility is high (e.g., 10.0), we penalize the score
        double volatilityPenalty = Math.Abs(volatility) * 0.1;

        // 3. Adjust probability
        double finalScore = probability - volatilityPenalty;

        // 4. Make decision using logical operators (Chapter 7)
        if (finalScore > 0.5)
        {
            Console.WriteLine($"Approved (Score: {finalScore:F2})");
        }
        else
        {
            Console.WriteLine($"Denied (Score: {finalScore:F2})");
        }
    }
}

Visualizing the Math Flow

The following diagram illustrates how data flows through these mathematical operations in a typical AI preprocessing step.

This diagram illustrates the AI's decision-making flow, where an input score is formatted and passed through a conditional branch to output either an Approved or Denied message to the console.
Hold "Ctrl" to enable pan & zoom

This diagram illustrates the AI's decision-making flow, where an input score is formatted and passed through a conditional branch to output either an Approved or Denied message to the console.

Summary of Allowed Concepts Used

In this section, we strictly adhered to the concepts introduced in the previous chapters:

  1. Variables (Chapter 2): We used double to store decimal numbers for precision.
  2. Arithmetic (Chapter 4): We used +, -, /, and * to combine results.
  3. Methods and Parameters (Chapters 13 & 14): We defined static methods like Sigmoid and CalculateEuclideanDistance that accept parameters and return values.
  4. Arrays and Loops (Chapters 11, 9, & 12): We used arrays (double[]) to store data points and for loops to iterate through them for calculations.
  5. If/Else Statements (Chapter 6): We used logic to make decisions based on the calculated math values.
  6. System.Math (Chapter 21): We utilized Math.Pow, Math.Sqrt, Math.Abs, and the constant Math.E.

By mastering these mathematical primitives, you now possess the tools to handle the numerical data that drives all modern AI applications.

Basic Code Example

Let's build a simple AI decision-maker. Imagine you are programming a video game. You have an enemy character that needs to decide if it should attack or retreat. This decision will be based on its "Health" and its "Aggression" level.

To make this decision, we will use a mathematical concept called a Sigmoid Function. Don't worry about the complex name; mathematically, it is simply a way to take any number and squish it between a minimum and a maximum value (usually 0 and 1).

We will use the System.Math library to perform the heavy lifting for us.

Here is the complete code. It calculates an "Attack Probability" based on the enemy's stats.

using System;

class GameLogic
{
    static void Main()
    {
        // --- 1. Define the Enemy's Stats ---
        // We use 'double' because we need precise decimal numbers for probability.
        double currentHealth = 25.5;
        double aggressionLevel = 80.0;
        double maxHealth = 100.0;

        // --- 2. Calculate the Input Value (x) ---
        // We want a value that increases as health gets LOW and aggression gets HIGH.
        // We use subtraction (maxHealth - currentHealth) so that low health results in a higher number.
        // We use Division to normalize the values relative to the max health.
        double rawValue = (maxHealth - currentHealth) / maxHealth + (aggressionLevel / 100.0);

        // --- 3. Apply the Sigmoid Function ---
        // Formula: 1 / (1 + e^-x)
        // e is Euler's number (approx 2.71828). We get it using Math.E.
        // We use Math.Pow(base, exponent) to calculate e raised to the power of -rawValue.
        double exponent = -1.0 * rawValue;
        double sigmoidOutput = 1.0 / (1.0 + Math.Pow(Math.E, exponent));

        // --- 4. Make a Decision ---
        // If the sigmoid output is greater than 0.5, the enemy attacks.
        // We format the output to 2 decimal places using F2 in the string interpolation.
        if (sigmoidOutput > 0.5)
        {
            Console.WriteLine($"Enemy Attacks! (Probability: {sigmoidOutput:F2})");
        }
        else
        {
            Console.WriteLine($"Enemy Retreats! (Probability: {sigmoidOutput:F2})");
        }
    }
}

Code Breakdown

Here is how the logic flows, step-by-step:

  1. Variable Initialization: We set up currentHealth (25.5), aggressionLevel (80.0), and maxHealth (100.0). We use double types because int would chop off the decimals, making our probability calculation inaccurate.

  2. Calculating rawValue: This is the input to our math function. We perform (maxHealth - currentHealth) / maxHealth. Since currentHealth is 25.5, maxHealth - currentHealth is 74.5. Divided by 100.0, this is roughly 0.745. We add the aggression (80.0 / 100.0 = 0.8). The total rawValue is roughly 1.545.

  3. The Math.Pow Method: We need to calculate \(e^{-1.545}\).

    • Math.E gives us the constant 2.71828...
    • Math.Pow(base, exponent) raises the base to the power of the exponent.
    • We calculate Math.Pow(Math.E, -1.545).

  4. The Division: We perform 1.0 / (1.0 + ...) to finalize the sigmoid formula. This squishes our raw value (1.545) into a result between 0 and 1.

  5. The Decision: We use an if statement (Chapter 6) to compare the result. Since the result (approx 0.82) is greater than 0.5, the code enters the first block and prints the attack message.

Common Pitfalls

1. Integer Division Truncation If you declare maxHealth as an int (e.g., int maxHealth = 100;) and perform maxHealth - currentHealth, the result is a double. However, if you later divide by another int, C# might perform integer division, dropping the decimal entirely.

  • The Fix: Always use the decimal point (e.g., 100.0) or explicitly cast variables to double when doing division to ensure you keep the precision needed for AI calculations.

2. The "Divide by Zero" Risk In the formula 1.0 / (1.0 + Math.Pow(Math.E, exponent)), the denominator is 1.0 + .... Since Math.Pow always returns a positive number, the denominator will never be zero. However, if you modify the formula to subtract the power instead of adding it, you could eventually hit a scenario where the denominator becomes 0. Always ensure your denominator is strictly positive or handled safely.

3. Negative Exponents Remember that we calculated exponent = -1.0 * rawValue. If you forget the negative sign, you will calculate \(e^{1.545}\) instead of \(e^{-1.545}\). This will result in a massive number, and the final division 1.0 / (1.0 + hugeNumber) will result in a tiny number close to 0. This would invert your logic: a highly aggressive, low-health enemy would be calculated as wanting to retreat!

The chapter continues with advanced code, exercises and solutions with analysis, you can find them on the ebook on Leanpub.com or Amazon

Code License: All code examples are released under the MIT License. Github repo.

Content Copyright: Copyright © 2026 Edgar Milvus | Privacy & Cookie Policy. All rights reserved.

All textual explanations, original diagrams, and illustrations are the intellectual property of the author. To support the maintenance of this site via AdSense, please read this content exclusively online. Copying, redistribution, or reproduction is strictly prohibited.