function [c,ia] = setdiffR2012a(a,b,options)

% 'R2012a' flag implementation

% flagvals = {'rows' 'sorted' 'stable'};

if nargin == 2 

    byrow = false; 

    order = 'sorted'; 

else

    byrow = (options(1) > 0);

    if options(3) > 0

        order = 'stable';

    else % if options(2) > 0 || sum(options(2:3)) == 0)

        order = 'sorted';

    end

end 

% Check that one of A and B is double if A and B are non-homogeneous. Do a

% separate check if A is a heterogeneous object and only allow a B

% that is of the same root class.  

if ~(isa(a,'handle.handle') || isa(b,'handle.handle')) 

    if ~strcmpi(class(a),class(b)) 

        if isa(a,'matlab.mixin.Heterogeneous') && isa(b,'matlab.mixin.Heterogeneous') 

            rootClassA = meta.internal.findHeterogeneousRootClass(a);

            if isempty(rootClassA) || ~isa(b,rootClassA.Name)

                error(message('MATLAB:SETDIFF:InvalidInputsDataType',class(a),class(b)));

            end

        elseif ~(strcmpi(class(a),'double') || strcmpi(class(b),'double')) 

            error(message('MATLAB:SETDIFF:InvalidInputsDataType',class(a),class(b)));

        end

    end 

end 

% Determine if A is a row vector.

rowvec = isrow(a); 

sparseA = false; 

% Determine if A is sparse

if issparse(a) 

    sparseA = true;

    a = full(a);

end

if issparse(b) 

    b = full(b);

end

if ~byrow 

    % Convert to columns.

    a = a(:); 

    b = b(:); 

    % Call ISMEMBER to determine list of non-matching elements of A.

    logUA = ~(ismember(a,b)); 

    c = a(logUA); 

    % Call UNIQUE to remove duplicates from list of non-matches.

    if nargout <= 1 

        c = unique(c,order); 

    else

        [c,ndx] = unique(c,order);

        % Find indices by using logUA and NDX.

        indlogUA = find(logUA);

        ia = indlogUA(ndx);

    end 

    % If a is a row vector, return c as a row vector.

    if rowvec 

        c = c.';

    end

    % If a is sparse then c is sparse.

    if sparseA 

        c = sparse(c);

    end

else    % 'rows' case

    if ~(ismatrix(a) && ismatrix(b))

        error(message('MATLAB:SETDIFF:NotAMatrix'));

    end

    [rowsA,colsA] = size(a);

    [rowsB,colsB] = size(b);

    % Automatically pad strings with spaces

    if ischar(a) && ischar(b)

        if colsA > colsB

            b = [b repmat(' ',rowsB,colsA-colsB)];

        elseif colsA < colsB

            a = [a repmat(' ',rowsA,colsB-colsA)];

            colsA = colsB;

        end

    elseif colsA ~= colsB

        error(message('MATLAB:SETDIFF:AandBColnumAgree'));

    end

    % Handle empty arrays

    if rowsA == 0

        c = zeros(rowsA,colsA);

        ia = zeros(0,1);

    elseif colsA == 0

        c = [];

        ia = zeros(0,1);

    % General handling

    else

        % Remove duplicates from A; get indices only if needed

        if nargout > 1

            [uA,ia] = unique(a,'rows',order);

        else

            uA = unique(a,'rows',order);

        end

        % Create sorted list of unique A and B; want non-matching entries

        [sortuAB,ndx] = sortrows([uA;b]);

        [rowsC,colsC] = size(sortuAB);

        if rowsC > 1 && colsC ~= 0

            % d indicates the location of non-matching entries

            d = sortuAB(1:rowsC-1,:) ~= sortuAB(2:rowsC,:);

        else

            d = zeros(rowsC-1,0);

        end

        d = any(d,2);

        d(rowsC,1) = 1;   % Final entry always included.

        numRowsUA = size(uA,1);

        d = d & ndx <= numRowsUA; % Now find only the ones in A.

        if strcmp(order, 'stable') % 'stable'

            d = sort(ndx(d));   % Sort ndx(d) to maintain 'stable' order

            c = uA(d,:);

        else

            c = sortuAB(d,:);

        end

        % Find IA only if needed.

        if nargout > 1

            if strcmp(order, 'stable') % 'stable'

                ia = ia(d);

            else

                ia = ia(ndx(d));

            end

        end

    end

    % If a is sparse then c is sparse.

    if sparseA

        c = sparse(c);

    end

end 

end