Do I have to override all math operators in a subclass?

method overriding in python
method overriding in java
python operator overloading list
method overloading
inheritance in java
python operator overloading assignment
polymorphism
how to overload division operator in python

I want to make a simple Point2d class in a Python 3.7 program that implements just a few features. I saw in an SO answer (that I can't find now) that one way to create a Point class was to override complex so I wrote this:

import math

class Point2d(complex):

    def distanceTo(self, otherPoint):
        return math.sqrt((self.real - otherPoint.real)**2 + (self.imag - otherPoint.imag)**2)

    def x(self):
        return self.real

    def y(self):
        return self.imag

This works:

In [48]: p1 = Point2d(3, 3)

In [49]: p2 = Point2d(6, 7)

In [50]: p1.distanceTo(p2)
Out[50]: 5.0

But when I do this, p3 is instance of complex, not Point2d:

In [51]: p3 = p1 + p2

In [52]: p3.distanceTo(p1)
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-52-37fbadb3015e> in <module>
----> 1 p3.distanceTo(p1)

AttributeError: 'complex' object has no attribute 'distanceTo'

Most of my background is in Objective-C and C# so I'm still trying to figure out the pythonic way of doing things like this. Do I need to override all the math operators I want to use on my Point2d class? Or am I going about this completely the wrong way?


In this case I suggest to implement your class Point2d from scratch.

If you're lazy, take a look to some lib like sympy which includes a Point class and other geometry stuff https://docs.sympy.org/latest/modules/geometry/index.html

Programming Smalltalk – Object-Orientation from the Beginning: An , A class from which no instances can be created is called an abstract class. the protocol mathematical functions a series of mathematical functions for all types message Unhandled Exception: My subclass should have overridden one of my​  Subclass Syntax Subclass Definition Syntax. To define a class that is a subclass of another class, add the superclass to the classdef line after a < character:


The problem, is that your class, when it uses any of the data model functions belonging to complex It returns a complex, so you'll need to turn this in to your Point2d class

adding this method should do the trick

def __add__(self, b):
    return Point2d(super().__add__(b))

But still there should be a better way of doing it. But this is the way to dynamically wrap some Data Model (dunder) methods.

By the way, the distance function you can make it shorter something like this

def distanceTo(self, otherPoint):
    return abs(self - otherPoint)

Operator and Function Overloading in Custom Python Classes , How to overload built-in functions and operators in your custom Python classes In fact, when you obtain the list of attributes and methods of a str object using To do this, you only need to define the corresponding special method in your class. If your class represents a mathematical entity like a vector, a coordinate, or a  Yes, I've already override all the subclass, and they are work. But I am stuck in the superclass livingRoomItem toString method. How can I call all it's subclass's getDescription method?


I'm going to mention a way of overriding all the methods without manually writing each of them, but only because we are all consenting adults here. I don't really recommend it, it is much clearer if you just override each and every operation. That said, you can write a class wrapper which inspects all the methods of the base class and converts the output to a point if it is a complex type.

import math
import inspect


def convert_to_base(cls):
    def decorate_func(name, method, base_cls):
        def method_wrapper(*args, **kwargs):
            obj = method(*args, **kwargs)
            return cls.convert(obj, base_cls) if isinstance(obj, base_cls) else obj
        return method_wrapper if name not in ('__init__', '__new__') else method
    for base_cls in cls.__bases__:
        for name, method in inspect.getmembers(base_cls, inspect.isroutine):  # Might want to change this filter
            setattr(cls, name, decorate_func(name, method, base_cls))
    return cls


@convert_to_base
class Point2d(complex):

    @classmethod
    def convert(cls, obj, base_cls):
        # Use base_cls if you need to know which base class to convert.
        return cls(obj.real, obj.imag)

    def distanceTo(self, otherPoint):
        return math.sqrt((self.real - otherPoint.real)**2 + (self.imag - otherPoint.imag)**2)

    def x(self):
        return self.real

    def y(self):
        return self.imag

p1 = Point2d(3, 3)
p2 = Point2d(6, 7)
p3 = p1 + p2
p4 = p3.distanceTo(p1)
print(p4)

# 9.219544457292887

What is happening here is that it just checks all the methods of the base class, and if what it returns is of the type of the base class, converts it to the child class, as defined by the special classmethod in the child class.

Using Macromedia Flash MX, If the change worked , Math . sqrt ( 4 ) would yield 8 . The second changes it for the Bird class and all its descendants — Raptor , Eagle , BaldEagle , and Auk . ( Statements implementing the functions would go inside the curly braces . ) You want to create a subclass with a method that overrides a superclass method . Hence in simple words, method overriding is overriding the definition of a superclass method in its subclass. Besides other rules that we are going to explain for method overriding, one basic rule is that the superclass method being overridden must have the same name in the subclass as well. Use of method overriding


In general, prefer composition to inheritance. You can implement all the desired operations in terms of complex numbers.

class Point2D:
    def __init__(self, x, y):
        self._p = complex(x,y)

    @classmethod
    def _from_complex(self, z):
        return Point2D(z.real, z.imag)

    def __add__(self, other):
        return Point2D._from_complex(self._p + other._p)

    # etc

Is it a lot of boilerplate? Yes. But it's not really boilerplate you can avoid.

Matlab: A Practical Introduction to Programming and Problem Solving, For example, we can perform mathematical operations such as adding and The methods in a subclass can override methods from the superclass if they have All figures consist of objects, each of which is referenced using an object handle  Operator Overloading Why Overload Operators. By implementing operators that are appropriate for your class, you can integrate objects of your class into the MATLAB ® language. For example, objects that contain numeric data can define arithmetic operations like +, *, -so that you can use these objects in arithmetic expressions.


Overriding in Java, When a method in a subclass has the same name, same parameters or Final methods can not be overridden : If we don't want a method to be Used correctly​, the superclass provides all elements that a subclass can use directly. Check if a Number is Odd or Even using Bitwise Operators · C program to sort an array in​  A subclass must override all abstract methods of an abstract class. However, if the subclass is declared abstract, it's not mandatory to override abstract methods. We can access the static attributes and methods of an abstract class using the reference of the abstract class.


Overridding, The method as implemented in the subclass will be the one that counts for the to the subclass, if necessary, using the super keyword together with the dot operator. Therefore, both classes may choose to override their inherited display methods. After all, they do not actually do anything in the Shape class, and they are  The subclass can implement a different property with the same name. Private Local Property Takes Precedence in Method When superclass and subclass define a property with the same name, methods that refer to this property access the property of the class defining the method.


Java Inheritance, Variables · Java Data Types · Java Math Operators and Math Class · Java Arrays For instance, do you need to refer to Car and Truck objects as Vehicle objects? The subclass can also override (redefine) the inherited methods. When a subclass extends a superclass in Java, all protected and public  Operator overloading (C# reference) 07/05/2019; 3 minutes to read; In this article. A user-defined type can overload a predefined C# operator. That is, a type can provide the custom implementation of an operation in case one or both of the operands are of that type.