Don't ever reinvent the wheel. Fraction is decently cooperative class, you should never have to write basic operations from scratch. Use the inherited stuff. Here is the solution for basic arithmetic, shouldn't be hard to adapt for many other protocols. Also, it doesn't handle negative numbers because I'm lazy, I trust you can add support for that too.

from fractions import Fraction
class Mixed(Fraction):
    def __new__(cls, a, b, c):
        return super().__new__(cls, a*c + b, c)
    def __str__(self):
        return '{} {}'.format(*divmod(Fraction(self), 1))
    def inject(name, *, namespace = locals()):
        name = '__{}__'.format(name)
        def method(*args):
            result = getattr(Fraction, name)(*args)
            return Fraction.__new__(Mixed, result)
        namespace[name] = method
    for name in 'add sub mul truediv'.split():
        inject(name)
        inject('r' + name)
    for name in 'abs pos neg'.split():
        inject(name)
    del name, inject
print(Fraction(122,3) / Mixed(4,5,6) + 5)  # 13 12/29


Mixed number fractions class
What are the most important applications of improper integrals, in particular to computer science and related fields, and to technology and engineering in general?

I know that improper integrals are very common in probability and statistics; also, the Laplace transform, the Fourier transform and many special functions like Beta and Gamma are defined using improper integrals, which appear in a lot of problems and computations. But what about their direct, practical applications in real life situations?

Any insight is much appreciated!
