Bandai Namco has revealed the release date for Captain Tsubasa: Rise Of New Champions on Nintendo Switch and other platforms. You’ll be able to kick off starting from 28th August.

The news comes alongside a brand new trailer which you can check out for yourself above, as well as the news that the game will be available in Standard, Deluxe, and Collector’s Editions (available on digital stores and in participating retailers starting from today), and Champions and Legends Editions which will be exclusive to Bandai Namco’s own online stores.

Back in February, we were treated to details on the game’s story mode. If you missed it, make sure to check that out to learn all about the game ahead of its summer release.

Excited to play this for yourself? Will you be getting it as soon as it launches this August? Let us know in the usual place.

With Paper Mario: The Origami King being revealed for Switch earlier this month, love for the series has once again started to unfold across all corners of the internet. Some take that passion further than others, and amazing videos like this are often the result.

YouTube user JorgeMV has shared a video showing the world and characters of Star Fox 64 in the style of Paper Mario, all wrapped up in a really neat animation. Software like Maya, C4D, After Effects, Illustrator and Photoshop were all used to make the video a reality, but more importantly, it’s utterly charming.

“Star Fox 64 is my favorite game and I always liked the style of Paper Mario, so I thought about making a video that would combine both,” JorgeMV says. “It took me a month and a half, but I finally had time to do it, it was a fun process and I learned a lot trying to improve the video day by day.”

Star Fox isn’t the only Nintendo franchise to be given the fan-made Paper Mario treatment in recent times. We’ve also seen equally delicious takes on both The Legend of Zelda and Ice Climber.

Would you play a game like this? Should we get Nintendo on the phone, demanding for a fresh, paper-based take on the Star Fox franchise? Share your thoughts with us below.

It’s never nice to see a games console finally bite the dust, never to play another game or take centre stage underneath the TV again, but some talented folk save the day by repurposing the poor little things for future use.

Take the talented Joe Heaton, for example, who we’ve previously featured on the site for transforming broken Nintendo DS consoles into gorgeous Game Boy Advance systems. Or indeed the star of today’s article, Reddit user IMOKRUOK, who’s managed to salvage a broken NES by turning it into a fully functioning docking station for a Nintendo Switch.

IMOKRUOK says that they bought a broken NES from a local seller page, stripping out the insides in case they could be used to service their own NES in the future, and reusing its shell to form the casing of this new Switch dock.

You can see the process of the new Switch dock being built here; new internal pieces had to be laser cut and the whole thing fits very snuggly indeed, with the edges of the plastic rounded to avoid any screen scratches.

Not a bad idea, huh? Now you know what to do if your old consoles suffer a similar fate!

Python’s math module provides you with some of the most popular mathematical functions you may want to use. In this article, I’ll take you through the most common ones. You can also watch the following tutorial video in which I’ll guide you through the article:

The math module is part of the Python standard library, and it is always available with every Python installation. However, you must import it before you can start using the functions it contains.

import math

Now every function in the math library is accessible by calling math.function_name(). If you want to import specific functions, use the standard from math import function_name syntax.

Python Math Floor

The math.floor(x) function takes one argument x – either a float or int – and returns the largest integer less than or equal to x.

>>> math.floor(3.9845794)

3

>>> math.floor(9673.0001)

9673

>>> math.floor(12)

12

The largest numbers less than or equal to 3.9845794 and 9673.0001 are 3 and 9673, respectively. Since 12 is an integer, the result of math.floor(12) is 12 itself.

>>> math.floor(-10.5)

-11

The floor of -10.5 is -11. This can sometimes be confusing but remember that -11 < -10 < -9 < … < -1 < 0.

If you create custom a custom Python class, you can make them work with math.floor() by defining a __floor__() method.

Try It Yourself: Run the following interactive Python shell.

Exercise: Can you figure out the output before running it?

Python Math.Ceil

The math.ceil(x) function takes one argument x – either a float or int – and returns the smallest integer greater than or equal to x.

>>> math.ceil(3.9845794)

4

>>> math.ceil(9673.0001)

9674

>>> math.ceil(12)

12

The smallest numbers greater than or equal to 3.9845794 and 9673.0001 are 4 and 9674, respectively. Since 12 is an integer, the result of math.ceil(12) is 12 itself.

>>> math.ceil(-10.5)

-10

The ceiling of -10.5 is -10. Your instinct that 10 < 10.5 is correct when 10 is a positive number. But the opposite is true for negative numbers, and so -10.5 < -10.

If you create custom a custom Python class, you can make them work with math.ceil() by defining a __ceil__() method.

Python Math Operators

The standard mathematical operators are not defined in the math module but rather in the syntax of Python itself.

To add two numbers together, use the + operator.

>>> 5 + 10

15

To subtract two numbers, use the - operator.

>>> 5 - 10

-5

To multiply two numbers together, use the * operator.

>>> 5 * 10

50

To divide two numbers, use the / operator.

>>> 5 / 10

0.5

Note that this always returns a float even if the result is a whole number.

>>> 10 / 5

2.0

Remember that if you take two random numbers and divide them, it is highly unlikely they will divide each other perfectly, so it is logical that all division with / returns a float.

To raise a number to a certain power, use the ** operator.

>>> 5 ** 10

9765625

This is ‘five to the power of ten‘ and you write it in the same order you would write this out by hand.

Then there are some other operators used less often in mathematics but are incredibly useful for computer science and coding: modulus and floor division.

The modulus operator returns the remainder left when one number is divided by another. You perform this calculation with the % operator in Python.

>>> 13 % 3

1

You should read the above line as ‘13 modulo 3‘, and the result is 1. This is because 3 goes into 13 four times (3 x 4 = 12) and the the total difference between 13 and 12 is: 13 – 12 = 1.

Another way to think of it is if you write 13/3 as a compound fraction, you get 4 + 1/3. Looking at the fraction left over – 1/3 – take the numerator (the top part) to get the final result: 1.

If you do many ‘modulo n’ calculations, the set of possible results ranges from 0 up to and including n-1. So for 3, the range of possible results is 0, 1, and 2.

Here are some more examples:

>>> 14 % 3

2

>>> 15 % 3

0

>>> 16 % 3

1

You can see that 15 % 3 is 0. This result is the case for all multiples of 3.

One incredibly useful way to use the modulo operator is in for loops if you want to do something every n-th iteration.

for i in range(10): if i % 4 == 0: print('Divisible by 4!!!') else: print('Not divisible by 4 :(')

Divisible by 4!!!

Not divisible by 4 :(

Not divisible by 4 :(

Not divisible by 4 :(

Divisible by 4!!!

Not divisible by 4 :(

Not divisible by 4 :(

Not divisible by 4 :(

Divisible by 4!!!

Not divisible by 4 :(

Here I used the modulo operator to print Divisible by 4!!! every time i was divisible by 4 – i.e., when i % 4 == 0 – and print Not divisible by 4 :( in all other cases.

The final built-in operator is related to modulo. It performs floor division and is written as //. As the name suggests, floor division is the same as normal division but always rounds the result down to the nearest whole number.

If you write 13/3 as a compound fraction, you get 4 + 1/3. Floor division returns the whole number part of this fraction, 4 in this case.

>>> 13 // 3

4

>>> 13 / 3 4.333333333333333

Here I calculated ‘thirteen floor three’, and this returns 4. The result of ‘thirteen divided by three’ is 4.3333, and if you round this down, you get 4.

Another way to think of it is if you write 13/3 as a compound fraction, you get 4 + 1/3. Floor division returns the whole number part of this fraction, 4 in this case.

Here are some more examples:

>>> 14 // 3

4

>>> 15 // 3

5

>>> 16 // 3

5

Note that all of the above examples are ints being floor divided by ints. In each case, Python returns an int. But if either of the numbers is a float, Python returns a float.

>>> 14.0 // 3

4.0

>>> 14 // 3.0

4.0

This result is different to normal division / which always returns a float.

You can perform floor division on any two numbers, but you may get surprising results if you add decimal places.

# No difference to normal

>>> 14.999 // 3

4.0

# Returns 3.0, not 4.0!

>>> 14 // 3.999

3.0

# Now we see why

>>> 14 / 3.999

3.500875218804701

When you run 14 // 3.999, the result is 3.0 because 14 / 3.999 is 3.508... and the floor of 3.508... is 3.

Floor division for negative numbers works in the same way.

>>> -14 / 3

-4.666666666666667

>>> -14 // 3

-5

Recall that floor division takes the lower number and that -5 < -4. Thus the result of floor division for negative numbers is not the same as adding a minus sign to the result of floor division for positive numbers.

Try It Yourself: Run the following interactive Python shell.

Exercise: Which line does not produce output integer 42?

Python Math Domain Error

You may encounter a special ValueError when working with Python’s math module.

ValueError: math domain error

Python raises this error when you try to do something that is not mathematically possible or mathematically defined.

import numpy as np

import matplotlib.pyplot as plt # Plotting y = log(x)

fig, ax = plt.subplots()

ax.set(xlim=(-5, 20), ylim=(-4, 4), title='log(x)', ylabel='y', xlabel='x')

x = np.linspace(-10, 20, num=1000)

y = np.log(x) plt.plot(x, y)

This is the graph of log(x). Don’t worry if you don’t understand the code, what’s more important is the following point. You can see that log(x) tends to negative infinity as x tends to 0. Thus, it is mathematically meaningless to calculate the log of a negative number. If you try to do so, Python raises a math domain error.

>>> math.log(-10)

Traceback (most recent call last): File "<stdin>", line 1, in <module>

ValueError: math domain error

Python Math Round

Rounding is more complicated than you might expect. Incorrectly rounding floats has lead to disastrous consequences. The Vancouver Stock Exchange used an overly simplified rounding algorithm when trading stocks. In less than two years, the algorithm resulted in the price of the stock exchange being half of what it should have been!

The round() function is not part of the math module but rather a built-in function you can access at all times.

It accepts two arguments:

round(number[, ndigits])

The number is an int or float, and ndigits is the rounding precision you want after the decimal point. The square brackets around ndigits signify that it is an optional argument. If you omit ndigits, Python rounds number to the closest integer.

# Closest integer

>>> round(10.237)

10

# One decimal place

>>> round(10.237, 1)

10.2

# Two decimal places

>>> round(10.237, 2)

10.24

Here you can see that round() works as you would expect.

First, I want to round 10.237 to an integer. So, let’s look at the first value after the decimal place and round down if it’s less than 5 and up if it’s greater than 5. The first value is 2, and so you round down to get 10. For the next example, round 10.237 to one decimal place. Look at the second decimal place – 3 – and so round it down to get 10.2. Finally, round 10.237 to two decimal places by looking at the third decimal place – 7 – and rounding up to get 10.24.

This algorithm works as expected; however, it is not that simple. Let’s look at rounding 1.5 and 2.5.

>>> round(1.5)

2

This rounds to 2, as expected.

>>> round(2.5)

2

But this also rounds to 2! What is going on?

The round() function applies a type of rounding called ’rounding half to even’. This means that, in the event of a tie, Python rounds to the closest even number.

The mathematical logic underpinning it is explained here, but in short, the reason Python does this is to preserve the mean of the numbers. If all the ties are rounded up (as we are taught in school), then if you round a collection of numbers, the mean of the rounded numbers will be larger than the mean of the actual collection.

Python assumes that about half will be odd for a random collection of numbers, and half will be even. In practice, this is true most of the time. However, there are more mathematically rigorous methods you can use in extreme circumstances.

Note that floating-point arithmetic has some inherent issues that cannot be resolved. Fortunately, this is built into all programming languages, mainly because computers represent floats as binary numbers. Some numbers that have finite floating-point representations – such as 0.1 – have infinite binary representations – 0.0001100110011… – and vice versa. Thus, the round() function is not perfect.

# Expected 2.68 but got 2.67

>>> round(2.675, 2)

2.67

From what I’ve said above, this example should return 2.68 as that is an even number. However, it returns 2.67. This result is not a bug and is a known property of the function. For the vast majority of cases, round() works as I described above, but you should know that it is not perfect. If you want something more precise, use the decimal module.

Python Math Pi

The math module includes some mathematical constants, one of which is π (pi).

>>> math.pi

3.141592653589793

It is the ratio of the circumference of a circle to its diameter and is 3.141592653589793 to 15 decimal places. If you are going to use this constant a lot, I recommend importing it separately to save you typing out math. every time you want to use it.

>>> from math import pi

>>> pi

3.141592653589793

Python Math Sqrt

To calculate the square root of a number, use the math.sqrt(n) function.

>>> math.sqrt(2)

1.4142135623730951

>>> math.sqrt(16)

4.0

Note that this always returns a float. Even if you pass an int and Python can express the result as an int, it always returns a float. This functionality is similar to the division operator and makes logical sense; the vast majority of times you calculate a square root, it will not return an integer.

As of Python 3.8, there is also the function math.isqrt(n) which returns the integer square root for some integer n. This result you get is the same as applying math.sqrt(n) and then math.floor() to the result.

# Only works with Python 3.8

>>> math.isqrt(2)

1

>>> math.isqrt(16)

4

If you pass numbers that have precise square roots, you get a similar result to math.sqrt(), but the result is always an integer.

>>> math.isqrt(16.0)

Traceback (most recent call last): File "<stdin>", line 1, in <module>

TypeError: 'float' object cannot be interpreted as an integer

You cannot pass a float.

>>> math.isqrt(17)

4

>>> math.floor(math.sqrt(17))

4

The function math.isqrt(n) is the same as math.floor(math.sqrt(n)) if n is an integer,

Python Math Abs

The abs() function is a built-in function that returns the absolute value of a number. The function accepts integers, floats, and complex numbers as input.

If you pass abs() an integer or float, n, it returns the non-negative value of n and preserves its type. In other words, if you pass an integer, abs() returns an integer, and if you pass a float, it returns a float.

# Int returns int

>>> abs(20)

20

# Float returns float

>>> abs(20.0)

20.0

>>> abs(-20.0)

20.0

The first example returns an int, the second returns a float, and the final example returns a float and demonstrates that abs() always returns a positive number.

Complex numbers are made up of two parts and can be written as a + bj where a and b are either ints or floats. The absolute value of a + bj is defined mathematically as math.sqrt(a**2 + b**2). Thus, the result is always positive and always a float (since taking the square root always returns a float).

>>> abs(3 + 4j)

5.0

>>> math.sqrt(3**2 + 4**2)

5.0

Here you can see that abs() always returns a float and that the result of abs(a + bj) is the same as math.sqrt(a**2 + b**2).

Python Math Random

To generate random numbers, you must use the Python random module rather than the math module. That link takes you to an article I’ve written all about it.

Python Math Degrees

It is important that you can quickly switch between degrees and radians, especially if you work with trigonometric functions.

Let’s say you have an angle r which is in radians, and you want to convert it to degrees. Simply call math.degrees®.

Let’s look at some common examples.

# You need to use pi a lot, so let's import it

>>> from math import pi

>>> math.degrees(pi)

180.0

>>> math.degrees(pi/4)

45.0

>>> math.degrees(2*pi)

360.0

First, I imported pi so that I could easily use it in all the functions. Then I calculated some common degree-to-radians conversions. Note that math.degrees() always returns a float. This result is expected as the vast majority of the time, the result of a conversion is not a whole number.

Note that, as is always the case with floating-point arithmetic, this function is not perfect.

>>> math.degrees(pi/3)

59.99999999999999

This should return 60.0. But note that since 0.999… recurring equals 1, it will not negatively impact your results.

Python Math Radians

Let’s say you have an angle d in degrees, and you want to convert it to radians. Simply call math.radians(d).

Let’s look at some common examples.

>>> from math import pi

>>> math.radians(180)

3.141592653589793

>>> math.radians(180) == pi

True

>>> math.radians(45)

0.7853981633974483

>>> math.radians(45) == pi/4

True

One downside with converting degrees to radians is that radians are much harder for humans to read. So, I added in the equality statements afterward to show you that 180 degrees, when converted to radians, is π and likewise for 45 degrees and π/4.

This function is especially crucial if you want to use any of the trigonometric functions as they assume you are passing an angle in radians.

Python Math Sin

To calculate the sine of some angle r, call math.sin®. Note that the function assumes that r is in radians.

>>> math.sin(0)

0

# Assumes angle is in radians!

>>> math.sin(90)

0.8939966636005579

# Convert to radians

>>> math.sin(math.radians(90))

1.0

# Enter as radians

>>> math.sin(pi/2)

1.0

From high school math, we know that sin(90) = 1.0 if 90 is in degrees. But here I demonstrate that you do not get 1.0 if you input 90. Instead, input pi/2, and you get the expected result. Alternatively, you can use the math.radians() function to convert any angle in degrees to radians.

Let’s look at the result for math.sin(pi).

>>> math.sin(pi)

1.2246467991473532e-16

Again, from high school math, you expect the result to be 0.0, but, as is often the case with floating-point arithmetic, this is not the case. Although we know that the sine of 0 and π are the same value, unfortunately, it is not reflected in the output. This result is because π is an infinite decimal that cannot be represented fully in a computer. However, the number is so small that it should not make a massive difference to your calculations. But if you need it to equal 0, there are some methods you can try, but I will not discuss them in this article for brevity.

Finally, note that all the values returned are floats even if Python can represent them as integers.

Python Math Cos

To calculate the cosine of some angle r, call math.cos®. Note that the function assumes that r is in radians.

>>> math.cos(0)

1.0

# Assumes angle is in radians

>>> math.cos(180)

-0.5984600690578581

# Convert to radians

>>> math.cos(math.radians(180))

-1.0

# Enter angle in radians

>>> math.cos(pi)

-1.0

From high school math, we know that cos(180) = -1.0 if 180 is in degrees. However, the trigonometric functions expect the angle to be in radians. So, you must either convert it to radians using the math.radians(180) function, or enter the actual radians value, which is pi in this case. Both methods give you the answer -1.0 as expected.

Let’s look at the result of math.cos(pi/2).

>>> math.cos(pi/2)

6.123233995736766e-17

The result of math.cos(pi/2) should be 0.0, but instead, it is a tiny number close to 0. This is because π is an infinite decimal that cannot be represented entirely in a computer. This functionality should be fine for most cases. If you must have it equal to 0, check out this Stack Overflow answer for alternative methods you can use.

Python Math Tan

To calculate the tangent of some angle r, call math.tan®. Note that the function assumes that r is in radians.

>>> math.tan(0)

0.0

>>> math.tan(pi/4)

0.9999999999999999

>>> math.tan(pi/2)

1.633123935319537e+16

The results for math.tan() are similar to those for math.sin() and math.cos(). You get the results you expect for 0.0, but once you start including pi, nothing is exactly what you expect. For example, tan(pi/4) is 1, but Python returns 0.999.... This may not look the same, but, mathematically, they are equal). The result of tan(pi/2) should be positive infinity, but Python returns a huge number instead. This result is nice as it lets you perform calculations with math.tan() without throwing loads of errors all the time.

Conclusion

There you have it; you now know how to use the most common functions in Python’s built-in math module!

You can take the floor or ceiling of any number using math.floor() and math.ceil(). You know all the essential operators, what types they return, and when. You’ve seen that Python raises a Math Domain Error if you try to do something mathematically impossible. And you can use some essential functions and constants for scientific computing such as math.pi, converting angles from degrees to radians and using the most common trigonometric functions – sin, cos, and tan.

There are some more functions I didn’t get the chance to cover in this article, such as the inverse and hyperbolic trigonometric functions. With your knowledge, you’ll easily understand and use them if you quickly read the docs.

Where To Go From Here?

Do you wish you could be a programmer full-time but don’t know how to start?

Check out the pure value-packed webinar where Chris – creator of Finxter.com – teaches you to become a Python freelancer in 60 days or your money back!

https://tinyurl.com/become-a-python-freelancer

It doesn’t matter if you’re a Python novice or Python pro. If you are not making six figures/year with Python right now, you will learn something from this webinar.

These are proven, no-BS methods that get you results fast.

This webinar won’t be online forever. Click the link below before the seats fill up and learn how to become a Python freelancer, guaranteed.

https://tinyurl.com/become-a-python-freelancer

If you follow Gamefromscratch on Twitter, you may have already seen this tweet I put out last night about a blackmail demand that was made against our YouTube channel:

First off, I really want to give a gigantic shout out to all of the people that helped get the message out, the tweets, retweets and even Reddit post.  You are an amazing community and hopefully if we yell loud enough, YouTube will here and fix this!

Basically it started with a message in the GFS Discord server claiming to have taken down my Animate CC video.  This video unfortunately has been taken down and reinstated 4 times in the last two months, this happened after YouTube turned up the bots responsibility due to Covid-19, so I had written it off as bots malfunctioning.  Each time it was taken down, I appealed and it would be restored.  After I didn’t pay the $50 in bitcoin, I started getting Circumvention of Technology notices for 3 of my videos.  That ultimately resulted in a community strike and loss of access to my channel for a week (or until appealed).  Thankfully those  three takedowns were reversed in about 2 hours and channel privileges were restored.

Today I was just waiting for YouTube to restore my 2 year old Animate CC video… then to my shock, it was reviewed and found to be in violation!  Even after multiple previous reviews, as you can see from these email snippets!

So that is where things stand now.  My channel is back, 3 out of 4 of my videos are returned.  Thing is, anyone that wants can do this exact same attack whenever they want.  It was reported to YouTube and frankly they did nothing.  Any YouTube creator you love can have their channel taken down by spamming Circumvention of Technology claims, and there really isn’t anything you can do about it.  YouTube assumes your guilt and until the review clears you name, your video is down.  As you can see from the above emails, your video doesn’t always come back.

The single biggest piece of advice I can give to any YouTube creator, make sure your content is mirrored on another network!   After my Animate CC video was taken down the second time, I started mirroring to Lbry.tv and I recommend you do to!  Thanks to mirroring to Lbry, my Animate CC video lives on!  So if you want to try to spot the copyright circumvention YouTube reviewers “found”, you can!

Hopefully if we yell loud enough, YouTube will hear and creators will be protected from insanity like this in the future!  You can learn much more in the video below.  Once again, thank you to everyone that helped amplify my voice, it was and is much appreciated!

Totally Off Topic Rant

---

Outfit 7 has announced the release date for the newest installment in the Talking Tom series, My Talking Tom Friends. It launches on June 12 on Android and iOS, with pre-registration open on Google Play right now. Over the years, Outfit 7 has cemented itself as the de facto developer and publisher of virtual mobile pet sims, with their suite of games receiving 12 billion downloads in the last alone decade.

My Talking Tom Friends is built upon Outfit 7’s success in those previous titles, advancing the formula by letting you care for all of Talking Tom’s characters at once under the same roof. The game takes place in a kind of domestic sandbox, as you cater to the needs of your cast of creatures.

It’s a little like The Sims – if all of your Sims somehow transformed into anthropomorphic animals and forgot how to look after themselves. Characters like Talking Tom, Ginger, Angela, Hank, Ben, and Becca are all present in the house, which you can also decorate and customise to your preference.

Below you can find one of the series shorts that makes Talking Tom and its characters so beloved:

When asked about the new installment in the series, senior game designer, Barbara Erman, said this:

“We wanted to give fans the perfect blend of caring for their favorite characters and having amazing experiences with them. And where the line between ‘you’ and ‘them’ disappears as you get drawn into the bright, vivid world of games, fun, and friendship.”

If Talking Tom sounds like your kind of game, then you can get your hands on the real thing on June 12. You can also currently pre-register on Google Play, though not for iOS just yet.