Dimitrios Galanakis wrote:
> I was expecting an answer like that... I wanted to ask then if operator 
> overloading if exactly similar to function overloading.
> I would like for example to define my own complex class. In this canse 
> the * operator will perform differencly when multiplying a real and a 
> complex and when multiplying two complex numbers (this is almost what I 
> need to do only the difference is that instead of a complex class I have 
> some other class for which it makes sence to multiply objects of that 
> class together and with real numbers). In other words how can I simplify 
> the following code by removing the ifs?
> 

I'm still a relative Ruby newbie, so I can't bang out any example code, 
but I hope I can point out a couple of useful tidbits. In Ruby classes 
aren't closed. That means you can add methods to Numeric whenever you 
want. Also, as written, your code wouldn't work if you multiplied 
Numeric * Complex

I'd make your new class a subclass of Numeric, and then modify the 
Numeric class. Alias the old * to something else, and put your own 
implementation in place. I still can't see how to get rid of an 'if', 
but your new method can check if either element is Complex then call a 
complex_multiply method, else use the aliased old *.

-Greg Vaughn

> 
> 
> class complex
>     def *(something)
>         result=self.dup
>         if something.kind_of?(Numeric)
>             result.real*=something
>             result.imag*=something
>             return result
>         end
>         if something.kind_of(complex)
>             
> result.real=result.real*something.real-result.imag*something.imag
>             ... etc etc etc
>         end
> 
>     end
> 
> end