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 = cat(1, zeros(rowsA,colsA), a(1:0,1:0));

        ia = zeros(0,1);

    elseif colsA == 0

        c = cat(1, [], a(1:0,1:0));

        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

        if needsCastingCheck(a, b)

            % Set the output to be the unique entries of the input.

            c = uA;

            % Find all rows of b that are elements of the unique rows of A.

            [~,locuA] = ismember(b, uA, 'rows');

            % Take the unique set of indices of rows of uA that were found

            % within b.

            rmidx = unique(locuA(locuA ~= 0));

            % Remove these rows from c and, if requested, ia.

            c(rmidx,:) = [];

            if nargout > 1

                ia(rmidx,:) = [];

            end

        else

            % 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

    end

    % If a is sparse then c is sparse.

    if sparseA

        c = sparse(c);

    end

end 

end