Rik, thanks for checking.
Later on I'll come up with some doc fixes as regards char array processing by ismember - we cannot stay behind Matlab there can we.

W/o reopening (yet), hereś an excerpt from an email thread I had with TMW tech support:

<QUOTE>
                                                      It is not specifically documented that for "ismember", character matrices the trailing spaces are ignored. Also, it is not documented that the behavior for character matrices is different than for character vectors. It should be though and this is one of the things I will be discussing with our documentation team.
</QUOTE>

So we get this:

>>format compact          % skip empty lines in output
>>ismember ('a ', {'a '})  % both arguments trailing space
ans =
  logical
   1
>> ismember ('a ', {'a'})   % only first arg has trailing space
ans =
  logical
   0
>> ismember ('a ', cellstr ('a '))   % both args trailing space, in 2nd arg truncated by ‘cellstr’
ans =
  logical
   0
>> ismember (['a '; 'b '], cellstr ('a '))   % arg #1 char array with trailing spaces
ans =
  2×1 logical array
   1
   0
>> size ('a ')
ans =
     1     2
>> size (['a '; 'b '])
ans =
     2     2

TMW (IMO correctly) mentioned that char arrays are actually a legacy type; one motive for truncating trailing spaces in char arrays by ismmber() is because there's no way to distinguish genuine input spaces from spaces originating from padding the char array to get rectangular.

I cannot check Octave's behavior now (busy bisecting s/th) but I think we'd better follow Matlab in truncating trailing spaces in char arrays, no matter how inconsistent.
Or, we could add a "legacy" flag (r2016b still has it) but as you mentioned that may be a bit far out for an obscure "bug" like this
If you want I could have a shot at it, though.

I agree, I dobut you'll get much satisfaction out of TMW's tech support.  In the meantime, I committed the simplest fix which still seems to resolve this issue.  See http://hg.savannah.gnu.org/hgweb/octave/rev/21b906769c0d.  I also added two BIST tests from this bug report.  Marking as "Ready for Test".

It seems like the behavior is very complicated.  In the interest of minimizing the coding burden I would not support the 'legacy' flag and only support the most recent behavior, whatever it is.

As for cellstr and the trimming of spaces at the end, that is Matlab compatible behavior which needs to be kept.  But notice that the C++ code for cellstr uses an argument to the Cell constructor when it creates the Cell.

      string_vector s = args(0).xstring_vector_value ("cellstr: argument STRING must be a 2-D character array");

      return ovl (s.is_empty () ? Cell (octave_value (""))
                                : Cell (s, true));

The constructor for Cell has several variations.  The one in question is

  Cell (const string_vector& sv, bool trim = false);

One potential coding path would be to have a function, maybe one for internal use with '__' prefix and suffix, which calls Cell (sv, false) so that spaces are not trimmed.

Another option would be examine the code for lookup which is what ismember uses internally.  The relevant code is

  else if (str_case)
    {
      Array<std::string> str_table = table.cellstr_value ();
      Array<std::string> str_y (dim_vector (1, 1));

      if (y.is_cellstr ())
        str_y = y.cellstr_value ();
      else
        str_y(0) = y.string_value ();

      Array<octave_idx_type> idx = str_table.lookup (str_y);

Maybe cell_value rather than cellstr_value would be more appropriate for the initialization of str_table?

Or maybe the problem is with y.  In the m-file for either ismember or lookup single row char arrays could be converted to cells.  This seems to work with the examples given.

## I added { } around query to test single row char matrices being converted
ismember ({'b '}, {'a ', 'b '})
ans = 1
## multi-row char matrices are not converted, and give the same result as Matlab
abc = ['a '; 'b '; 'c ']
abc =

a
b
c

ismember (abc, {abc})
ans =

  0
  0
  0

A quick diff for that change is

diff -r 71bfd507663c scripts/set/ismember.m
--- a/scripts/set/ismember.m    Thu Jun 08 18:24:28 2017 -0700
+++ b/scripts/set/ismember.m    Fri Jun 09 09:31:32 2017 -0700
@@ -88,6 +88,10 @@ function [tf, s_idx] = ismember (a, s, v
     s = uint8 (s);
   endif

+  if (ischar (a) && rows (a) == 1 && iscell (s))
+    a = {a};
+  endif
+
   [a, s] = validsetargs ("ismember", a, s, varargin{:});

   by_rows = nargin == 3;

'test ismember' still passes which is a good thing, and the failing case also passes.

IIRC correctly (I already tried that this week) Matlab returns a single 1. In the online ML docs there's a similar example.
Later today I'll verify.

I attach a preliminary fix using a for loop (yes, ugly, but I couldn't find a vectorized way to convert a char array into a cellstr array w/o truncation trailing whitespace)

I have another case that needs attention and that I was busy trying to fix as well:

abc = ['a '; 'b '; 'c ']
ismember (abc, {abc})

Matlab (r2016b):

ans =
1
1
1

Octave, with the attached patch:

ans =
1
0
0

(file #40891)

@Guillaume, comment #5:
In the inline Matlab docs (r2017a) for ismember there's a stanza that clearly indicates that Matlab's ismember honors trailing spaces.
If your first example came from Matlab, I think you've hit a Matlab bug (what ML version did you use then?)

Your suggestion for a fix won't work as it invokes cellstr() which is at the heart of the problem - that function strips the trailing spaces.

We need a way for turning a char array into a cellstring array while preserving trailing spaces.

Status -> in progress

Using cellstr and then adding back stripped spaces doesn't seem good to me.

I don't think you can simply substitute {} for cellstr because of the difference between

x = ['foo'; 'bar']
cellstr (x)  % two element cell array
{x}          % one element cell array

BTW, trying with a simple space " " rather than "a " is sufficient

octave:36> version
ans = 4.0.3 ## installed via backports.


octave:37> a = "a "; ismember(a,{a})
ans = 0


.. on Debian 8 jessie stable.