Wie kann ich einen beliebigen binären oder unären Operator für eine Klasse überladen?

Question

Angenommen, Sie haben eine Klasse x, ein Array vererben einige Parameter angeben p:

classdef test 
    properties 
     x 
     p 
    end 
    methods 
     function t=calculate(t) 
      [t.x,t.p]=calc(x,p); 
     end 
     function t=plus(t1,t2) 
      t.x=t1.x+t2.x; 
     end 
    end 
end 

Es ist bekannt, wie binäre Operatoren zu überlasten, wie plus, mtimes, minus, etc .. Wie kann ich ermöglichen für Überlastung irgendein binärer vektorisierter Operator, oder schließlich irgendein unärer Operator wie mean, abs, max, usw., um direkt über dem Vektor x angewendet zu werden? Zum Beispiel, wie kann ich S = mean(S); entsprechen S.x = mean(S.x);?

Answer 1

Wenn ich Ihre Frage richtig verstanden, es klingt wie Sie Ihre neue Klasse wollen test einfach alle binären und unären Methoden für die Klasse des Objektes x (und arbeiten auf dem Grundstück x, wenn sie aufgerufen wird) definiert erben, so dass Sie müssen sie nicht alle selbst neu definieren.

Wenn das ist, was Sie wollen, dann denke ich, den einzig gangbaren Weg, etwas zu tun, wie es tatsächlich ist Vererbung zu verwenden und Ihre Klasse test ein subclass der Klasse der Eigenschaft x machen. Betrachtet man den einfachen Fall, in dem x nur ein double ist, kann ein gutes Beispiel für die Unterklasse des eingebauten double Typs here gefunden werden. Die Anpassung dieses Beispiel zu Ihnen, hier ist eine Art und Weise Sie Ihre Klasse test implementieren könnte:

classdef test < double 

    properties 
    p 
    end 

    methods 
    function obj = test(x, p) 
     if (nargin < 2) 
     p = 0; 
     if (nargin < 1) 
      x = 0; 
     end 
     end 
     obj@double(x); 
     obj.p = p; 
    end 

    function sref = subsref(obj, s) 
     switch s(1).type 
     case '.' 
      switch s(1).subs 
      case 'p' 
       sref = obj.p; 
      case 'x' 
       x = double(obj); 
       if (length(s) < 2) 
       sref = x; 
       elseif (length(s) > 1) && strcmp(s(2).type, '()') 
       sref = subsref(x, s(2:end)); 
       end 
      otherwise 
       error('Not a supported indexing expression') 
      end 
     case '()' 
      x = double(obj); 
      newx = subsref(x, s(1:end)); 
      sref = test(newx, obj.p); 
     case '{}' 
      error('Not a supported indexing expression') 
     end 
    end 

    function obj = subsasgn(obj, s, b) 
     switch s(1).type 
     case '.' 
      switch s(1).subs 
      case 'p' 
       obj.p = b; 
      case 'x' 
       if (length(s) < 2) 
       obj = test(b, obj.p); 
       elseif (length(s) > 1) && strcmp(s(2).type, '()') 
       x = double(obj); 
       newx = subsasgn(x, s(2:end), b); 
       obj = test(newx, obj.p); 
       end 
      otherwise 
       error('Not a supported indexing expression') 
      end 
     case '()' 
      x = double(obj); 
      newx = subsasgn(x, s(1), b); 
      obj = test(newx, obj.p); 
     case '{}' 
      error('Not a supported indexing expression') 
     end 
    end 

    function disp(obj) 
     fprintf('p:'); 
     disp(obj.p); 
     fprintf('x:'); 
     disp(double(obj)); 
    end 
    end 

end 

Es gibt eine Einschränkung: Das Ergebnis Sie erhalten mit double Operatoren und Methoden auf Objekte der Klasse test werden die Ergebnisse der Klasse zurückgeben double, nicht test, wie Sie möchten. Um das Verhalten zu erhalten Sie möchten, wird das Ergebnis auf Eigenschaft x jedes Mal neu zuordnen müssen, wie in den folgenden Beispielen:

>> a = test(1:3, pi) % Create an object with p = pi, and x = [1 2 3] 

a = 
p: 3.141592653589793 
x:  1  2  3 

>> a.x = -a % Unary operation on a, and reassignment to x 

a = 
p: 3.141592653589793 
x: -1 -2 -3 

>> a.x = a+4 % Binary operation and reassignment 

a = 
p: 3.141592653589793 
x:  3  2  1 

>> a.x = mean(a) % Another unary operation and reassignment 

a = 
p: 3.141592653589793 
x:  2