<![CDATA[ Math - freeCodeCamp.org ]]> https://www.freecodecamp.org/news/ https://cdn.freecodecamp.org/universal/favicons/favicon.png <![CDATA[ Math - freeCodeCamp.org ]]> https://www.freecodecamp.org/news/ Eleventy Sat, 30 May 2026 11:14:47 +0000 60 <![CDATA[ How Does Cosine Similarity Work? The Math Behind LLMs Explained ]]> https://www.freecodecamp.org/news/how-does-cosine-similarity-work/ 68cb5c87b90c34f2f16f5703 Thu, 18 Sep 2025 01:12:39 +0000 When you talk to a large language model (LLM), it feels like the model understands meaning. But under the hood, the system relies on numbers, vectors, and math to find the relationships between words and sentences.

One of the most important tools that makes this possible is cosine similarity. If you want to know how an LLM can judge that two sentences mean almost the same thing, cosine similarity is the key.

This article explains cosine similarity in plain language, shows the math behind it, and connects it to the way modern language models work. By the end, you will see why this simple idea of measuring angles between vectors powers search, chatbots, and many other AI systems.

Table of Contents

What Is Cosine Similarity?

Imagine you have two sentences. To a computer, they are not words but vectors, a long lists of numbers that capture meaning.

Cosine similarity measures how close these two vectors are, not by their length, but by the angle between them.

Cosine Similarity

Think of two arrows starting from the same point. If they point in the same direction, the angle between them is zero, and cosine similarity is one. If they point in opposite directions, the angle is 180 degrees, and cosine similarity is negative one. If they are at a right angle, the cosine similarity is zero.

So, cosine similarity tells us whether two vectors are pointing in the same general direction. In language tasks, this means it tells us whether two pieces of text carry a similar meaning.

The Math Behind Cosine Similarity

To understand cosine similarity, we need to look at a bit of math. The cosine of an angle in geometry is the ratio between the dot product of two vectors and the product of their magnitudes. Written as a formula, cosine similarity looks like this:

cosine_similarity(A, B) = (A · B) / (||A|| * ||B||)

Here:

  • A · B is the dot product of vectors A and B.

  • ||A|| is the magnitude (length) of vector A.

  • ||B|| is the magnitude of vector B.

The dot product multiplies corresponding numbers in the two vectors and adds them up. The magnitude of a vector is like finding the length of an arrow, using the Pythagorean theorem.

This formula always gives a value between -1 and 1. A value close to 1 means the vectors are pointing in nearly the same direction. A value close to 0 means they are unrelated. A value close to -1 means they are opposite.

A Simple Example

Let’s see a short example using Python. Suppose you want to check how similar two short texts are. We can use scikit-learn to turn them into vectors and then compute cosine similarity.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

texts = [
    "I love machine learning",
    "I love deep learning"
]

vectorizer = TfidfVectorizer().fit_transform(texts)
vectors = vectorizer.toarray()

similarity = cosine_similarity([vectors[0]], [vectors[1]])
print("Cosine similarity:", similarity[0][0])

The code starts by importing two important tools. TfidfVectorizer is responsible for turning text into numbers, while cosine_similarity measures how similar two sets of numbers are. Together, they let us compare text in a way a computer can understand.

Next, we define the sentences we want to compare. In this example, we use “I love machine learning” and “I love deep learning.” These two sentences share some words such as “I,” “love,” and “learning,” while differing in one word: “machine” versus “deep.” This makes them good examples to test, because they are clearly related but not exactly the same.

The vectorizer then builds a vocabulary from all the unique words across the two sentences. For these inputs, the vocabulary becomes ["deep", "learning", "love", "machine"]. This means the program now has a list of all the words it will track when building the numerical representation of the sentences.

Each sentence is then converted into a vector, which is simply a list of numbers. These numbers are not just raw word counts. Instead, they are weighted using TF-IDF, which stands for Term Frequency–Inverse Document Frequency.

TF-IDF gives more importance to words that matter in a sentence and less importance to very common words. In simplified form, the first sentence becomes something like [0. 0.50154891 0.50154891 0.70490949], while the second becomes [0.70490949 0.50154891 0.50154891 0. ]. The numbers may look small, but what matters is their relative values.

The .toarray() method then converts these vectors into standard Python arrays. This makes them easier to handle, since the TF-IDF output is stored in a special sparse format by default.

Once the sentences are represented as vectors, cosine similarity is applied. This step checks the angle between the two vectors.

If the vectors point in exactly the same direction, their similarity score will be one. If they are unrelated, the score will be close to zero. If they point in opposite directions, the score will be negative.

In this case, because the two sentences share most of their words, the vectors point in a similar direction, so the cosine similarity falls somewhere around 0.5 to 0.7.

In simple terms, this code shows how a computer can compare two sentences by turning them into vectors of numbers and then checking how close those vectors are. By using cosine similarity, the program can judge not just whether the sentences share words, but also how strongly they overlap in meaning.

Cosine Similarity in Embeddings

In practice, LLMs like GPT or BERT do not use simple word counts. Instead, they use embeddings.

An embedding is a dense vector that captures meaning. Each word, phrase, or sentence is turned into a set of numbers that place it in a high-dimensional space.

In this space, words with similar meaning are close together. For example, the embeddings for “king” and “queen” are closer than the embeddings for “king” and “table.”

Cosine similarity is the tool that allows us to measure how close two embeddings are. When you search for “dog,” the system can look for embeddings that point in a similar direction. That way, it finds results about “puppy,” “canine,” or “pet” even if those exact words are not in your query.

How LLMs Use Cosine Similarity

Large language models use cosine similarity in many ways. When you ask a question, the model encodes your input into a vector. It then compares this vector with stored knowledge or with candidate answers using cosine similarity.

For semantic search, cosine similarity helps rank documents. A system can embed all documents into vectors, then embed your query and compute similarity scores. The documents with the highest scores are the most relevant.

In clustering, cosine similarity helps group sentences that have related meaning. In recommendation systems, it helps match users to items by comparing their preference vectors.

Even when generating answers, LLMs rely on vector similarity to decide which words or phrases best follow in context. Cosine similarity gives the model a simple but powerful way to measure closeness of meaning.

Limits of Cosine Similarity

While cosine similarity is powerful, it has limits. It depends heavily on the quality of embeddings. If embeddings fail to capture meaning well, similarity scores may not reflect real-world closeness.

Also, cosine similarity only measures direction. Sometimes, magnitude contains useful information too. For example, a sentence embedding might have a length that reflects confidence. By ignoring it, cosine similarity may lose part of the picture.

Still, despite these limits, cosine similarity remains one of the most widely used methods in natural language processing.

Why It Matters for LLMs

Cosine similarity is not just a math trick. It is a bridge between human language and machine understanding. It allows a model to treat meaning as geometry, turning questions and answers into points in space.

Without cosine similarity, embeddings would be less useful, and tasks like semantic search, clustering, and ranking would be harder. By reducing the problem to measuring angles, we make meaning measurable and usable.

Every time you search on Google, chat with an AI, or use a recommendation engine, cosine similarity is at work behind the scenes.

Conclusion

Cosine similarity explains how LLMs judge the closeness of meaning between words, sentences, or even whole documents. It works by comparing the angle between vectors, not their length, which makes it ideal for text. With embeddings, cosine similarity becomes the foundation of semantic search, clustering, recommendations, and many other tasks in natural language processing.

The next time an AI gives you an answer that feels “close enough,” remember that a simple mathematical idea, measuring the angle between two arrows, is doing much of the heavy lifting.

Hope you enjoyed this article. Signup for my free AI newsletter TuringTalks.ai for more hands-on tutorials on AI. You can also find visit my website.

]]> <![CDATA[ The Architecture of Mathematics – And How Developers Can Use it in Code ]]> https://www.freecodecamp.org/news/the-architecture-of-mathematics-and-how-developers-can-use-it-in-code/ 68308ee8ccde6bc325c82393 Fri, 23 May 2025 15:06:16 +0000

"To understand is to perceive patterns." - Isaiah Berlin

Math is not just numbers. It is the science of finding complex patterns that shape our world. This means that to truly understand it, we need to see beyond numbers, formulas, and theorems and understand its structures.

The main goal of this article is to show how math is just like a growing tree of ideas. I want to show that math is a living system of logic, not just formulas to memorize. With analogies, history, and code examples, I want to help you understand math more deeply and how you can apply it to programming.

I’ve also included some code examples here to help you connect theory and practice. I show them to demonstrate how math ideas are applied to real problems. Whether you are new to more advanced math or are more experienced, these code examples will help you understand how to apply math in programming.

This link across theory and application reflects my own studies. I am a finalist in an undergraduate degree in Electrical and Computer Engineering at NOVA FCT, one of the best engineering faculties in Portugal.

My engineering degree is one with more math and physics. This is because it’s key to get a solid grasp of math to understand electronics, telecommunications, control theory, and other areas of engineering.

Here’s a brief overview of some of the math and physics subjects I’ve learned:

  • Partial Differential Equations (PDEs): These equations model real-world phenomena, from heat diffusion to the economy of a country.

  • Harmonic Analysis (Fourier & Laplace): Integral transforms like the Fourier and Laplace transform allow us to understand problems in new domains.

  • Complex Analysis: Extending calculus into the complex plane gives rise to powerful tools used in physics and engineering.

  • Numerical Analysis: When analytical solutions are impossible or inefficient, numerical methods provide computer-based approximations. This is crucial for real-world applications.

  • Control and Signal Theory: These areas show us how to design stable systems like rockets, trains, and robots.

  • Physics: Courses in Classical Mechanics and Electromagnetism helped bridge theoretical math to physical laws

During my years of study, besides technical skills, I’ve developed a deeper understanding of how the world works and the structure of the field of mathematics. And I’ve started to find patterns in how math is a framework of interconnected logic.

In this article, we’ll explore:

Simple Analogy: The Tree of Mathematics

Photo of two trees by Johannes Plenio: https://www.pexels.com/photo/two-brown-trees-1632790/

Imagine math as a vast tree growing forever.

The roots of the tree are the foundations of mathematics: logic and set theory. From this foundation emerge the main basic fields of math: arithmetic, algebra, geometry, and analysis.

As the tree divides further and further into more branches, new, more complex subfields start to appear, like topology, abstract algebra, and complex analysis. Sometimes the branches are connected to each other.

And remember: this tree is always growing in many directions. From branches creating new branches to branches connecting to other branches. Little by little, it grows.

Throughout history, there have been times that, due to some big scientific discoveries, parts of the math tree started to grow very fast. Other times, decades and even centuries passed without many new branches. This is the case for imaginary numbers, for example.

And you might wonder: How many more branches and connections between them will keep appearing?

The Structure and History of Mathematics

Photo of a writing desk and notebook on Pixabay: https://www.pexels.com/photo/brown-wooden-desk-159618/

The first mathematical ideas appeared independently across ancient civilizations. For example:

  • India’s invention of zero

  • Islamic algebraic advances

  • Greek geometric rigor

Over time, many different great mathematicians created and shared them by writing and giving lectures.

Eventually, these new ideas were shared widely with new generations and these new generations created new math based on old math.

This is is how new branches are continuously born from previous branches of the tree of mathematics.

And this is why Isaac Newton wrote, in a letter to Robert Hooke in 1675:

If I have seen further, it is by standing on the shoulders of giants

He meant that by working from previous knowledge, he was able to create and (re)discover new ideas.

Yet, the real power of math lies in practicing it over and over and understanding it more and more deeply. As one of my professors once explained:

More important than knowing the theorems is knowing the ideas behind them and the history of how they were created.

Very often, to solve problems, it is necessary to think in terms of first principles and build from there. Math teaches exactly that. In this way, math is not just an academic subject. It is a language spoken by scientists and engineers around the globe.

By having it well preserved and shared, it is still possible to create new math from previous ideas. And it’s possible for the big tree to continue growing based on previous branches or nodes.

An Tree example: Foundations of Relativity by Albert Einstein

Albert Einstein, one of the greatest physics giants in history

Albert Einstein created the general and special theories of relativity. These have big consequences nowadays:

  • GPS and Global Communication

  • Advancements in Satellite Telecommunications

  • Space Exploration and Satellite Launches

But this was only possible through the unification of geometry with calculus, called differential geometry. The evolution of differential geometry happened over the centuries, thanks to many great mathematicians. Below are some of them, but this is not a complete list:

  • Euclid (circa 300 BCE): Contributed to geometry, laying the groundwork for later mathematical systems

  • Archimedes (circa 287–212 BCE): Pioneered the understanding of volume, surface area, and the principles of mechanics

  • René Descartes (1596–1650): Developed Cartesian coordinates and analytical geometry

  • Isaac Newton (1642–1727) & Gottfried Wilhelm Leibniz (1646–1716): Newton’s laws of motion and gravitation, alongside Leibniz’s development of calculus, formed the basis of classical mechanics that Einstein sought to extend and modify in his theory of relativity.

  • Leonhard Euler (1707–1783): Contributed to the development of differential equations, which are essential in the mathematical foundations of physics.

  • Gaspard Monge (1746–1818): The father of differential geometry and pioneer in descriptive geometry

  • Carl Friedrich Gauss (1777–1855): Made groundbreaking advances in geometry, including the concept of curved surfaces.

  • Bernhard Riemann (1826–1866): Introduced Riemannian geometry, a branch of differential geometry.

Once again, as Isaac Newton wrote, in a letter to Robert Hooke in 1675:

If I have seen further, it is by standing on the shoulders of giants.

Albert Einstein saw what no one else in his time saw, thanks to these great math giants and countless others.

The Biggest Paradox of Math, Discovered by Kurt Gödel

Kurt Gödel, one of the greatest math giants in history

The biggest paradox in math, in my opinion, is what Kurt Gödel discovered. His early 20th century research revealed a limitation within this cycle.

This paradox – that is, his incompleteness theorems – shows that in any consistent formal system capable of expressing simple arithmetic, there will always be true mathematical statements that cannot be proven within the system itself.

This means that in ALL systems, there are limits to what you can actually prove as to what is true and false. For for mathematicians, this means that the tree will never be completed. There are truths that are beyond formal truths, and yet we still assume that they are true (albeit unproven).

This way, it proves that no matter how many mathematicians work in the field or how much AI is used to find new mathematics, there will always exist limitations. Some things are impossible to prove that are true, and we just know that they are due to approximation estimations and other non logical exact methods.

What About Applied Math and Engineering?

Photo by JESHOOTS.com: https://www.pexels.com/photo/person-holding-a-chalk-in-front-of-the-chalk-board-714699/

Applied math and engineering involves interpreting the same pure math ideas in real-world scenarios. Actually, in many cases, it is the combination of many math ideas. Let’s consider some examples:

Principal component analysis (PCA) is a widely used tool in data science. Yet, it is a mixture of linear algebra (in PCA, eigenvalues) with optimization (order eigenvalues that represent more data with less data) in order to make datasets shorter.

In machine learning, logistic regression is a mixture of calculus with statistics and probability.

In harmonic analysis, Laplace, Fourier, and Z-transforms are a way to see the same thing in a new domain to get new insights. In this case, integrals are used to make this mapping.

In deep learning, neural networks are just many matrices multiplying and updating themselves that adapt to model a dataset representing a system. This optimization of matrix values happens with activation functions, a gradient descent-based optimization method (tells how much values need to change), and backpropagation (applies those alterations to all matrix values).

I have actually written an article where I teach why activation functions are important if you want to check it out.

But the best example of this fusion of math with engineering is in control theory.

Control theory is the study of the architecture of systems. From trains to cars to airplanes, everything is based on control theory. It is everywhere in nearly all modern electronic devices. In electric circuits, control theory is also used heavily to guarantee circuit stability in the face of electric disturbances.

So as you can probably start to see, many of the tools we now have are just a mixture of many pure math ideas. Just many combinations and recipes of pure math ideas. In essence, applied math is the application of pure math as “ingredients“ in "recipes" to solve problems.

So, we’ve explored the structure and evolution of mathematics. Yet, it is important to see how these ideas can be applied in real life. Pure math makes the framework, and applied math applies that framework to solve problems. To understand this, we’ll examine two code examples that show how you can use math ideas as programming tools.

Code Examples – Analytical and Numerical Approaches

These code examples demonstrate a couple ways you can use Python to solve math equations.

In the first code example, we’ll solve the problem in the same way that kids in school solve math exercises: essentially, by hand with a pencil. Moving variables from left to right to find their values. In the second example, we’ll solve the problem using numerical analysis.

Example 1: Solve a Problem Analytically

When we solve math problems analytically, like we did in school, we are manipulating symbols to get exact values. Often there symbols are x, y and z. In Python, we can do this using the SymPy library:

from sympy import symbols, Eq, solve

x, y = symbols('x y')
eq1 = Eq(2*x + 3*y, 6)
eq2 = Eq(-x + y, 1)

solution = solve((eq1, eq2), (x, y))
print(solution)

7a21cddc-f4ba-4f9f-afa0-d1cc11fb27d6

Essentially, we are finding x and y based on this equation:

$$\begin{align*} 2x + 3y &= 6 \\ -x + y &= 1 \end{align*}$$

Which gives us the following result:

{x: 3/5, y: 8/5}

Or:

  • x= 0.6

  • y = 1.6

When we say that we’re solving this analytically, it means that we’re finding an exact mathematical solution using formulas or equations.

But many times, problems are harder and can be solved by adding symbols to the right or left of the equation.

Sometimes, there can be so many symbols and transformed versions of them, with things like derivatives and integrals, that it can become very hard to manage and takes a lot of time.

For this reason, there is an area of mathematics devoted to finding approximations of already created mathematical formulas called numerical analysis. It makes it faster to solve these problems. And this is the method we will explore next.

Example 2: Solve Numerically (Approximation)

We’ll now use SciPy to solve the same system with numerical methods:

import numpy as np
from scipy.linalg import solve

A = np.array([[3, 2, -1, 4, 5],
              [1, 1, 3, 2, -2],
              [4, -1, 2, 1, 0],
              [5, 3, -2, 1, 1],
              [2, -3, 1, 3, 4]])

b = np.array([12, 5, 7, 9, 10])

solution = solve(A, b)

print(solution)

d1f17aa6-b288-4e41-9be7-0810c45e778c

In this code example, this line of code:

solution = solve(A, b)

Uses the solve method from the SciPy Python library:

from scipy.linalg import solve

It’s a method that helps you find the values of x in an equation A⋅x=b, where a is a square grid of numbers and b is a list of numbers. Which gives us the following:

[ 1.35022026 -0.79955947 -1.17180617  3.14317181 -0.83920705]

Now imagine, in this simple case, that a matrix like A could represent the traffic flow between cities or intersections, and b could represent the traffic entering or leaving each city.

By solving the system, it could help us determine the distribution of traffic between cities to meet desired traffic conditions.

Of course, these types of problems are far more complex in real life. But to understand and solve the big problems, you need to first understand the smaller problems.

And by the way, a system of equations is the same thing as a matrix. We just represent systems of equations as matrices to make the findings of properties and clarity easier to understand.

The thing is that by using matrices, it is easier to make calculations and to perform linear algebra math to check for characteristics of the matrix and understand it better.

In essence, a matrix represents a system of equations. Also, systems of equations can represent real life phenomena like the economy of a country or the weather.

If you want to know more, I wrote an entire article on numerical analysis that you can check out.

The Impact of a Grand Unified Theory of Mathematics

Photo by Porapak Apichodilok: https://www.pexels.com/photo/person-holding-world-globe-facing-mountain-346885/

Despite the biggest paradox in mathematics, what would happen with a Grand Unified Theory of Mathematics?

Remember that such a theory tells us that there are things that are true that are impossible to formally prove, and we need to just accept it. But even with this assumption, it is still possible to unify all math.

This is what the Langland's program is trying to solve. A kind of attempt to interconnect the largest parts of the big tree of math to uncover new patterns in math.

With a Grand Unified Theory of Mathematics, we would be able to understand how every branch of the tree connects with the others and all the relationships between them.

What is the value of this big unification for society?

By studying history, we can find patterns. The unification of various fields has created many massive impacts on society, such as:

  • In the 19th century, James Clerk Maxwell united the fields of electricity and magnetism with his famous Maxwell equations. This allowed the creation of radios and electric grids around the globe. In turn, it served as a foundation for all technological progress in the 20th and 21th century.

  • In the 20th century, the unification of algebra with logic led to the rise of digital systems. In turn, digital systems gave the rise of processors and the evolution of computers to the modern laptop.

  • Also in the 20th century, the unification of probability and communication led to information theory. This became the foundation for the internet. This unification was carried out by a great mathematician called Clause Shannon.

In the end, a Grand Unified Theory of Mathematics could be one of the biggest achievements in modern society.

It could lead to new discoveries in physics, such as in string theory or quantum gravity, where deep mathematical structures are needed to create new physics. In AI, it could help unify all machine learning models in a common architecture. This would help accelerate the development of new AI models. It could also open the door to new cryptographic methods and material science advances, revealing, with math, the deep patterns still not found in these fields.

Just as uniting electricity and magnetism led to modern technology, a unified math framework would lead to a wave of innovation.

A Final Lesson From History

From Greek geometry to AI, math has grown like a tree over centuries. By understanding its structure, it is possible to see its role in finding the patterns of our universe. I hope I was able to make you see math in this way.

In addition, we can conclude that the unification of scientific fields makes the foundations for the creation of new innovations to help society go forward. Many profound societal transformations only came to be thanks to abstract math ideas. When these are shared and refined, they become the hidden architecture of progress in society. Innovation begins when disconnected ideas are united, well-linked, and widely shared.

Find the full code here.

]]> <![CDATA[ 120 Free Online Math Courses from the World’s Top Universities ]]> https://www.freecodecamp.org/news/math-online-courses-from-worlds-top-universities/ 66c376b59a8c3b7871c66a55 Sun, 12 Jan 2025 06:00:00 +0000 In this article, we’ve compiled over 300 online courses offered by the 60 best universities in the world for studying math.

We did so by combining popular university rankings to identify the best institutions, and then using the Class Central database to find all their math online courses.

Methodology

I built the list following the same data-driven approach used to build the list of computer science courses from the top CS universities.

First, I identified the leading world university rankings. Since I was specifically interested in math, I looked at their latest rankings of the best universities for studying math (or closest superset). Here are the rankings I ended up using:

Then, we crawled and scraped each ranking.

Now that I had some data, I used Jupyter with Python to process it. I combined the three rankings into one by averaging the position of each university in each ranking. Then, I filtered out the universities that didn’t offer online courses, and limited the list to the top 60 institutions.

For the latest update of this article, Suparn used the same sources and methodology to find the top 60 universities offering online math courses.

83ffe01a-ea37-4faf-9cde-264d7b9eab73

Combined ranking: top 10 universities for studying mathematics in 2024

As you can see in the image above, I found that the top three math institutions are:

  1. Harvard

  2. MIT

  3. Stanford

Finally, we used the Class Central database, with its 250K online courses, to find all the math courses offered by the universities in the ranking.

The end result is a list of more than 300 online courses offered by 60 best universities in the world for studying math in 2025.

While processing the data, I noticed something interesting: 59 of the top 60 universities offer online courses, a lot more than I would have guessed. The world’s top institutions are very prolific creators of online courses.

Stats

  • Enrollments range from 21 to over 13 million. There are 8 courses with over 1 million enrollments

  • Altogether, the courses in this list have over 52 million enrollments, with an average of over 296 thousand enrollments

  • 222 courses are free and 98 are paid

  • 291 courses are in English, 19 Chinese, 7 French, and 1 each in Spanish, German, Korean.

  • Together, they account for 2,118 reviews at Class Central, with an average of 28 reviews

  • Average Rating 4.51 out of 5.0

  • 80 courses are beginner level, 57 are intermediate level, and 11 are advanced level.

General Mathematics (45)

Linear Algebra (32)

Differential Equations (12)

Statistics & Probability (54)

Calculus (30)

Mathematical Modeling (9)

Convex Optimization (17)

Probability Theory (8)

Others (113)

More Courses

free-certificates-banner

With over 300 courses to pick from, we hope you find something you like. But if these aren’t enough, check out Class Central’s catalog of 250K online courses or our thematic collections:

]]> <![CDATA[ Practical Guide to Linear Algebra in Data Science and AI ]]> https://www.freecodecamp.org/news/linear-algebra-roadmap/ 66d4614e55db48792eed3fa5 Tue, 04 Jun 2024 20:22:06 +0000

"In God we trust; all others bring data." – W. Edwards Deming

This famous quote from Edwards Deming perfectly captures the essence of modern Data Science and AI.

Data is the lifeblood of Data Science and AI fields – Machine Learning, Deep Learning, Generative AI and much more. And understanding how to analyze and manipulate data it is key to unlocking its full potential.

The key to understanding all these concepts is linear algebra – the unsung hero behind many powerful algorithms and techniques.

If you've ever felt a disconnect between the linear algebra you learned in school and its practical use in your career, you're not alone. If you believe you should study and work your way through an entire book of Introduction to Linear Algebra, then you are again not alone.

Many aspiring data science and AI professionals struggle to bridge this gap and think they need to spend countless hours to master mathematics for Data Science and AI. But don't worry, this guide is here to help.

I'll show you how linear algebra isn't just a theoretical concept or old fashioned forgotten area of expertise. You'll learn how it's a practical tool that you can use to solve real-world problems in your field.

Linear Algebra combined with Mathematical Analysis (called Calculus I and II in many undergrad studies) form the backbone of Machine Learning, Deep Learning, Computer Vision, and Generative AI. From building recommendation systems and training Neural Networks to analyzing medical images, understanding linear algebra opens up a world of possibilities.

In this guide, you'll discover:

  • Real-World Applications: We'll explore how linear algebra is applied across various industries, from healthcare to finance, and everything in between (with a special and detailed focus on Data Science and AI).

  • Practical Tips: You'll learn how to translate theoretical concepts into actionable steps for your data science projects.

  • Linear Algebra RoadMap 2024: You will get a roadmap for Linear Algebra in 2024 – on paper and in a video tutorial.

  • Career Development Resources: I will provide you resources to help you learn linear algebra and accelerate your career in data science and AI.

Whether you're a student, a recent graduate, or an experienced professional aspiring to become technical professional, this guide will equip you with the knowledge and skills to learn and leverage linear algebra effectively in your work. And you won't have to spend all your time on endless browsing and searching.

"Mathematics is like the producer of the movies: you don't see them but they are actually running the show." – Tatev Aslanyan

Table of Contents

  1. Core Linear Algebra Concepts

  2. Linear Algebra Roadmap

  3. Real-World Applications of Linear Algebra

  4. Resources for Learning Linear Algebra

Core Concepts in Linear Algebra that You Will Actually Use

Let's dive into the heart of linear algebra and explore the core concepts that you will leverage daily in your Data Science, Machine Learning, or AI journey.

Vectors and Matrices: The Building Blocks of Your Data

Think of vectors as lists of numbers (like NumPy arrays), and matrices as tables of numbers (multiple arrays stacked next to each other). In the world of data science and AI, vectors and matrices are your bread and butter.

Vectors can represent anything from customer characteristics (salary, age, height, income, purchase history) to word embeddings (numerical representations of words, text, and strings in general in natural language processing [NLP]). These vectors in datasets are commonly referred to as features – or, if used as response variables, as labels, dependent variables, and so on.

Matrices are powerful data structures that store datasets, with each row representing a data point and each column representing a feature. When you load your data and store it in a dataframe, all the rows of your data are basically the rows of your matrix, while all the features and response variables combined are the columns in your matrix.

Simple vector or matrix operations like addition, subtraction, multiplication of vectors and matrices are tools for data manipulation and transformation. These tools are used to normalize or standardize features, scale the data, combine different datasets or even perform forward pass/backward pass when training neural networks.

Linear algebra operations all power these common and daily tasks in Data Science and Machine Learning.

Linear Transformations: Manipulating and Transforming Data

In the world of data, transformations are the key. You need transformations to rotate an image and resize it.

These are also common ways to perform data augmentation in Computer Vision. Maybe you want to adjust the colors or contrast. These tasks are all done through linear transformations, which are essentially functions that map one set of data points to another.

In the world of linear algebra, multiplying a matrix by a vector (or another matrix), transposing the matrix and inverting it, is like applying a specific transformation to your data. This is incredibly powerful for:

  • Image and signal processing: Enhancing images, removing noise, or transforming audio signals.

  • Data preprocessing: Scaling features, standardizing variables, and preparing data for machine learning models.

  • Feature engineering: Creating new features by combining or manipulating existing ones through linear combinations.

Eigenvalues and Eigenvectors: The Essence of Your Data

Think of eigenvalues and eigenvectors as the DNA of your data matrix. These sets of important values reveal the fundamental characteristics and directions, respectively, of largest variation (information).

Once you know the eigenvalues and eigenvectors, you can quickly figure out which features in your data contain the most variation (that is information). This is basically your golden ticket for feature selection.

Eigenvalues and eigenvectors are essential in linear algebra, as they offer insights into matrix properties. They are particularly useful across various disciplines such as engineering, physics, data science and AI.

  • Eigenvalues indicate the factor by which an eigenvector is scaled by a matrix, revealing key properties like system stability or oscillation.

  • Eigenvectors are vectors that remain directed along the same line under a matrix transformation, only scaled in magnitude. They help simplify complex systems and elucidate structural properties of transformations.

Eigenvalues and Eigenvectors are essential for:

  • Dimensionality Reduction (PCA): PCA uses eigenvectors to identify the directions of greatest variation (variance) in your data, allowing you to reduce the number of features while retaining the most important information.

  • PageRank Algorithm: Google's famous algorithm uses eigenvectors to determine the importance of web pages.

  • Understanding data clusters: Eigenvectors help us to identify groups or clusters within your data.

Don't be intimidated by the names – eigenvalues and eigenvectors are simply numbers and vectors that describe the inherent structure of your data. Understanding them gives you a powerful lens through which to analyze and interpret complex datasets.

Matrix Factorization: Uncover Hidden Patterns in Your Data

Imagine a massive table of article ratings from thousands of users. Hidden within this data are patterns that reveal user preferences and article similarities.

Matrix factorization, particularly a technique called Singular Value Decomposition (SVD), is the key to creating such a recommender system.

SVD breaks down large matrices into smaller, more manageable matrices that reveal what are called latent factors. These are the underlying characteristics that explain why users rate things (like movies) the way they do. This is the algorithm behind famous recommendation systems like Amazon or Netflix, which use these latent factors to suggest items and movies you'll love.

But matrix factorization isn't just for building powerful recommender systems. It's a versatile tool used for:

  • Dimensionality reduction: Simplify your data by identifying the most important features.

  • Topic modeling: Discover hidden topics in a collection of documents.

  • Image compression: Reduce the size of image files without sacrificing too much quality.

  • Recommendation systems: Predict user preferences and similarities to generate meaningful recommendations and suggest relevant items.

Linear Algebra RoadMap – Your Path to Success

Now let's look at a roadmap that'll help guide you as you master Linear Algebra for Data Science and AI. It's a structured journey that builds upon foundational concepts and progressively delves into advanced topics with real-world applications.

This roadmap, from LunarTechs 25+ hour Linear Algebra Course is aligned with resources such as the Linear Algebra and Its Applications by David C. Lay, Steven R. Lay,and Judi J. McDonald (Cambridge Linear Algebra Book) and the Interactive Linear Algebra by Dan Margalit and Joseph Rabinoff (UBC Linear Algebra Book). It provides you with a solid foundation to tackle real-world problems in data science and AI.

Image

Image Source: LunarTech - Fundamentals to Linear Algebra

Refresh your Memory of High School Algebra

  • Begin by refreshing your understanding of Real Numbers & Vector Spaces, ensuring you grasp the fundamental properties and operations of numbers and vectors.

  • Refresh your knowledge of Angles and Trigonometry, essential for understanding vector relationships and transformations.

  • Make sure you are clear on Norm vs. Euclidean Distance, as norms quantify vector magnitude, and Euclidean distance measures the distance between vectors. This is a very important concept for your future journey of implementing math in real world.

  • Refresh your knowledge on the Pythagorean Theorem and Orthogonality, crucial for concepts like projections and orthogonal transformations.

  • Make sure you are clear on Cartesian Coordinate System for visualizing vectors and understand the geometric side of vectors.

Foundations of Vectors

  • Dive into Vectors and Operations, including vector addition, subtraction, scalar multiplication, and their geometric interpretations.

  • Study Special Vectors and Operations, such as unit vectors, zero vectors, and linear combinations.

  • Explore Advanced Vector Concepts, including linear independence, span, basis, and dimension, crucial for understanding vector spaces.

  • Master the Dot Product and its Applications, understanding its role in calculating angles, projections, and vector similarity.

  • Understand the Cauchy-Schwarz inequality – related to dot product and trigonometric concepts, which provides bounds on the dot product and has applications in various fields.

Foundations of Linear Systems and Matrices

  • Master Matrices and Solving Linear Systems, as learning how to represent systems of equations in matrix form and solve them using techniques like Gaussian elimination will help you understand ML and AI for real.

  • Study Core Matrix Operations, including addition, subtraction, scalar multiplication, matrix multiplication, and transposition.

  • Practice Gaussian Reduction, REF, RREF, row echelon form (REF), and reduced row echelon form (RREF) for solving linear systems and finding inverses.

  • Explore the concepts of Null Space, Column Space, Basis, Rank, Full Rank, essential for understanding the solutions and properties of linear systems.

  • Learn the Algebraic Laws for Matrices with Proofs, solidifying your understanding of matrix algebra.

Linear Transformations and Matrices

  • Dive into Linear Transformations and Matrices, and make sure you understand how matrices can represent linear transformations in vector spaces.

  • Learn how to Transpose a Matrix and its properties.

  • Study Determinants and Their Properties, understanding their significance in determining invertibility and calculating areas/volumes.

  • Master Transpose and Inverses of Matrices (2x2) and (3x3), essential for solving linear systems and understanding matrix transformations.

  • Explore Vector Spaces and Projections, understanding subspaces, orthogonal projections, and their applications in data science.

  • Understand and pratice the Gram-Schmidt Process for orthogonalizing a set of vectors, crucial for QR decomposition (popular Matrix Factorization technique) and other applications.

Advanced Linear Algebra Topics

  • Delve into Matrix Factorization, understanding techniques like QR decomposition, eigenvalue decomposition, and singular value decomposition (SVD).

  • QR Decomposition: Learn how to decompose a matrix into an orthogonal matrix (Q) and an upper triangular matrix (R), useful for solving linear systems and least squares problems.

  • Eigenvalues, Eigenvectors, and Eigen Decomposition: Understand how to find these fundamental characteristics of a matrix and their applications in dimensionality reduction (PCA) and other areas.

  • Singular Value Decomposition (SVD): Learn this powerful matrix factorization technique widely used in data science for dimensionality reduction, recommendation systems, and other applications.

Here is the YouTube tutorial, Linear Algebra Roadmap 2024, which explains in even more detail the Linear Algebra Roadmap topic by topic.

By following this roadmap, you'll gain a comprehensive understanding of linear algebra concepts, starting from the basics and gradually progressing to advanced topics, equipping you with the skills necessary to tackle real-world problems in data science and AI.

Linear Algebra in Action: Real-World Applications in Data Science, AI, and Beyond

Mathematics is like producer of the movies: you don't see them but they are actually running the show.

In this section, we'll delve into specific examples that showcase the practical power of linear algebra across various cutting edge fields. You'll see how seemingly abstract concepts translate into real-world solutions that drive innovation and impact our daily lives.

Let's explore how linear algebra is revolutionizing many different industries.

Linear Algebra in Data Science and Machine Learning

Linear Regression

Linear Regression, which is a fundamental ML algorithm, relies on linear algebra to find the best-fit line (or hyperplane) that minimizes the error between predicted and actual values.

Matrices and vectors are used to represent data and model parameters, while matrix operations like inversion and transpose are crucial for solving the regression equations.

Application - House Price Prediction: Predicting housing prices based on features like square footage, number of bedrooms, and location. You can check out a complete end-to-end case study here.

Imagine you're a real estate agent trying to predict the price of a house. You have data on various features of different houses: the square footage, the number of bedrooms, and so on.

These features are put into a table-like structure called a matrix, denoted as X. Each row of X represents a different house, and each column represents a specific feature – for instance, one column might be the square footage, another the number of bedrooms. The prices of the corresponding houses are stored in another matrix, Y.

Your goal is to predict the price (Y) of a new house based on its features (X). Linear regression uses linear algebra to find the relationship between these features and the price.

The "line of best fit" is defined by a set of coefficients called Beta (β). Each element in Beta corresponds to a particular feature in X and tells you how much that feature influences the final price. We also add an error term, epsilon (ε), to account for any random variation in house prices that can't be explained by the features we have.

Under the hood, linear regression uses matrix operations like transposes, inverses, and matrix multiplication to calculate the Beta values that give the best prediction. So, while you might not see the complex math directly, linear algebra is the engine that powers the price estimates you see on real estate websites!

Logistic Regression

This algorithm uses linear algebra to model the relationship between customer features (like tenure, usage patterns, and demographics) and the probability of churn. Coefficients learned through linear algebra determine the importance of each feature in predicting churn.

Application - Customer Churn Prediction*:* A telecommunications company might use logistic regression to identify customers at high risk of switching to a competitor. The model analyzes factors like call duration, data usage, customer service interactions, and billing issues.

Support Vector Machines (SVM)

SVM is a powerful classification algorithm that uses linear algebra to find the optimal hyperplane separating different classes of data. The concept of vector dot products is central to calculating distances and determining the margin between classes.

Application - Spam Email Identification: classifies emails as spam or not spam based on features like word frequency and email length.

Feature Extraction

Techniques like Principal Component Analysis (PCA) leverage linear algebra to extract the most important features from image data, reducing dimensionality and improving computational efficiency.

Application - Object Detection: Object detection algorithms often use PCA to reduce the complexity of image features before classification.

Principal Component Analysis (PCA)

PCA leverages linear algebra, specifically eigenvalues and eigenvectors, to identify the directions of greatest variance in high-dimensional data. By projecting data onto these principal components, PCA reduces dimensionality while preserving the most important information.

Application - Genomics: In genomics research, PCA is used to analyze gene expression data from thousands of genes. By reducing the dimensionality of the data, researchers can more easily visualize patterns and identify relationships between genes.

Linear Algebra in Deep Learning and Generative AI

Neural Networks

The foundation of deep learning, neural networks are essentially interconnected layers of nodes (neurons) that process information using linear algebra operations. Matrices represent weights and biases, while matrix multiplication and activation functions propagate signals through the network.

Application - Image Classification with CNNs: Image classification using convolutional neural networks (CNNs), where linear algebra is used for filtering operations and feature extraction.

Image Transformations

Linear algebra is used extensively for image manipulation, including rotation, scaling, translation, and shearing. Matrices are used to represent these transformations, and matrix multiplication is used to apply them to images.

Application in Facial Recognition: Facial recognition software uses linear transformations to align and normalize face images for comparison.

Generative Adversarial Networks (GANs)

GANs, a type of generative model, use linear algebra operations within their neural networks to learn and generate new data samples, such as images or text.

Application in Generating Images: Generating realistic images of human faces or creating artwork in the style of famous painters.

Variational Autoencoders (VAEs)

These generative models use linear algebra to encode high-dimensional data into a lower-dimensional latent space. This space is structured to follow a standard distribution (usually a Gaussian), making it easier to sample new data points and generate diverse outputs. Matrix operations are crucial for encoding and decoding data between the original space and the latent space.

Application in Healthcare with VAE: A pharmaceutical company uses VAEs to generate novel molecular structures with desired properties. By encoding existing drug molecules into a latent space, the VAE can explore this space to generate new candidate molecules that potentially have therapeutic effects.

All these examples are just the tip of the iceberg. Linear algebra plays an important role in countless applications across data science and AI. By understanding its core concepts, you'll be equipped to not only use existing algorithms but also contribute to the development of new and innovative solutions.

Practical Tips, Tools, and Resources for Learning Linear Algebra

I often get asked about the best resources for learning linear algebra and specifically what book to read to master it. My advice, as someone who's gone through the traditional academic route of textbooks and countless theoretical examples: don't feel obligated to read those massive linear algebra textbooks cover to cover.

They are valuable resources, but not the most efficient way to learn if your goal is to apply linear algebra in your data science career.

Instead, focus on a clear, guided, and time-efficient approach to learning the theory that you'll actually use. Then, prioritize practical application: learn how to implement these concepts in Python and utilize them in machine learning, deep learning, and other areas. This is a far more effective use of your time.

So, where should you start? The answer is to understand the essentials and implement these concepts with clear guidance. This will help save your time and make it easier to learn effectively.

First of all, make sure you read through the roadmap and watch the accompanying video that I included above. And then you can move on to the following:

Fundamentals of Linear Algebra: 25+ Hour Course

If you're overwhelmed by dense textbooks or endless theoretical examples, you're not alone. Linear algebra can be intimidating, but it's a crucial foundation for anyone working in data science and AI.

LunarTech's concise, career-focused course will equip you with the skills you need to excel in data science and AI. Try it now – it's included in our LunarTech Max plan at the moment. You can sign up for the Fundamentals of Linear Algebra 25+h Course here.

Image

Source: Fundamentals to Linear Algebra 25+h Course

  • Undergraduate Students: Ace your linear algebra exams and build a strong foundation for further study.

  • Working Professionals: Gain the skills you need to understand, create, and implement cutting-edge AI and machine learning algorithms.

Whether you're a student looking for a clear and concise approach to linear algebra or a professional aiming to advance your career in AI and data science, this course will equip you with the knowledge and skills you need to succeed.

Free Linear Algebra Crash Course – 7 Hours

This shorter, demo version of the main course is perfect for learners who need a quick yet comprehensive overview of the key concepts in linear algebra. It’s great as a refresher or for those who need to understand the basics before diving into more complex topics, and is a starting point to learn Linear Algebra.

You can check out this Linear Algebra Crash Course - Mathematics for Machine Learning and Generative AI [Full 7h] to get started.

freeCodeCamp Linear Algebra Course and Textbook

You can also check out this free freeCodeCamp course that covers key Linear Algebra topics like Gaussian reduction, vector spaces, linear maps, determinants, and eigenvalues and eigenvectors. There are many practical examples, and the course encourages you to work through each of them to solidify your knowledge.

There's also a link to download the professor's textbook if you're interested in that.

Connect with Me

Screenshot-2023-10-23-at-6.59.27-PM

Image Source: [LunarTech](https://lunartech.ai" style="box-sizing: inherit; margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant-caps: inherit; font-weight: inherit; font-stretch: inherit; line-height: inherit; font-family: inherit; font-size-adjust: inherit; font-kerning: inherit; font-variant-alternates: inherit; font-variant-ligatures: inherit; font-variant-numeric: inherit; font-variant-east-asian: inherit; font-variant-position: inherit; font-feature-settings: inherit; font-optical-sizing: inherit; font-variation-settings: inherit; font-size: 17.6px; vertical-align: baseline; background-color: transparent; color: var(--gray90); text-decoration: underline; cursor: pointer; word-break: break-word;)

Want to discover everything about a career in Data Science, Machine Learning and AI, and learn how to secure a Data Science job? Download this free Data Science and AI Career Handbook.

Thank you for choosing this guide as your learning companion. As you continue to explore the vast field of machine learning, I hope you do so with confidence, precision, and an innovative spirit. Best wishes in all your future endeavors!

]]> <![CDATA[ How to Apply Math with Python – Numerical Analysis Explained ]]> https://www.freecodecamp.org/news/numerical-analysis-explained-how-to-apply-math-with-python/ 66ba533e80dbd3f269f5887b Thu, 29 Feb 2024 11:41:59 +0000 Numerical analysis is the bridge between math and computer science.

Essentially, it is the development of algorithms that approximate solutions that pure math would also solve, but using less computational resources and faster.

This field is very important. Because for most solutions in the real world, we only need good approximations and not the exact solutions.

In this article, we will explore:

An Analogy that Illustrates the Importance of Numerical Analysis

How can we measure the coastline of an island?

If we try to measure every centimeter of every small segment, it would be impossible and probably time-consuming.

Because of the sea, the coastline is always changing at that level of detail.

However, by approximating and measuring in larger segments, we can get a practical measurement of the coastline.

This situation mirrors numerical analysis.

Approximation gives insights in situations where precise measurement is impossible or impractical.

Just as we accept a good estimation of the coastline length, numerical analysis uses approximation to solve hard problems.

Fundamentals of Numerical Analysis

Numerical analysis is all about approximation. It is like using binoculars to see a landscape that is very far away. We can't see every leaf. But we get a good enough picture to understand the terrain.

This is crucial in numerical analysis.

In this, we solve hard math problems where exact solutions are either impossible or extremely resource-intensive.

By approximating, we get sufficient good results with less computational effort.

Application of Numerical Analysis in Real-World Problems

There are many applications of numerical analysis

  • In engineering, it enables simulation of structures and fluids.
  • In finance, for risk assessment and portfolio optimization.
  • In environmental science, it predicts climate patterns.

In each field, numerical analysis is a toolkit to solve problems where pure math just takes too much time, or it is impossible to give good results.

An Introduction to Partial Differential Equations (PDEs)

Partial Differential Equations (PDEs) are equations that describe how quantities like heat, sound, or electricity change in different places and as time goes on.

Solving PDEs is very important. Because it allows us to control these changes.

By allowing us to control them, we can:

  • Predict weather patterns.
  • Understand sound propagation in different environments.
  • Design efficient transportation systems.
  • Optimize energy distribution.

However, most PDE can only be approximated with numerical methods.

It is either too hard or impossible to find through normal calculations.

This way, with numerical methods, we are able to solve PDEs which in turn allows us to solve many real life problems.

Numerical Solutions of PDEs with SciPy

Solving PDEs with numerical methods often involves dividing the PDEs in small, manageable parts. Solve each one and then add them up.

SciPy, a Python library for scientific and technical computing, gives many tools for this purpose.

Now, let's solve a heat transfer problem in a rod.

In the below code, we will see line by line how it allows us to know how heat spreads in a rod:

import numpy as np
from scipy.integrate import solve_bvp

def heat_equation(x, y):
    return np.vstack((y[1], -y[0]))

def boundary_conditions(ya, yb):
    return np.array([ya[0], yb[0] - 1])

x = np.linspace(0, 1, 5)
y = np.zeros((2, x.size))

sol = solve_bvp(heat_equation, boundary_conditions, x, y)

Lets see how thhe code works block by block in the following sections.

How to importing libraries

import numpy as np
from scipy.integrate import solve_bvp

Image Importing libraries

Here we import 2 python libraries:

These two python libraries are some of the most used in data science.

How to define the head equation and boundary conditions

def heat_equation(x, y):
    return np.vstack((y[1], -y[0]))

def boundary_conditions(ya, yb):
    return np.array([ya[0], yb[0] - 1])

Image Defining heat equation and boundary conditions

We create heat_equation(x, y) and boundary_conditions(ya, yb).

In heat_equation(x, y) we are defining the differential equation we want to solve.

The boundary_conditions(ya, yb) function defines constrains at the start and end of a solution. The condition is that the end of the solution needs to be one unit less than the start.

How to solve the equation

x = np.linspace(0, 1, 5)
y = np.zeros((2, x.size))

sol = solve_bvp(heat_equation, boundary_conditions, x, y)

Image Solving equation

The line sol = solve_bvp(heat_equation, boundary_conditions, x, y) is the solution.

The code solve_bvp stands for solve boundary value problem.

It takes four arguments:

  • heat_equation: This is the main problem we are trying to solve.
  • boundary_conditions: These are the mathematical constrains at the start and end of a solution.
  • x: Are the spots we choose to explore our answers.
  • y: Are initial attempts to solve the problem, based on your chosen x values.

An Introduction to Optimization in Numerical Analysis

Optimization is finding the best solution from all solutions. It is like finding the most efficient route in a complex network of roads.

Numerical optimization methods find the most efficient or cost-effective solution to a problem, whether that is:

  • Minimizing waste in production.
  • Maximizing efficiency in a logistic network.
  • Finding best fit for a certain data model.

An Overview of Numerical Optimization Techniques with SciPy

The goal in this example is to minimize transportation cost across a network.

For instance, let's consider an optimization problem in logistics, where the goal is to minimize transportation cost across a network.

SciPy's minimize function can be used to find the best strategy to minimizes cost while meeting all constraints:

from scipy.optimize import minimize

def objective_function(x):
    return x[0]**2 + x[1]**2

def constraint_eq(x):
    return x[0] + x[1] - 10

con_eq = {'type': 'eq', 'fun': constraint_eq}

bounds = [(0, 10), (0, 10)]

x0 = [5, 5]

result = minimize(objective_function, x0, method='SLSQP', bounds=bounds, constraints=[con_eq])

Lets explain how the code works block by block.

How to importing the library

from scipy.optimize import minimize

Image Importing scipy

Once again we import the necessary library:

https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html

How to defining objective and constraint equation

def objective_function(x):
    return x[0]**2 + x[1]**2

def constraint_eq(x):
    return x[0] + x[1] - 10

con_eq = {'type': 'eq', 'fun': constraint_eq}

Image Define objective and constrain equations

  • The objective function is the function we want to minimize to find the best answer.
  • The constraint equation is the equation that limits the search space to those x values that fulfill this equation.

con_eq is defined by the following:

  • 'type': 'eq' indicates the type of constraint. 'eq' means equality, in other words, the function must equal zero at the solution.
  • 'fun': constraint_eq assigns the constraint function.

We will see in the next block of code, it is where we constrain the possible solutions of the problem.

How to define an initial condition and result

bounds = [(0, 10), (0, 10)]

x0 = [5, 5]

result = minimize(objective_function, x0, method='SLSQP', bounds=bounds, constraints=[con_eq])

Image Defining initial condition and solving equation

To understand this block of code, let's understand each parameter of result = minimize(objective_function, x0, method='SLSQP', bounds=bounds, constraints=[con_eq]):

  • objective_function: Is the function to be minimized.
  • x0: Is the initial guess for the variables.
  • method='SLSQP': This specifies the optimization algorithm we are using. In this case, we use SLSQP (Sequential Least SQuares Programming).
  • bounds=bounds: This parameter specifies the bounds for each of the decision variables.
  • constraints=[con_eq]: This parameter tells us the constraints applied in the optimization problem.

This is how many real life problems are solved

Many things in real life are modeled with partial differential equation.

Then, with optimization methods developed with numerical analysis, they are optimized.

I am writing this because I know math can be boring for some people, and they may not be aware of where it is applied to solve real problems. The Calculus they learn can be applied in non-ideal situations outside the exams exercises.

Here, we can see finally see why math is important in two scenarios:

  • To model systems to get solutions from it
  • To optimize a certain system

Conclusion

Numerical analysis is one of the most important areas of applied math in STEM.

From solving PDE to optimize problems, numerical analysis is everywhere.

With more complex problems, numerical analysis is growing in importance to get faster algorithms that approximate pure math solutions.

This way, it is a bridge between theoretical mathematics and practical application.

If you want to, you can get the full code used in this article on GitHub.

]]> <![CDATA[ How to Add Numbers in Excel ]]> https://www.freecodecamp.org/news/add-numbers-in-excel/ 66b8ddc62755c964523f056c Thu, 12 Oct 2023 21:02:58 +0000 Did you know you can write Python code in a spreadsheet?

You'd be surprised how many different ways there are to do things in Excel. Below, I'll show you 9 ways to add two or more numbers. You can skip to a certain section if you'd like to see that method:

  1. Manual
  2. References
  3. SUM()
  4. SUMIF()
  5. SUBTOTAL()
  6. AGGREGATE()
  7. VBA
  8. Python
  9. Highlight

Video Walkthrough

If you prefer to watch me go through each of these in a demo workbook, here's a video for that:

To write a formula or a function in Excel (which we'll be doing in the examples below), start out by simply typing an equals sign in a cell.

=

This triggers Excel to know that what follows will be a formula or a built-in function.

Manual

This is simplest version of a formula in Excel. Start out with the equals sign, and then type in the numbers and operation you want to do. Just like a calculator:

=6+102

Pressing enter will result in 108 being listed in the cell

Image screenshot of manual addition in Excel

References

The next step up in Excel is to start using cell references. Notice that on the top and on the left side of the main spreadsheet area, there are columns designated by letters and rows designated by numbers.

Image screenshot of rows and columns

We can refer to specific cells using "A1" notation. Like a set of (x,y) coordinates on a graph, this simply means that by referring to C4, for instance, we are referring to the cell found in column C, row 4.

To add numbers using references, we start again with the equals sign and refer to the values in specific cells directly.

This has the added advantage of being dynamic. If a value is changed in one of the cells, the result of the sum automatically updates.

=SUM(A1+A3) provides us with the value of the numbers in A1 and A3.

SUM()

The first two methods are examples of using formulas. We manually give Excel a series of instructions that it executes.

Excel also has built-in functions which we can use by starting with the equals sign and then referring to the function by name. Functions also take variables which we pass to them by using a set of parenthesis after the name of the function.

The SUM() function takes either a range or a comma-separated list of cell references. It then returns the sum of all the numbers in the range.

You can select a range by either clicking and dragging or by declaring one by typing in the A1 notation with a colon in between the top left cell and the bottom right cell of the range.

SUM(A5:A11) adds all the numbers in cells A5, A6, A7, A8, A9, A10, A11

Image screenshot of the SUM() function

SUMIF()

A more powerful version of SUM() is the SUMIF() function. This adds conditional logic. It needs at least two variables: a range and a condition. We could give it the same range as above and have a condition be that it only adds up numbers that are greater than zero.

A third, optional variable is a sum_range. This allows for us to match a condition in one range with the sum of values in another range.

In the example sheet, I have inserted checkboxes in column C. Checkboxes in Excel are a new feature. This is the range that I'm checking for a condition. The condition is TRUE. Now I enter the range that I want to sum if the condition in the corresponding row of the first range is indeed TRUE.

When using a range and a sum_range separately like this, they do have to be of the same size or it will not behave as you want it to.

Image screenshot of SUMIF() function in Excel

SUBTOTAL()

Ok, here's where things start to get interesting.

Image

The SUBTOTAL() function allows us to do a ton of different things. Ultimately, it returns a subtotal of a list or database. But inside of SUBTOTAL() there are other functions. The first argument that we give SUBTOTAL() is a number corresponding to one of these functions:

Image screenshot of functions within SUBOTAL from Microsoft Excel

Looking at the function list, we see that 9 or 109 both correspond to the SUM() function which we want to use. If we have hidden rows in our range that we don't want to include in the sum, we use 109 to ignore those – if not, simply 9.

So the function looks like this: SUBTOTAL(9,B3:B12). This sums B3:B12 even if one or more of those rows are hidden.

Image screenshot of SUBTOTAL in Excel

AGGREGATE()

We can think of AGGREGATE() as a souped-up version of SUBTOTAL(). It works in the same way but has a lot more built-in functions (19 of them) and allows for detailed specificity on what values, if any, to ignore in the calculation.

AGGREGATE(function_num, options, ref1, [ref2], …) is the full reference formula. Again, we pass it a number corresponding to one of the 19 built-in functions, then an optional argument for what type of values to ignore, followed by the reference array and an optional second reference array.

Image screenshot of options for Aggregate function from Microsoft Excel

For our example, we again use 9 as our function number, but we can use option 5 to explicitly exclude hidden rows:

Image screenshot of Aggregate function in Excel

VBA

Now we're warmed up. Let's get overly complicated.

Image gif of complicated nonsense

Visual Basic for Applications is Microsoft's baked-in programming language in Microsoft Office applications.

Open it up by selecting Visual Basic from the Developer tab.

Image screenshot of VBA in Developer tab in Excel

If you don't see the developer tab, go to File - Options - Customize Ribbon and add it.

Image screenshot of Customizing Ribbon in Excel

Also, Alt +11 is the keyboard shortcut to open up VBA.

Once here, we can write code to do all sorts of things. Our example isn't very practical since a function will do it quicker, but the following code will Sum the range A1:A11, put the result in F11 and display a message pop-up with the result:

Sub AssignSumVariable()
   Dim result As Double
   'Assign the variable
   result = WorksheetFunction.Sum(Range("B1:B11"))
   'Show the result
   MsgBox "The total of the ranges is " & result
   'Put the result in cell F9
  Range("F9") = result
End Sub

Image screenshot of VBA in Excel

Python

Yes, this is now ridiculous. But, it's good to know what Excel can do when you have more complicated tasks that require tools like VBA or Python. At the time of this writing, Python is available in Excel for people using the Beta Channel of Excel.

Image gif of woman saying "seems like overkill"

You can check your eligibility and join Microsoft 365 Insider if you want to test out new features like this in the future.

Go to File - Account, and then select the 365 Insider channel button for more info.

Image screenshot of Microsoft 365 Insider options

Once Python is usable in Excel, you activate it by typing =py and then the tab key. This turns the cell into a Python command line.

Image screenshot of Python command line in Excel

From here, we can write Python code directly in the cell. The following code uses the custom xl() function for Python to use a range. We hold the range in the numbers variable and then using dot notation, we sum that range with the numbers.sum() line:

numbers = xl("'Sum➕'!$B$3:$B$12")
numbers.sum()

Now to execute the Python code, click CTRL + ENTER.

What we now see is that we've got a Python Series in the cell:

Image

In order to just display the answer, we can click the Python Output selector just to the left of the formula bar and select Excel Value:

Image screenshot of Python Output in Excel

Now, our cell is updated with the correct value.

Image screenshot of cells in Excel

The real value of Python in Excel comes with manipulating dataframes using built-in libraries like Matplotlib, NumPy, or Pandas.

Okay, take a breath, we'll finish with something simple and easy...👇

Highlight

Bonus time. If you highlight cells in Excel by either clicking and dragging mouse over a range, or by CTRL+ Left-Click individual cells, some automatic calculations are visible in the bottom right of the window, including the Average, Count and Sum:

Image

If the sum isn't immediately visible, right clicking will pull up auto-calculations that you can toggle on and off:

Image screenshot of auto-calculation options in Excel

Thanks for reading!

Hope this is helpful for you!

Follow me on LinkedIn: https://www.linkedin.com/in/eamonncottrell/

And YouTube: https://www.youtube.com/@eamonncottrell

Have a great one! 👋

]]> <![CDATA[ How to Calculate Definite and Indefinite Integrals in Python ]]> https://www.freecodecamp.org/news/calculate-definite-indefinite-integrals-in-python/ 66d460c5bd438296f45cd3a4 Mon, 31 Jul 2023 18:02:27 +0000 By Roy Chng

Python is a versatile programming language that offers libraries and tools for scientific computing and mathematical calculations.

Many essential mathematical operations frequently involve definite and indefinite integrals. In this article, we will explore how to perform these calculations using Python.

How to Calculate Single Variable Definite Integrals

Install SciPy

Before we start, we need to install the SciPy module. It provides a collection of Mathematical algorithms and functions that we'll use.

You can do this by running the following command in a terminal:

pip install scipy

To calculate single variable definite integrals, we need to first import quad from scipy.integrate. It is a general purpose function used to calculate single variable definite integrals.

from scipy.integrate import quad

Elementary Functions

From there, we'll need to define the integrand as a function in Python.

For example, if we wanted to calculate the integral of x-squared, we would define the integrand as a Python function like so:

def integrand(x):
    return x**2

Once we define the integrand, we can calculate the definite integral using the quad function like this:

print(quad(integrand, 0, 1))
# (0.33333333333333337, 3.700743415417189e-15)

In the above code, 0 represents the lower limit of integration and 1 represents the upper limit of integration. They can be any other number.

Image Result of the of integral of x^2 from 0 to 1 with the associated code

In this example, we calculate that the estimated result of the integral from 0 to 1 of x-squared is approximately 0.333 with an absolute error of roughly 3.7e-15.

The quad function returns a tuple of an estimation of the definite integral followed by the absolute error of the estimation.

What the quad function does is essentially evaluate the integrand function at multiple different values between our limits of integration to be able to calculate an estimate of the integral.

Another example would be if I wanted to calculate the integral of (x+1)/x**2. We would first define it as a function in Python, and pass it into the quad function along with the limits of integration:

from scipy.integrate import quad

def integrand(x):
    return(x+1)/x**2

print(quad(integrand, 1, 2))
# (1.1931471805599452, 1.3246594716242401e-14)

Image Result of the of integral of (x+1)/x^2 from 1 to 2 with the associated code

In this example, we calculate that the estimated result of the integral from 1 to 2 of x +1 all over x-squared is approximately 1.19 with an absolute error of roughly 1.32e-14.

Other Common Functions

If we wanted to use common mathematical functions such as sin(x) or log(x), we can use another Python package for scientific computing – NumPy. You can install the package using the following command:

pip install numpy

By importing it, we have access to these common functions which we can use in our integrand:

from scipy.integrate import quad
from numpy import log, sin

def integrand(x):
    return log(sin(x))

print(quad(integrand, 0, 2))
# (-1.1022223889049558, 1.2237126744196256e-15)

Image Result of the of integral of log(sin(x)) from 0 to 2 with the associated code

In this example, we calculate that the estimated result of the integral from 0 to 2 of log(sin(x)) is approximately -1.10 with an absolute error of roughly 1.22e-15.

A full list of mathematical functions that NumPy provides is in their documentation.

How to Use Constants

NumPy also provides useful constants such as e and pi, as well as inf. It's a floating point representation of positive infinity. We can use it to calculate a definite integral that converges.

from scipy.integrate import quad
from numpy import inf, exp

def integrand(x):
  return exp(-x)

print(quad(integrand, 0, inf))
# (1.0000000000000002, 5.842606742906004e-11)

Image Result of the of integral of e^x from 0 to infinity with the associated code

In this example, we calculate that the estimated result of the integral of e raised to the negative x from 0 to infinity is approximately 1.00 with an absolute error of roughly 5.84e-11.

How to Calculate Multi-Variable Integrals

Double Integrals

To calculate double integrals, we need to import the dblquad function from scipy.integrate:

from scipy.integrate import dblquad

We define the integrand in a similar way to definite it with one variable, only this time we specified two arguments instead.

def integrand(y, x):
    return x*y**2

We can then calculate the definite integral using the dblquad function given by scipy.

Note that the integrand is a function that needs to accept y as the first parameter and x as the second parameter.

print(dblquad(integrand, 0, 1, 2, 4))
# (9.333333333333334, 2.0679162295394134e-13)

Image Result of the integral of (xy^2) dxdy from 2 to 4 for y and integral from 0 to 1 for x with the associated code

In this example, we calculate that the estimated result of the double integral x times y-squared from x = 0 to 1 and from y = 2 to y = 4 is approximately 9.33 with an absolute error of roughly 2.07e-13.

The function requires us to pass in the integrand, and the lower and upper limits of integration for x, followed by the lower and upper limits of integration for y.

Variable Limits

To calculate integrals with variable limits, we'll need to define functions for the lower and upper limits of integration for y in terms of x:

def upper_limit_y(x):
    return x**2

def lower_limit_y(x):
    return x

def integrand(y, x):
    return x+y

print(dblquad(integrand, 0, 2, lower_limit_y, upper_limit_y))

In this example, we calculate that the estimated result of the double integral of x+y from x = 0 to x = 2, and from y = x to y = x^2 is approximately 3.2 with an absolute error of roughly 1.10e-13.

Image Result of the double integral (x+y) dydx from 0 to 2 for x and integral from x to x^2 for y with the associated code

Triple Integrals

To calculate triple integrals, we can use the tplquad function:

from scipy.integrate import tplquad

def integrand(z, y, x):
    return z*(x+y+z)

print(tplquad(integrand, 0, 1, 4, 5, 0, 1))
# (2.8333333333333335, 3.6983326566167174e-14)

The function requires us to pass in similar arguments, being the upper and lower limits of integration in x, y and z.

In this example, we calculate that the estimated result of the triple integral of z multiplied by (x+y+z) from x = 0 to x = 1, y = 4 to y = 5, and z = 0 to z = 1 is approximately 2.83 with an absolute error of 3.70e-14:

Image Result of the triple integral z(x+y+z) dxdydz from 0 to 1 for x, 4 to 5 for y and 0 to 1 for z with the associated code

How to Evaluate Single Variable Indefinite Integrals

To calculate single variable indefinite integrals with Python, we need to use the SymPy library. It's used for symbolic computation and involves exact computation using variables. To install it, install the SymPy module:

pip install sympy

Once it has been installed, we can import the Symbol and integrate methods from sympy:

from sympy import Symbol, integrate

We first need to define the variables used in the integrand:

x = Symbol('x')

After that, we can integrate the function using the integrate method that SymPy provides. It expects two arguments: the first is the integrand, and the second is the variable we are integrating with respect to.

For example, if we wanted to integrate x-squared with respect to x, we can define the integrand in Python as x**2:

print(integrate(x**2, x))
# (x**3)/3

Image Result of the indefinite integral of x^2

In this example, we calculate the integral of x-squared which is x-cubed over 3.

Note that SymPy doesn't add the constant of integration, but it is implied.

SymPy also provides other common functions such as sin(x) and exp(x) that we can use.

Before using them, we first need to import it from sympy:

from sympy import Symbol, integrate, sin

Using the imported sin function, we can then evaluate the integral of sin(x).

x = Symbol('x')
print(integrate(sin(x), x))
# -cos(x)

In this example, we calculate the integral of sin(x) which is -cos(x):

Image Result of the indefinite integral of sin(x)

Sympy provides the full list of mathematical functions you can use in their documentation

Summary

In this tutorial, we went over the basics of how to calculate both definite and indefinite integrals in Python. We also looked at how to calculate integrals of elementary functions, ones that involved common mathematical functions, as well as using constants.

We made use of popular Python libraries for scientific comptutation and went over examples of calculating integrals.

If you enjoy my writing, consider subscribing to my YouTube channel.

Happy Coding!

##

]]> <![CDATA[ Exponent in Python – Power Function and Exponents Using a Loop ]]> https://www.freecodecamp.org/news/python-bytes-to-string-how-to-convert-a-str-to-bytes-and-back-again/ 66d84f4caeb1c87b6855d3f6 Tue, 14 Feb 2023 17:54:02 +0000 By Dillion Megida

The exponent of a number refers to the power to which that number should be raised. In this article, I'll show you how to find exponents using two ways: the power function and a loop.

Exponents are usually written like this: Baseexponent

Take an example like 103. This means, "10, raised to the power of 3". The result of this is evaluated as 10 * 10 * 10 (10 multiplied by itself 3 times), which is 1000.

There are different ways you can evaluate the exponent of a number (the number is referred to as the base). One way is using the ** operator. With this operator, you have the number, followed by the operator, and then the exponent like this 10 ** 3 which is 103

But in this post, I'll show you two other ways, which are the pow function and using a loop.

Exponents with the pow function

pow is an in-built function in Python for evaluating a number raised to an exponent. The syntax for this function is:

pow(base, exponent, modulo)

This function accepts three arguments:

  • base: the number which will be raised
  • exponent: the power to which the number will be raised
  • modulo: an optional number that evaluates the remainder when the raised number is divided by it

The last argument is optional, but according to the python documentation on pow, this argument computes more efficiently than pow(base, exponent) % number.

Let's see some examples:

result1 = pow(100, 3)
print(result1) # 1000000

result2 = pow(5, 4)
print(result2) # 625

result3 = pow(3, 2, 5)
print(result3) # 4

In the last example, we have pow(3, 2, 5). What happens here is that 3 is first raised to the power of 2, which is 9. Then 9 is divided by 5, and the remainder, which is returned, is 4.

Note that there's also a Math.pow function in Python. The difference between this and pow(), is that pow() will only return a float number when the number is a float. It will return an integer if the number is whole. But math.pow() always returns a float number.

Exponents with a loop

You can use any kind of loop to achieve this, but for this post, I'll use a while loop.

The syntax for a while loop is:

while condition:
  # code to execute

For exponents, I can put this loop in a function like this:

def loopExp(number, exp):
  result = number
  counter = 1

  while counter < exp:
    result *= number
    counter += 1

  return result

Here, we defined a loopExp function that takes two inputs: number and exp which stands for exponent.

In the function, we initialize the result and counter variables with the value of number and 1 respectively. Then we have the while loop which runs as long as the counter variable is less than the exp input.

In each loop, we update the result variable by multiplying the previous value of the result with the number input. We also increment the counter variable by 1. Then we return the result variable.

Let's see this function in use:

result1 = loopExp(100, 3)
print(result1) # 1000000

result2 = loopExp(5, 4)
print(result2) # 625

result3 = loopExp(3, 2)
print(result3) # 9

As you can see in the results, we have the exponents calculated using the loop in the loopExp function.

Wrapping up

In this article, I've shown you how to evaluate exponents in different ways. I used examples to show you the ** operator, the pow and Math.pow functions, and also using a loop.

Kindly share this if you find it helpful :)

]]> <![CDATA[ How to Use Your Linux Terminal as a Calculator – Mathematical Expression Solver ]]> https://www.freecodecamp.org/news/solve-your-math-equation-on-terminal/ 66ba10f67282cc17abcf0c6a Thu, 15 Dec 2022 17:40:54 +0000 Can you solve the below math expression on your own without using any device? Take as much time as you need – but no tools allowed:

( ( 11 + 97 ) + ( 2 * 63 ) - ( 7 / 93 ) * ( 8 - 25 ) / ( 9 * 64 ) ) * ( ( 64 / 34 ) + ( 94 - 20 ) - ( 23 + 98 ) * ( 199 * 928 ) / ( 92 * 26 ) ) * ( ( ( 2 * 1 ) / 2 ) - 1 )

Kudos to you if you solved it on your own. I'm sure you'll be angry with me, though, after discovering that the result of this long expression just evaluated to zero.

So what if you used your browser to find the answer? How long would that take?

Searching this expression on Google took less than a second to get the answer (using a 500MBPS connection) along with 5,21,00,000 results.

Image Search results by Google for the given expression

Yahoo gave us the answer in less than 500 ms along with 1,480,000,000 search results.

Image Search results by Yahoo for the given expression

Bing didn't even return anything.

But my terminal and system calculator were almost instant in finding the answer (took < 10 ms).

Using the terminal is one of the quickest ways to evaluate a mathematical expression. But many developers are unaware that you can solve mathematical expressions using your terminal.

In this article, you'll learn how to solve math problems in the Linux terminal.

How to Evaluate a Mathematical Expression in the Linux Terminal

You can use the expr command to evaluate mathematical expression in your terminal. Basic mathematical operations such as addition, subtraction, multiplication, division and modulus all work using the expr command.

Let's have a quick look at each of these operations:

expr 12 + 8   # Addition

expr 20 - 10  # Subtraction

expr 5 \* 2   # Multiplication

expr 8 \/ 4   # Division

expr 5 \% 3   # Modulus

Image Using the expr terminal command to find answers to arithmetic operations

Running each of those commands in the terminal evaluates and returns the answer of that expression (as you can verify in the attached screenshot).

You might be thinking, "Why is there a backward slash () for the last 3 operations (Multiplication, Division, and Modulus)?"

A backward slash in programming is basically used to escape characters. Let's take the example of the Multiplication symbol (). "" is used in regular expressions which basically means to include all files and folders.

Here's a quick example:

cp ./* ../backup/

Running the above command will copy all the files and folders in the current directory to the backup directory.

Similarly, each symbol has their own meaning. Using a backward slash () will escape its regular usage pattern. This is the reason that most symbols are prefixed with a backward slash.

But, you may wonder, is this all this command can do?

The answer is no. I've shared a sample of the expressions, but we could use any others and get the results in a fraction of a second.

How to Evaluate a Logical Expression in the Terminal

In addition to finding the results of a mathematical expression, you can use this command to evaluate a logical expression.

Logical expressions containing <, <=, >, >=, =, != can be evaluated with this command.

Let's have a quick look at how it works:

expr 2 \< 1

expr 29320 \> 23820

expr 29320 \>= 29320

expr 29320 \< 29320

expr 29320 \<= 29320

expr 293202 \= 293203

expr 293202 \!= 293203

Image Evaluate logical expressions with expr command

The command returns "1" if the expression evaluates to true and "0" if it evaluates to false.

From the above commands you can notice that all the logical operators are escaped with a backward slash ().

What Do the Special Logical Operators Do?

I read your mind. You're thinking, "I know about logical operators. What are the special logical operators?".

Well, the special logical operators are:

  • AND (&)
  • OR (|)

From a programming perspective, the AND operator evaluates to true if both sides of the operator evaluates to true. The OR operator evaluates to true if either of the sides evaluates to true.

Here's the table for your reference. Some people may be familiar with 1 and 0. For those people, replace FALSE with 0 and TRUE with 1.

X Y X OR Y X AND Y
FALSE FALSE FALSE FALSE
FALSE TRUE TRUE FALSE
TRUE FALSE TRUE FALSE
TRUE TRUE TRUE TRUE

But they have a completely different usage with the expr command. Let's have a quick look at it.

The expr command works similar to the above table. But there's an exception for a particular case. This command will never return 1 if an expression evaluates to true – instead it returns an argument.

Evaluating expr ARG1 | ARG2 returns ARG1 if ARG1 is neither null nor 0, otherwise it'll return ARG2. On the other hand, evaluating expr ARG1 & ARG2 returns ARG1 if neither of the arguments are null or 0 . It returns 0 otherwise.

Let's examine few examples with the logical OR operator:

expr 1 \| 2     # Returns first argument (1)

expr 0 \| 2     # Returns second argument (2) as first argument is 0

expr "" \| 2    # Returns second argument (2) as first argument is null 
                  (Empty string [""] is considered as null in terminal)

expr 100 \| 78    # Returns first argument 100

expr "" \| ""   # Returns 0 as both arguments are null ("")

Image Evaluating logical OR expressions with expr command

The above screenshot represents operations with logical OR operator (|). Reading that you may still have a couple of questions:

What's the purpose of using empty double quotes ("") in the expression?

Empty double quotes represent a null value in bash. So, as said earlier, if the first argument is null, the second argument is returned.

What if both the arguments are null?

When evaluating both arguments with null values, both the Logical OR and AND operators return 0.

Let's examine a few examples with the logical AND operator:

expr 1 \& 2     # Returns first argument (1)

expr 1 \& 0     # Returns 0 as one (second) argument is 0

expr 0 \& 1     # Returns 0 as one (first) argument is 0

expr "" \& 1    # Returns 0 as one (first) argument is null ("")

expr 1 \& ""    # Returns 0 as one (second) argument is null ("")

expr "" \| ""   # Returns 0 as both arguments are null ("")

Image Evaluating logical AND expressions with expr command

How to Perform String Operations with the expr Command

The expr command is not limited to mathematical and logical operations. It can perform string operations, too.

Pattern Matching with Regex

The expr command can verify if a text matches with a regex pattern. It returns the matched pattern of the text if it exists or else returns an empty line.

The syntax to verify the regex is:

expr STRING : REGEXP

or

expr match STRING REGEXP

Image expr command evaluates regex pattern match with the given text

You can achieve this either by using the match keyword or by using a semicolon (:) between the string and the regex pattern.

Alternatively, you can use the semicolon to find the number of characters matching between the two texts.

Here's an example:

expr Remember : Remo    # Returns 0

expr Remember : Rem     # Returns 3

Image expr command to find the number of characters matching the given text

Find the length of a text

You can use the expr length command to find the length of the given text. 

expr length Linux

expr length "Learning Linux is fun"

Image expr length command showing the number of characters in the given text

You can enter the text directly after the expr length command if it does not have any spaces. If the text has spaces, enclose them within double quotes (""), or else you'll get an error.

Find a character in a text

You can find a particular character from a given text using the expr index command. It returns the place where the character exists. 

expr index STRING CHAR

Image expr index to find a character from a text

Remember that the expr index command performs a case-sensitive search and returns the first matching index of a character from the text.

Extract a substring from a string

Extracting a substring from a string is simple using expr command. Entering the string, start index, and number of characters to be clipped after the start index will return the expected substring. 

expr substr Carpenter 4 3      # Returns pen

Image expr substr command to find a substring from a string

Conclusion

In this article, you have learnt the use cases of the expr command.

If you enjoyed my tutorial, you can subscribe to my newsletter on my personal site to receive more such insightful articles straight to your inbox. You'll also find a consolidated list of all my blog posts.

]]> <![CDATA[ How to Round to 2 Decimal Places in Python ]]> https://www.freecodecamp.org/news/how-to-round-to-2-decimal-places-in-python/ 66d84f17d592ae8435de7164 Mon, 22 Aug 2022 17:17:58 +0000 By Dillion Megida

Python provides many math methods for mathematical operations such as square roots, exponents, and so on.

In this article, I will show you how to round up a number to a specified decimal place.

What is a Decimal Place?

Look at this number: 324.89.

Each number here has a position which is refered to as place value. The place value of:

  • 3 is hundreds
  • 2 is tens
  • 4 is ones
  • 8 is tenths
  • 9 is hundredths

After the decimal point, you have two numbers: 8, then 9. The decimal place of a number is the position of the number after a decimal point (on the right side of it).

This definition means that the decimal place of 8 (in the tenths position) is 1, and 9 (in the hundredths position) is 2.

How to Round Up to a Certain Decimal Place

What does it mean then to round up to a certain decimal place? It means that you round up a number at a decimal place based on the number after it.

If the number after the decimal place is 5 or more, the number at the decimal place is rounded up +1. Otherwise, the number at the decimal place stays the same and the number after the decimal place is rounded down to 0.

For example, let's say we want to round up 24.89 to 1 decimal place. Or you can put it as rounding up 24.89 to the nearest tenth.

The number 8 is at the 1 decimal place, and the number after 8 is 9. Since 9 is more than 5, 24.89, rounded up to the nearest tenth will be 24.9.

As another example, let's take 24.82 and round it to 1 decimal place (the nearest tenth). Since 2 is not larger than 5, 8 remains the same, and 2 gets rounded down – resulting in 24.8.

How to Round Up a Decimal Place in Python

Now that you understand how to round up a decimal place, let's see how to do it in Python.

You can use the global round function to round up numbers to a decimal place. The syntax is:

round(number, decimal_point)

The function accepts the number and decimal_point as arguments. decimal_point specifies the decimal place that you want to round the number up to. Let's see an example:

num = 24.89

rounded = round(num, 1)
print(rounded)

# 24.9

Here's another example of a longer number:

num = 20.4454

rounded3 = round(num, 3)
# to 3 decimal places

rounded2 = round(num, 2)
# to 2 decimal places

print(rounded3)
# 20.445

print(rounded2)
# 20.45

For rounded3, the num is rounded up to 3 decimal places. At the 3rd decimal place is 5, and the number that comes after it is 4. Since 4 is not greater than 5, the number 5 stays the same and 4 is rounded down to 0.

For rounded2, the num is rounded up to 2 decimal places. At the 2nd decimal place is 4, and the number after it is 5. Since this number is greater than or equal to 5, the number 4 is rounded up to 5.

Conclusion

Rounding up numbers can be useful for keeping floating numbers within fixed digits.

For example, this is useful with currencies that only accept two decimal places (like the dollar: $100.99). In cases where a calculation for a product results in $50.678, you may want to round it to 2 decimal places, like this: $50.68. This way, it can be easier to give someone the actual monetary value.

In this article, I've briefly explained what decimal places are, and how to round numbers to certain decimal places in Python.

]]> <![CDATA[ How to Use Graph Theory to Build a More Sustainable World ]]> https://www.freecodecamp.org/news/the-value-of-graph-theory-within-sustainability/ 66baef4fd453cb5eb7951596 Fri, 19 Aug 2022 20:50:13 +0000 Discrete mathematics is an area of math based on the study of formal structures whose nature is fundamentally separate and distinct.

This means it focuses on integers and natural sets of numbers, shapes, and other objects that you can count finitely or distinguish from one another. It models reality in a manner specifically suited to certain real-world applications.

From industry and logistics to computer science and telecommunications, having a quantized representation of everything around us has led to magnificent advances in our understanding and control of the physical world.

It's important to have at least a rough idea of the main distinctions between discreteness and continuity to address graph theory. But these aren't very well-known concepts to people outside the world of mathematics.

At first, continuous math is the one predominantly taught in the education system due to its versatility, usefulness, and practicality in most areas.

It’s based on the analysis of real numbers and functions that encapsulate mappings between these quantities, along with the notion of the infinitesimal change of a variable. This results in a series of tools like limits or derivatives that constitute calculus.

On the other hand, the discrete paradigm is more straightforward and intuitive, with the exception of a few cases. And its finiteness is given by the primordial element constituting it – sets.

Among the most notorious use areas are those whose main components imply algorithms and data structures. Although the use cases of math are not what most people think they are.

In the real world, we don’t often face problems in the same way as in the education system. Indeed, discrete ways of approaching riddles and modeling the input data we need to come up with a solution are more usual than continuous ones, especially regarding system optimization issues.

For this reason, we should reconsider the role of this way of doing mathematics since it involves the development of critical/computational thinking. This is crucial for the current era in which we are surrounded by technology. It also involves the improvement of problem-solving skills, making it possible for us to face any new challenges.

By doing so, we can see how relevant it is to apply a solid mathematical foundation to common global threats that are increasing daily, like misinformation, lack of fluency in handling technology, geopolitical instability, and even climate change.

Notwithstanding the apparent remoteness between the latter issue and graph theory itself, we should think about the way we live and the system by which our civilization is maintained as we know it.

Goals of this Article

This article aims to explain graph theory, one of the most significant components of all discrete mathematics, in an intuitive, simple, and visual way. I'll also try to guide its use towards the development of new disruptive techniques applicable in areas such as environmental care, necessary to preserve and regenerate our nature.

Effectively achieving this will not only foster curiosity or inspire readers who may intend to continue learning, but will also contribute to a further rising in society’s awareness about sustainability issues. This will increase the likelihood that in the future, the problems that scientists predict to be threatening to our existence and the existence of life on the planet will be curbed, thanks to scientific knowledge and specifically the contribution of graph theory.

Still, given its broad scope, it will be impossible to explain graph theory entirely in this article. So, I'll focus on the visual side of any explanation over the formal one since you can easily consult that in any textbook. That will also provide a different point of view from certain definitions.

Also, it's essential that we treat the idea of a graph as comprehensively as possible. We'll focus on its history, representation, and most descriptive properties instead of advanced concepts like singular cycles. This will help you grasp the kernel of graph theory and prepare you to learn these advanced concepts more easily.

Here's what we'll cover:

  1. Basic Elements of Graph Theory
  2. History of Graph Theory
  3. Definition of a Graph
  4. Representations of Graphs
  5. Properties of Graphs
  6. Algorithms and Graph Theory
  7. Why Are Graphs Important in Achieving Sustainability?
  8. Conclusion

Basic Elements of Graph Theory

Whether you are new to Graph Theory or already know something about it, reviewing the basics is always worthwhile.

First, let’s introduce the idea of a “graph” with a usual representation you may have seen:

Image Example of an arbitrary graph

Above, you have a graph where we can see, at the most fundamental level, two different building blocks: vertices (shown as circles) and edges (shown as lines connecting circles).

You can create a structure with those elements that can encapsulate the functioning of many systems present in our life that we don’t even realize.

But, most surprising of all is that graph theory as a whole is derived from such a simple concept as objects linked to each other.

History of Graph Theory

To understand the origin of this idea, we have to look back to the 18th century, when Leonhard Euler solved the famous Seven Bridges of Königsberg problem.

By that time, the city was crossed by the Pregel river, generating four pieces of land interconnected with seven bridges, as seen below:

Image _Image extracted from [here](https://en.wikipedia.org/wiki/File:Konigsbergbridges.png" rel="noopener)

The task consisted of finding a path that crosses all bridges without passing by the same bridge twice, starting and ending at the same point.

At first, with so few bridges, it may be easy to find a brute force solution by trying combinations of paths. But, since we don’t know if a feasible solution exists, it’s helpful to formalize the problem elements and correctly prove its solvability before starting any process.

Also, if the number of bridges increases, it will become much more complex to solve, as the combinations increase remarkably fast.

Image Königsberg problem displayed as a graph

As seen above, Euler represented land areas with graph vertices (also called nodes) and bridges with edges, concluding that it was impossible to have such a traversal through the graph.

Briefly, if we look at the number of edges incident to each vertex, we will see that every value is odd for every node, meaning that the graph does not have an eulerian cycle. This means that it’s not an eulerian graph, and we can’t positively prove the problem.

Nevertheless, this approach represented a breakthrough in the mathematical conception of various questions that were yet unsolvable. Euler’s contributions to the elaboration of this theory, which has been perfected and broadened over the years, made him one of the most influential mathematicians of his time.

Definition of a Graph

Now that you know what a graph looks like drawn on a diagram, let’s review the official formal definition:

A graph G is a pair of sets (V, E) where V is a non-zero set containing the graph’s vertices and E is a set made of element pairs belonging to V.

Image Formal definition of a graph with its corresponding sets

Above, we represented the two main components of a graph in two corresponding sets, one for vertices V and another for edges E. So, our graph G is ultimately an ordered pair of these sets. But before we continue, we must look inside those sets to see what they look like and understand why.

On the one hand, V is a collection of items v in which each element contains the necessary data to define a vertex. Abstractly they are called with the letter v and a numerical subindex.

But in practice, they can be complex objects holding parameters, profiles, and so on.

On the other hand, the set of edges E is a little more complicated to define since it needs to determine the connections between vertices. In this case, the elements are unordered pairs of vertices from set V such that each pair is of the form {x, y}.

Image Both formal and graphical representations of a graph

To familiarize yourself with these structures above, you have an arbitrary, fully defined graph with its respective sets. In V, you can see all the vertices numbered from 1 to 5 and placed in the upper diagram in a specific distribution, but you can arrange them according to your needs.

Meanwhile, in E, you can observe all the edges (lines) establishing an interconnection link between vertices.

The appropriate terminology to address this link is the following: for instance, if we have the edge {v1, v4}, we call it incident to v1 and v4. Also, those vertices are denoted to be adjacent since an edge links them.

As you may notice, there isn’t an edge {v4, v1} in E. But to find an explanation for this phenomenon, we have to introduce the main distinction that generates two classes of graphs.

The first one (undirected), to which the above examples belong, includes all graphs whose edges can be traversed in both directions. This makes them unordered pairs of vertices.

On the other hand, we can have a graph in which all its edges can only be traversed in one direction, that is, from one vertex to another exclusively. Thus, its vertex pairs on E set must be ordered, meaning that going from v1 to v4 is not the same as going from v4 to v1. This second class is known as a directed graph.

Image Example of a directed graph.

Before learning how to represent a graph computationally to perform operations on it, you need to understand the vertex degree concept.

In undirected graphs, the degree of a vertex refers to the number of edges incident to it, considering that self-connecting edges (loops) count as 2 in the total score.

By contrast, in directed graphs, we have in-degree and out-degree values for each vertex, representing the number of incoming and outcoming edges, respectively.

Representations of Graphs

Image The 2 most popular ways to computationally store a graph

Sometimes, the most intuitive solution for a problem is not always the most efficient in computer science. In this context, it generates different ways of representing a graph according to a problem’s nature.

What is an Adjacency Matrix?

An adjacency matrix is one of the most popular methods to store a graph on a computer. But its major drawback is unused memory consumption.

For directed graphs like the one above, there is a matrix size |V|x|V| (being |V| the cardinality of the vertices set, thus the number of vertices on the graph) where each element can be a 0 if there is no connection between vertices or a 1 if the row element links the column one by an outgoing edge. Also, if the graph is weighted, the 1 value is substituted with the weight parameter associated with each edge when necessary.

However, if the graph is undirected, the same criteria apply with the difference that no distinction is made between outgoing and incoming edges this time. So there will be a 1 value if an edge exists between the row and column elements.

Image Adjacency matrix element definition for each type of graph.

What is an Incidence Matrix?

Similar to the previous method, there is a matrix size |V|x|E| in which the same rules are fulfilled. The difference is that if an edge e is incoming to a vertex v, the corresponding element will be a -1 instead of 0.

How to Use Adjacency Lists

When using matrices, if the graph has many vertices but few edges (a sparse graph), the matrix will contain a high number of zeroes. This wastes a lot of memory and makes the representation inefficient in terms of space.

To solve this issue, adjacency lists appeared as an alternative replacing matrices with a combination of different data structures – arrays, and linked lists.

The kernel of this method is an array containing all the graph’s nodes. Each array element will have a linked list holding each leading node’s neighbor vertices (adjacent vertices). In the case of directed graphs, only the neighbor elements connected by an outgoing edge from the lead node will be inside the linked list.

Image Example of a graph depicted as an adjacency list

So if we have a dense graph with a high number of edges, we should store it in matrix form. This has the advantage of O(1) time complexity when checking vertex connection and matrix symmetry along the main diagonal in undirected graphs.

But, if our graph is sparse, the low density of edges make an adjacency list the best choice to depict it computationally.

Properties of Graphs

Like any other mathematical object, graphs have specific properties that make them unique and functional for their purposes. Some have to do with their composition, others with topology, and even accessibility.

Undoubtedly, the most relevant properties concern traversals, since they allow us to model and optimize real-world scenarios.

What is a graph traversal?

First, we need a starting node v1 and an ending node v2 to traverse a graph. Then, we can define a walk from v1 to v2 as an alternate sequence of vertices and edges. There, we can go through these elements as much as we need, and there is always an edge after a vertex (except the last one).

In the case of v1 being equal to v2, the walk would be closed.

Still, we can add repetition restrictions. So if we want a walk in which no edge is repeated, it’s renamed as “trail”. Consequently, if the trail is closed, it would be denoted as “circuit”.

The same happens if we restrict vertex repetition – the walk renames to “path,” and a closed path is known as a “cycle”.

Image Formal and graphical examples of network traversal types.

Image

This traversing ability comes along with an interesting property valid for all existing undirected/directed graphs. It’s formalized as follows:

Image Formalization of the degree sum property.

This establishes that the sum of all vertex degrees equals two times the cardinality of the edge set in an undirected graph. If directed, the sum breaks into two terms, each referring to each node in and out-degree.

This is fairly straightforward to prove, because every time you add an edge to a graph, you need two vertices to build the pair of elements stored on E. So if you add a loop (edge linking a node with itself), you anyways need to define a pair of elements from V, regardless of whether they are the same.

This characteristic supports us when solving questions like:

Given a 6-regular graph (with all its vertex degrees set to 6) of n vertices, how many edges will it have?

As its resolution is immediate, going deeper when thinking about similar questions improves your understanding of its nature and why it's that way.

What is Connectivity?

Now, let’s move on to the properties related to the graph’s linking capability. Starting with an undirected graph, we can assure that a vertex v reaches u if there's a path from v to u. Also, we can look at the whole graph and define it as connected if every pair of vertices in it is indeed connected.

Being connected is often associated with the uniqueness of its components. That is, if we end up with a disconnected graph, its number of components will always be greater than 1.

You can imagine a component as a zone of the graph isolated and disconnected from the rest of the vertices. And this, if we consider a graph, will be connected and will only have one connected component as if it were a connected graph.

Image Example of a 2 component made graph.

In contrast, when dealing with directed graphs, two vertices u and v are said to be strongly connected if they can reach each other and weakly connected if they are connected on the underlying (all edges replaced by undirected ones) graph.

As you can imagine, these properties generate many possibilities and new characteristics to consider.

To briefly mention, we can take advantage of the discrete nature of graphs to remove nodes and edges from them. Therefore, concepts such as articulation points or bridges emerge as one of the simplest ways to study a graph’s weak points.

An articulation point is a vertex that, if we remove from the graph together with all its incident edges, the graph will increase its connected components.

Likewise, a bridge is just an edge meeting the same previous condition with the difference that no vertex is removed from the graph.

Image Visual example of an articulation point and a bridge.

As an extension to the properties section, it’s worth mentioning some tools and characteristics of graphs that will help us recognize the key of the algorithms we will see later:

What are Subgraphs?

Their name is an appropriate indicator of what subgraphs are, since it is quite illustrative. A subgraph is a collection of vertices and edges that we can extract from an arbitrary graph G to form another graph, usually undersized.

Formally, a graph H is a subgraph of G if it’s formed by a subset of vertices of G and similarly a subset of edges of G, with every edge being a valid pair of nodes.

Image Example of a subgraph validity

The number of classifications and research we can perform about subgraphs makes it impossible to cover everything here. But the basis for further learning we'll start with the following ideas about its morphology, topology, and composition.

A subgraph H spans a graph G if both have the same vertices stored on V set. In this situation, subgraph H is known as a spanning subgraph.

Image Example of a spanning subgraph.

Given a graph G, if we apply the vertex removal operation n times with n<|V|, the resulting graph will be an induced graph.

Image Steps taken to reach an induced graph.

Topology doesn't just concern subgraphs. It's also mainly studied with general graphs. So reviewing some broad classifications and features will make graph theory more manageable.

A graph is said to be complete if it’s undirected, has no loops, and every pair of distinct nodes is connected with only one edge. Also, we can have an n-complete graph Kn depending on the number of vertices.

Image Example of the first 5 complete graphs.

We should also talk about the area of graph coloring. A graph is bipartite when its nodes can be divided into two disjoint sets whose union results in the whole initial vertex set, with the condition that every edge has its extremes on both sets simultaneously. This allows for the possibility of coloring each vertex set with a different color.

Also, it can be a complete-bipartite graph if both sets are densely connected (every vertex of one set is connected with all vertices of the other collection).

Image Some examples of arbitrary complete-bipartite graphs.

You might also need to represent a graph in a plane without any of its edges intersecting. Then, if possible, the graph will be planar. To better understand the state of this characteristic, we can use Kuratowski’s theorem. It involves advanced concepts like isomorphism and homomorphism concerning k5 complete and k3,3 complete bipartite graphs.

Image Visual difference between planar and non-planar graphs.

What are Particular Cycles?

Finally, some graph features deserve special attention. For example, when it’s a matter of cycle finding, there's a deep relationship with vertex degrees, integral graph topology, and traversability.

To visualize this relationship, we'll return to the Königsberg problem. In it, we need to traverse all the graph’s edges without repeating any of them, starting and finishing in the same vertex.

Since graphs were new then, Euler developed a solution by defining a unique type of cycle only found in graphs meeting precise conditions – like the degree of all their nodes being even.

These cycles were named Eulerian after their creator, and every graph that has one is also called an Eulerian graph.

There are also Eulerian Paths. These remove the condition of having to start and end on the same vertex and require the graph to have exactly two odd-degree nodes, which will be the path extremes.

Image Visualization of an eulerian path.

Also, suppose we focus on contemporary issues like the traveling salesman problem (TSP), an NP-Hard problem mainly used by delivery and logistic companies.

In that case, we will realize the relevance of the hamiltonian cycles and paths to support practical solutions to similar questions. Similar to the eulerianity, a graph is Hamiltonian if it contains a cycle in which every vertex is used instead of edges.

Image Visualization of a hamiltonian cycle.

These latter properties become challenging to deal with, given the complexity of the problems involved. Although, knowing the critical foundation supporting everything around them allows us to continue exploring with reasonable confidence.

Algorithms and Graph Theory

Once you have a solid grasp of graph theory, its elements, attributes, and tools, we should also review some basic algorithms comprising the principles of almost all other graph processes. Then we can move on to graph theory's use in climate preservation projects.

Breadth-first search algorithm

Here, we will only consider 3 algorithms since there are many types and very specialized ones for determined tasks.

To start with something simple and intuitive, we will unscramble Breadth-First Search. It's a graph traversal algorithm used to go through a graph in a breadthward motion.

In simple terms, it starts at an arbitrary vertex and iteratively visits its adjacent vertices, repeating this step until there are no more unvisited ones.

This behavior serves as the shortest path finder across all graph nodes, although you can stop the execution when a particular vertex is visited.

Image Representation of breadth-first search algorithm

Depth-first search algorithm

The second algorithm is a variant of the previous one, known as Depth First Search. Its goal is similar but is also useful when detecting cycles, connected components, topological sorting, or checking for graph bipartitions.

But the way it works differs in some aspects, like the precedence of the depth over breadth – that is, not all neighboring nodes are visited in each step. Instead, one of them is chosen for further deepening, and the process is repeated until the path reaches a dead end and recursively goes back to the starting node, visiting every vertex.

Image Representation of depth-first search algorithm

Dijkstra's Shortest-Path algorithm

Finally, the last one we will treat is Dijkstra’s algorithm, the most widespread Single Source Shortest Path problem solver ever created.

It’s designed to operate in weighted graphs with non-negative weights, and tries to find the most efficient route between 2 selected nodes.

Compared to the previous algorithms, that change increases the number of steps before completion. However, the key idea behind it is straightforward:

Image Example Graph used to explain Dijkstra's algorithm

As you can see in the above example, if we want to go from v1 to v2, we can select the edge between them and arrive at our destination after traversing six distance units.

On the other hand, if we choose to go through the v3 or v4 paths, we would be walking seven units. So we need to make a decision on whether or not to take a particular path.

On large graphs, the algorithm calculates the provisional shortest paths along every single node. It then updates these values and minimizes “distance” (given by weights) by a complete graph traversal, as you can see in this animation.

Why Are Graphs Important in Achieving Sustainability?

At this point, you may realize that Graph Theory is valuable because it can encapsulate and abstractly model problems of a nuanced nature. Especially those problems whose origin stems from society’s need to pursue a degree of globalization that brings a standard of wellness to everyone’s lives.

Yet many of us are unaware that the comfort we currently enjoy brought about by advances in communications, transport, nutrition, and entertainment requires the coordinated operation of complex systems to be in place.

So the overpopulation experienced since the twentieth century causes these systems to be so massive that they entail a severe environmental impact based on CO2 emissions and the systematic dumping of waste into natural environments.

Graphs can help with transportation of goods

In this context, everything involving the transport of goods and logistics contributes a significant amount of CO2 to the atmosphere. Here is where using graphs has a clear benefit for the environment. They can find optimal paths between cities or world locations, reducing the emissions of the vehicles engaged in such transport.

For example, you can experiment with Google Maps by tracing routes between distant places. You will notice it can automatically choose an appropriate route, minimizing the corresponding environmental cost.

Google Maps is working is based on Single Source Shortest Path algorithms like Dijkstra or advanced ones such as A-star. A-star is a heuristic variant of Dijkstra. These are used in combination with other state-of-the-art graph mechanics used to add certain constraints to algorithms.

Graphs can help with waste management

Graphs also have a place in the global industry by simulating or directly managing networks, manufacturing processes, and schedules. They can potentially reduce the amount of incorrectly handled/wasted energy and resources.

It’s also worth mentioning the numerous possibilities that graphs have to offer when we deal with the problem of excessive waste accumulation.

Nowadays, it's widely believed that plants and trees are the major contributors to oxygen in our atmosphere thanks to photosynthesis. But we have to account that between 50% and 85% of the oxygen released into the atmosphere each year is produced under the sea.

Ironically, data on waste thrown into the ocean are constantly increasing as the consumer society advances on time, causing a dramatic impact on the actual lungs of our planet, as well as on the animal species it shelters.

To avoid having to decide where to dump our garbage, we can use graph theory to generate simulations of molecular physical systems, atomic structures, and chemical reactions to develop new recyclable or biodegradable materials. These would reduce the environmental impact of the products we use.

Also, these simulations have the potential to be useful in biology, where deciphering the ultimate workings of DNA can lead to better food quality, as well as more efficient mass-production methods.

Graphs can help with machine learning and AI

Finally, the most well-known application of graphs is in the field of machine learning.

Despite all the other significant uses for graphs in computer science (like communication networks, distributed systems, or data structures), machine learning has shown us with its exponential evolution over the last decade that it is a highly promising technology when tackling climate change.

Simply put, machine learning is a subset of artificial intelligence that focuses on enabling machines to learn and detect patterns on large datasets. Sometimes, this learning is inspired by natural phenomena like synapses on human neurons, resulting in new techniques such as Artificial Neural Networks.

Regarding environmental care, the ability of these techniques to analyze large amounts of data makes it possible to measure our effect on the planet better.

As a real working example, Joinus4theplanet is an initiative focused on taking advantage of social media to raise awareness about the value of sustainability. It has developed a machine learning system able to perform waste sorting with the help of convolutional models designed to process multidimensional data in order to palliate the effects of incorrect recycling.

Image Example of a social network is represented as a graph. Image from [Wikipedia.](https://en.wikipedia.org/wiki/File:SocialNetworkAnalysis.png" rel="noopener ugc nofollow)

Conclusion

If we want to maintain a considerable amount of progress inside our civilizations and provide a thriving future for the next generations, we have to consider graphs as an essential tool when rethinking the way our technological and economic systems work.

]]> <![CDATA[ How to Calculate Percentage in Excel – Formula for Percentages ]]> https://www.freecodecamp.org/news/how-to-calculate-percentage-in-excel-formula-for-percentages/ 66b0c38ebb3f390180bed0d5 Thu, 18 Aug 2022 17:44:39 +0000 A percentage is a kind of fraction saying how many parts over 100 something is. In this article you will see in detail what a percentage is, and how to calculate a percentage in Excel.

First, before diving into how it works in Excel, let's take a look at the math.

If you want to jump directly to the Excel part, and avoid the math part, please proceed to the section How to work with percentages in Excel.

What is the Formula for Calculating a Percentage?

Percentages from 0% to 100% are equivalent to decimal values from 0 to 1. That means you can convert from a percentage to a decimal number. Let's see how.

How to Convert from Decimal Number to Percentage

You can convert from a decimal number to a percentage in the following way:

  • take the decimal number, (d),
  • multiply it by (100),
  • and then add the percentage (\%) symbol,

In short, if you want to get a percentage from a number (d) you can do this:

$$ ( d \cdot 100 ) \% $$

How to Convert from a Percentage to a Decimal Number

If you want to convert from a percentage to a number, you can:

  • take the percentage (P\%),
  • remove the percentage symbol, (P)
  • then divide the number by (100): (\frac{P}{100})

In short, to convert a percentage (P\%) to a decimal number:

$$ \frac{P\xcancel{\%}}{100} $$

How to Calculate the Percentage of a Number

There are three cases in which you might want to calculate the percentage of a number:

  • to add a percentage to the number (like for calculating how much you have to pay including VAT)
  • to just get the percentage of the number
  • to subtract a percentage from the number (like for a sale)

How to add a percentage to a number

Let's first use a specific case, and then let's generalise.

You went shopping, and the total you need to pay is $185 + VAT. Let's say VAT in this case is 17%.

So you would have to calculate 17% of $185 and then add it to $185.

$$ \$185 \cdot 17 \% + \$185 $$

You can make it a single operation if instead you multiply by ( 117 \% ).

$$ \$185 \cdot ( 100\% + 17\% ) = \$185 \cdot 117\% $$

If you have a simple calculator that doesn't have a percentage operator, you can convert the percentage to a decimal number as we discussed above. Here's what that would look like:

$$ \$185 \cdot 117\% = \$185 \cdot \frac{117 \xcancel{ \% }}{ 100 } = \$185 \cdot 1.17 $$

So, in general, if you want to add a percentage ( P \% ) to a number ( n ) you can do this:

$$ n \cdot ( 100\% + P\%) $$

Or if instead you have the percentage in the decimal number form ( d ) you can do this:

$$ n \cdot (1 + d) $$

How to calculate the percentage of a number

If you want to buy a house you need to pay a deposit on the house. Let's say that's 15% of the total value of the house.

If the house price is $200,000, how can you calculate it?

You can multiply the price by the percent number to get the percentage.

$$ \$200,000 \cdot 15 \% = \$30,000 $$

So if you want to know what's the percentage (P\%) or fraction (d) of a number (m), you can multiply that number by the percentage or fraction.

$$ m \cdot P\% \newline \, \\ m \cdot d $$

How to subtract a percentage from a number

This case is common for calculating the price of an item on sale. For example, if something has an original price of $999 and it is on sale for 20% less, you can calculate the the final price by figuring out what is 20% of $999. Well, it's $199.80, so then you just subtract that value from $999.

The final price of the item on sale is $799.20.

You can calculate it in a single step if you multiply the original price by ((100\% - 20\%)) or (80\%):

$$ \$999 \cdot (100\% - 20\%) = \$999 \cdot 80\% = \$779.20 $$

So the general formula to subtract a percentage (P\%) from a number (b) is:

$$ b \cdot (100\% - P\%) $$

Or in decimal form:

$$ b \cdot (1 - d) $$

How to Calculate the Percentage of a Number in Respect to Another Number

A cake weights 11 lbs, and you eat 3 pieces for a total of 21 oz. How can you know what percentage of cake have you eaten?

It's important to do calculations of this kind with everything in the same units. So, first, let's convert the weight of the cake to ounces.

$$ 11~\mathrm{lb} \cdot \frac{16~\mathrm{oz}}{\mathrm{lb}} = 176~\mathrm{oz} $$

Now it's possible to see the percentage of the cake you've eaten: you need to divide the part (in this case the 21 oz of cake you have eaten) by the whole (the 176 oz of the whole cake):

$$ \frac{11~\mathrm{oz}}{176~\mathrm{oz}} = 0.0625 $$

As seen in the paragraph on how to convert a decimal to a number, you can convert this to a percentage with ( 0.0625 \cdot 100 \% = 6.25\%).

In this example, you have eaten 6.25% of the whole cake.

How Do You Combine Two Percentages?

Let's say that some items in an online store are discounted at 20%, and then there is an offer for a 10% discount for everything in your cart at payment.

If you are getting a discount of 20% and then another 10% on top of that... how much is the discount?

It's not 30%, because the second discount is applied at a different time than the first discount.

A discount of 20% means you pay 80% ((100\% - 20\%)) of the original price, and a discount of 10% means you pay 90% ((100\% - 10\%))of the original price. Combining the two discounts means multiplying together the two percentages, like so:

$$ 80\% \cdot 90\% = 72\% $$

Or in decimal form:

$$ 0.80 \cdot 0.90 = 0.72 $$

So you pay 72% of the original price, or have a discount of 28%.

Why Are a Decimal and a Percentage Equivalent?

Percentage comes from "per cent", or "over one hundred". The percentage symbol represents the line fraction with 100 in the denominator.

$$ 0.20 = \frac{20}{100} = 20\% $$

The percentage is a simple way to describe how many hundredths of a whole something is.

How to Work with Percentages in Excel

Now it's time to start working with Excel. Let's start with a pretty important thing. How do you write percentages in Excel?

How to Write Percentages in Excel

In Excel you can write percentages in two ways:

  • You can write a decimal number and then format the cell as a percentage from the format drop down menu or from the Percent Style button:

Image In the first image the Percent Style button is circled in red, and a decimal number is written in the cell. In the second image, the cell has been formatted as a percentage, and the number is converted to a percentage.

  • You can write a percentage in the cell, and the cell will automatically take the percentage formatting:

Image In the first image you can see that the empty cell has the "General" formatting, in the second image you can see a percentage being written in the cell, and in the third image you can see that the cell has taken the percentage formatting.

The default format is for a whole percentage. You can change the number of decimal places shown with the "Increase Decimal" and "Decrease Decimal" buttons.

Image The two buttons "Increase Decimal" and "Decrease Decimal" circled in red.

Let's say you have a decimal form of 0.12345. Formatting it to a percentage will show ( 12\% ). You can use the buttons to show the decimal places.

Image In the first image, the value 12% appears in the cell K1. In the second image, after using the "Increase Decimal" button twice, the value 12.35% appears in the cell K1. In the third image, after using the button "Decrease Decimal" once, the value 12.3% appears in the cell K1.

How to Calculate the Percentage of a Number in Excel

In math, the percentage of a number is calculated by multiplying that number by the percentage: ( 87\% \cdot 824 = 716.88 ).

In Excel, let's say you have the number in cell A1 and the percentage in cell B1. To calculate the result, you can write in cell C1 =A1*B1:

Image In the first image you can see the formula to calculate the percentage of a number, and then its result in the second image.

How to Calculate the Percentage of a Number with Respect to Another in Excel

In math, you can calculate the percentage of a number with respect to another number by taking the ratio of the two numbers and then converting to a percentage.

If you want to know what percentage 75 is with respect to 142, you can do ( \frac{75}{142} = 0.528 = 52.8\% ).

Let's write 75 in cell G1, and 142 in cell H1. To get the percentage of 75 in respect of 142 you can write in cell I1 =G1/H1. The cell will have the result in decimal format, but you can format it to a percentage using the Percent Style button. Then you can adjust the number of decimal places with the Increase Decimal and Decrease Decimal buttons.

Image In the first image you can see the formula to do the calculation. In the second image it results in a decimal number. In the third image it has been converted to a percentage, and then in the fourth the number of digits after the decimal separator has been changed.

How to Calculate a Percentage of Multiple Percentages in Excel

Let's take the example used above.

An online store has a promotion on some items for 20% off. Then there is another promotion of 10% off for everything in the cart at the moment of payment.

The first discount means you pay 80% of the original price of the item. And then you pay 90% of what's in the cart.

How much is the discount?

You get the result by multiplying the two percentages. ( 90\% \cdot 80\%).

In Excel, if you have the first percentage in I2 and the second in J2, you can write =I2*J2 to calculate the result.

Image In the first image you can see the formula to calculate the percentage from multiple percentages, and then its result in the second image.

Conclusion

Percentages are a mathematical tool we use in every day life. In this tutorial, you have learned how they work mathematically, and how to use them in Excel.

I hope this article has been useful.

]]> <![CDATA[ What is a Factorial? How to Calculate Factorials with Examples ]]> https://www.freecodecamp.org/news/what-is-a-factorial/ 66b0c3bff8d7f56c3f394b08 Wed, 03 Aug 2022 16:32:53 +0000 A factorial is a mathematical operation that you write like this: n!. It represents the multiplication of all numbers between 1 and n.

So if you were to have 3!, for example, you'd compute 3 x 2 x 1 (which = 6). Let's see how it works with some more examples.

Definition of a Factorial

The factorial of a number is the multiplication of all the numbers between 1 and the number itself. It is written like this: n!. So the factorial of 2 is 2! (= 1 × 2).

To calculate a factorial you need to know two things:

  1. 0! = 1
  2. n! = (n - 1)! × n

The factorial of 0 has value of 1, and the factorial of a number n is equal to the multiplication between the number n and the factorial of n-1.

For example, 5! is equal to 4! × 5.

Here the first few factorial values to give you an idea of how this works:

FactorialMultiplicationResult
0!11
1!11
2!1 × 22
3!1 × 2 × 36
4!1 × 2 × 3 × 424
5!1 × 2 × 3 × 4 × 5120
6!1 × 2 × 3 × 4 × 5 × 6720
7!1 × 2 × 3 × 4 × 5 × 6 × 75040
8!1 × 2 × 3 × 4 × 5 × 6 × 7 × 840,320
9!1 × 2 × 3 × 4 × 5 × 6 × 7 × 8 × 9362,880

What is a Factorial Used For?

Practically speaking, a factorial is the number of different permutations you can have with n items: 3 items can be arranged in exactly 6 different ways (expressed as 3!).

For example, let's see all the arrangements you can have with the three items, A, B and C:

ABC
ACB
BAC
BCA
CAB
CBA

And in fact, 3! = 6.

How to Calculate the Factorial of 0

Looking at the factorial from this point of view, what's the factorial of 0?

Well, how many different ways can you arrange 0 elements?

There is exactly 1 way to arrange zero elements. And that's making a sequence of zero elements.

Factorial Use Cases

You typically use a factorial when you have a problem related to the number of possible arrangements. Let's look at some example problems.

Factorial example problem 1: the letters in the word "camper"

How many different ways can you arrange the letters of the word camper?

The word camper has 6 letters, so the number of possible arrangements is given by the factorial of 6: 6! = 6 × 5 × 4 × 3 × 2 × 1 = 720. That would have been a pretty big number of arrangements to find by hand, wouldn't it?

Factorial example problem 2: drawing colored balls from a bag

Let's say there are three balls in a bag – one green, one blue, and one yellow.

If you draw the three balls in sequence, what chance is there that you'll get the yellow first, the green one second, and the blue one last?

Maybe now you are wondering what chances have to do with factorials – well, in a moment you will see.

There are 6 possible sequences in which the balls can be drawn: 3! = 6.

There is a chance of 1 over the total number of possibilities to get the yellow-green-blue sequence, so that is 1/(3!) or 1/6 or 16.7% chance to get the desired outcome.

How to Calculate a Factorial Programmatically with JavaScript

There are two ways to calculate factorials programmatically in JavaScript:

How to calculate a factorial in JS with recursion

Let's get back to the two things to know when calculating a factorial – that is 0! = 1 and n! = (n - 1)! × n. We can use the first one to create the base case of the recursive function, because in that case we know the result already.

function factorial(n) {
  if (n === 0) {
      return 1;
  }
}

The second thing to know about how to calculate a factorial, n! = (n - 1)! × n, can be the recursive case.

function factorial(n) {
    if (n === 0) {
        return 1;
    } else {
        return factorial(n-1) * n;
    }
}

How to calculate a factorial with a JavaScript while loop

We said before that 0! = 1. So, to calculate the factorial of a number with a loop, we can initialize a variable to 1, and multiply the numbers from n to 1 by the variable inside the loop.

In this way, if the input is higher than 1, the output will easily be 1.

function factorial(n) {
    let result = 1;
    for (n > 1) {
        result *= n;
        n--;
    }
    return result;
}

Conclusion

The factorial is a pretty important operator to know if you are interested in statistics and probabilities.

In this article you have learned a how to calculate a factorial, a simple application, and you have seen how to calculate it using JavaScript.

Have fun with it!

]]> <![CDATA[ What Does // Mean in Python? Operators in Python ]]> https://www.freecodecamp.org/news/what-does-double-slash-mean-in-python/ 66adf24ff452caf50fb1fe26 Thu, 21 Jul 2022 15:30:37 +0000 In Python, you use the double slash // operator to perform floor division. This // operator divides the first number by the second number and rounds the result down to the nearest integer (or whole number).

In this article, I will show you how to use the // operator and compare it to regular division so you can see how it works.

It doesn’t end there, though – you will also learn about a Python math method that is synonymous with the double slash // operator.

What We'll Cover

The Basic Syntax of the // Operator

To use the double slash // operator, you do things almost like in regular division. The only difference is that instead of a single slash /, you use double slash //:

firstNum // secondNum

Examples of Floor Division

In the example below, the floor division of 12 by 5 resulted in 2:

num1 = 12
num2 = 5
num3 = num1 // num2

print("floor division of", num1, "by", num2, "=", num3)
# Output: floor division of 12 by 5 = 2

Whereas, the regular division of 12 by 5 would be equal to 2.4. That is, 2 remainder 4: ```py’num1 = 12 num2 = 5 num3 = num1 / num2

print("normal division of", num1, "by", num2, "=", num3)

Output: normal division of 12 by 5 = 2.4


This shows you that the `//` operator rounds down the result of the division of two numbers to the nearest whole number. 

Even if the decimal point is 9, the `//` operator would still round the result down to the nearest whole number.

```py
num1 = 29 
num2 = 10 
num3 = num1 / num2
num4 = num1 // num2

print("normal division of", num1, "by", num2, "=", num3)
print("but floor division of", num1, "by", num2, "=", num4)

"""
Output:
normal division of 29 by 10 = 2.9
but floor division of 29 by 10 = 2
"""

And if you perform floor division with a negative number, the result would still be rounded down.

To prepare your mind for the result, rounding down a negative number means going away from 0. So, -12 divided by 5 results in -3. Don’t get confused – even though at first glance it seems like the nubmer is getting "bigger", it's actually getting smaller (further from zero/a larger negative number).

num1 = -12
num2 = 5
num3 = num1 // num2

print("floor division of", num1, "by", num2, "=", num3)

# floor division of -12 by 5 = -3

The Double Slash // Operator Works Like math.floor()

In Python, math.floor() rounds down a number to the nearest integer, just like the double slash // operator does.

So, math.floor() is an alternative to the // operator because they do the same thing behind the scenes.

Here's an example:

import math

num1 = 12
num2 = 5
num3 = num1 // num2
num4 = math.floor(num1 / num2)

print("floor division of", num1, "by", num2, "=", num3)
print("math.floor of", num1, "divided by", num2, "=", num4)

"""
Output:
floor division of 12 by 5 = 2
math.floor of 12 divided by 5 = 2
"""

You can see that math.floor() does the same thing as the // operator.

How the Double Slash // Operator Works Behind the Scenes

When you use the // operator to divide two numbers, the method that gets called behind the scenes is the __floordiv__().

You can also use this __floordiv__() method directly in place of the // operator:

num1 = 12
num2 = 5
num3 = num1 // num2
num4 = num1.__floordiv__(num2)

print("floor division of", num1, "by", num2, "=", num3)
print("using the floordiv method gets us the same value of", num4)

"""
Output:
floor division of 12 by 5 = 2
using the floordiv method gets us the same value of 2
"""

Conclusion

In this article, you’ve learned how you can use the double slash // operator and how it works behind the scenes.

In addition, you learned about two alternatives of the // operator – math.floor() and the __floordiv__() method.

Don’t be confused about which to use. The three ways you can perform floor division work the same way. But I would advise you to use the double slash // operator because you get to type less with it.

Thank you for reading.

]]> <![CDATA[ Java Random Number Generator – How to Generate Numbers with Math.random() and Convert to Integers ]]> https://www.freecodecamp.org/news/java-random-number-generator-how-to-generate-with-math-random-and-convert-to-integer/ 66d460fe73634435aafcefce Tue, 19 Jul 2022 15:09:37 +0000 By Sebastian Sigl

In many applications, you need random numbers. You might need to throw dice in video games, create a private cryptography key, or create a user’s temporary password.

All these applications depend on random number creation. It’s sometimes challenging to differentiate what to use when, and security is a deep topic. Without spending a few years digging into it, it’s hard to quickly understand the documentation about available implementations and pick the proper way for your use case.

So in this tutorial, I'll summarize the prominent use cases and how to choose the best-performing implementation based on your your Java code.

Image

In this article, you will learn:

  • How to generate integers, floats, and booleans,
  • How generate random numbers for performance-critical use cases,
  • How generate random numbers for security-critical use cases,
  • How numbers generators work,
  • The differences between pseudo random number generators and true random number generators,
  • How to use a seed to your advantage.

All the code examples are minimal, and you can find the complete source code on GitHub.

Constraints of Math.random()

Math.random did exist even before Java 6. It's easy to access and still widely used. With Java 17, a new common interface called RandomGenerator is available, which consolidates all random generator implementations in the current Java SDK.

Math.random() nowadays simply delegates to Random().nextFloat(). But, it only returns a double. So it doesn't allow you to request different types of numbers or generate numbers between ranges. It also doesn't allow you to select from different implementations.

In the following sections, you will learn about a more flexible number generation and learn how to generate numbers optimized for efficiency or security.

Common Interface Since Java 17

With Java 17, a common interface is implemented by the available number generators in the Java SDK. You have methods available for all essential data types, and you can define the expected range you would like to generate numbers for:

RandomGenerator randomGenerator = new Random();

// generate int between 0 - 9
randomGenerator.nextInt(10);

// generate int between 1 - 9
randomGenerator.nextInt(1, 9);

// generate long between 1 - 9
randomGenerator.nextLong(1, 9);

// generate float between 1 - 9
randomGenerator.nextFloat(1, 9);

// generate double between 1 - 9
randomGenerator.nextDouble(1, 9);

// generate random boolean
randomGenerator.nextBoolean();

Performance Optimized Random Number Generation in a Single-Threaded Environment

For many non-security-relevant cases, you do not care how predictable your random number is. Usually, you just want to have a reliable distribution.

More performant implementations than Random are available if your application is single-threaded. One very efficient alternative is called SplittableRandom:

new SplittableRandom().nextInt();

The benchmark executed on a MacBook Pro comparing SplittableRandom and Random shows the following results:

SingleThreaded.Random  116528253,100 ops/s
SingleThreaded.SplittableRandom  619630768,299  ops/s

SplittableRandom performs about 5 times faster than Random in a single-threaded environment.

Additional advantages to Random() are deterministic behavior and splittable fork/join implementation. Summing up, you should prefer using SplittableRandom over Random in single-threaded environments.

Performance Optimized Random Number Generation in a Multi-Threaded Environment

High throughput applications leverage multiple threads. So you want to use a number generator which is made for parallel usage.

The implementation of Random is thread-safe but is relatively slow and slows down even more because of locks. Because SplittableRandom is not thread-safe, it’s not an alternative here.

But, you gain better performance by using ThreadLocalRandom in a multi-threaded environment. It uses SplittableRandom, but ensures performant and secure usage in multiple threads:

ThreadLocalRandom.current().nextInt();

The benchmark executed on a MacBook Pro comparing ThreadLocalRandom and Random generating numbers in parallel using 10 threads shows the following results:

MultiThreaded   Random                      8308724,791         ops/s
MultiThreaded   ThreadLocalRandom  3537955530,922   ops/s

As you can see, using ThreadLocalRandom is 425 times faster. ThreadLocalRandom is lock-free and, therefore, more performant than the thread-safe Random class.

Security Optimized Random Number Generation

The methods we just discussed are speedy and sufficient for most of your applications. But, they are creating so-called pseudo-random-generated numbers.

Instead of always creating a truly random number, they predict a new number based on the previously predicted number, which comes with a state and a severe problem of predictability.

Maybe you want to create long-living secrets for encryption, and you don't want others, by any chance, to be able to predict the next generated token.

In Java, you have SecureRandom for more security-relevant use cases:

SecureRandom.getInstanceStrong().nextInt();

SecureRandom.getInstanceStrong() gives you a provider, which creates secure tokens. In many Linux systems, you use /dev/random, generating numbers based on the random noise of real devices.

But, if you don't have enough random data being collected, so-called missing entropy, the execution can block and take an unexpectedly long time. Especially in machines with a lot of Docker containers, this can lead to a slow execution in practice.

As an alternative, new SecureRandom() does not block by default in case no entropy is available. It also uses a less secure way of number generation as a fallback.

How to Use Seeds to Your Advantage

By default, a pseudo number generator uses a random seed, which reflects the start values used to generate values. So a seed is quite handy for testing, as it gives you control over predictions and allows you to reset how numbers are created.

Until now, we haven't talked about anything related to seeds.

@Test
   public void splittableRandomWithSeedIsDeterministic() {
   assertEquals(new SplittableRandom(9999).nextInt(), -788346102);
}

@Test
   public void randomWithSeedIsDeterministic() {
   assertEquals(new Random(9999).nextInt(), -509091100);
}

This makes testing a lot easier. Otherwise, you would need to always mock dependencies.

Why Number Generation is Hard

Understanding why number generation is hard to get a sense of security is essential.

Engineers write code, which is eventually compiled into machine-readable code executed in a real processing unit (CPU). A CPU is built upon electronic circuits, which consist of logic gates.

Long story short, there is no real randomness you can create with a traditional computer because output requires some input and, by definition, that can not be random.

This means that you need some kind of true random input from the real world, like Thermal noise from a resistor. There are expensive hardware number generators that use real-world physics to give you a lot of capacity for random number creation.

Risks of Unsafe Random Number Generation

Although many protocols are secure by design, they are not if an attacker can predict encryption keys.

Nowadays, a lot of applications require true random number generation behind the scenes. Otherwise, attackers might be able to predict generated numbers and, by doing so, infiltrate applications.

For example, security-related processing breakthroughs based on quantum computing can be a real threat if suddenly attackers can solve encryptions in no time.

Summary

In this blog post, you learned how to generate numbers in Java efficiently. You also learned how to optimize towards performance or security, and you learned what a seed is and how it can be used.

Also, you should now understand the key differences between pseudo and truely random generated numbers, and you should be able to describe why secure random number generation is important.

I hope you enjoyed the article.

If you liked it and felt the need to give me a round of applause or just want to get in touch, follow me on Twitter.

By the way, we are hiring!

References

]]>