MATLAB: Calling superclass method outside of redefined method

classMATLABsuperclass methods

I have an "DataAnalyzer" classdef that has a method that slowly computes exact solutions to certain queries. 
classdef DataAnalyzer < HandleCompatibleSuperClass
    methods
        function obj = DataAnalyzer(dat,varargin)
            obj     = obj@HandleCompatibleSuperClass(varargin{:})
            % lengthy constructor using dat with immutable properties
        end
        y_results = analyze(obj,x_queries) % slow analysis method
        % lots of other user methods to analyze data
    end
end
For debugging, we can get good enough results with a DataInterpolator, that provides all the same methods EXCEPT redefines the analyze method. 
classdef DataInterpolator < DataAnalyzer
    properties(SetAccess=immutable)
        DomainX
        RangeY
    end
    methods 
        function obj = DataInterpolator(x_domain,dat,varargin)
            obj         = obj@DataAnalyzer(dat,varargin{:});
            obj.DomainX = x_domain;
            obj.RangeY  = analyze@DataAnalyzer(obj,x_domain);
            %                    ^ Can't do this!
        end
        function y_results = analyze(obj,x_queries)
            y_results   = interp1(obj.DomainX,obj.RangeY,x_queries,'linear');
        end
        % all those other useful methods to analyze data

    end
end
From https://www.mathworks.com/help/matlab/matlab_oop/calling-superclass-methods-on-subclass-objects.html
Subclass methods can call superclass methods if both methods have the same name.
I realize that I could do something like this…
classdef DataInterpolator < DataAnalyzer
    properties(SetAccess=immutable)
        DomainX
        RangeY
    end
    methods 
        function obj = DataInterpolator(x_domain,dat,varargin)
            obj         = obj@DataAnalyzer(dat,varargin{:});
            % Create a temp object, but time is a penalty.
            temp_obj    = DataAnalyzer(dat,varargin{:});
            obj.DomainX = x_domain;
            obj.DomainY = analyze(temp_obj,x_domain);
        end
        function y_results = analyze(obj,x_queries)
            y_results   = interp1(obj.DomainX,obj.RangeY,x_queries,'linear');
        end
        % all those other useful methods to analyze data
    end
end
But that feels like a really ugly hack, even for debug. Worse, I lose the performance benefits of constructing obj essentially twice.
Is there a smarter way to accomplish what I'd like to do here?

Best Answer

I went back to the author and brought up these techniques. He agrees that the level of hackery is unforuntate, but this is what we agreed to:
  1. An analyze_protected_static method was added to let us access any superclass analyze method.
  2. The constructor of Interpolator calls that static method of the superclass to get the instance data. 
classdef DataAnalyzer < HandleCompatibleSuperClass
    methods
        function obj = DataAnalyzer(dat,varargin)
            obj     = obj@HandleCompatibleSuperClass(varargin{:})
            % ... lengthy constructor using dat to set immutable properties.
        end
        % This method is just a wrapper for the protected, static method.
        y_results = analyze(obj,x_queries) 
        
        % ... lots of other user methods to analyze data
    end
    methods(Static,Access=protected)
        % The true, slow analysis method.
        y_results = analyze_protected_static(obj,x_queries)
    end
end
Then the Interpolator subclass just constructs the domain data from the static method. 
classdef DataInterpolator < DataAnalyzer
    properties(SetAccess=immutable,GetAccess=private)
        DomainX (:,1)
        RangeY  (:,:)
    end
    methods
        function obj = DataInterpolator(x_domain,dat,varargin)
            % Construct object
            obj         = obj@DataAnalyzer(dat,varargin{:});
            obj.DomainX = x_domain;
            obj.RangeY  = DataAnalyzer.analyze_protected_static(obj,obj.DomainX);
        end
        function y_results = analyze(obj,x_queries)
            % No if cases; YAY!
            y_results   = interp1(obj.DomainX,obj.RangeY,x_queries,'linear',nan);
        end
    end
end
Thank you for all your advice. It helped when discussing this with the author. It's unfortunate that we'll have to redistribute the pcode to other members that are using these methods.
Related Question