Diff of /inst/@dataframe/subsref.m [afaced] .. [591ef1]  Maximize  Restore

  Switch to unified view

a/inst/@dataframe/subsref.m b/inst/@dataframe/subsref.m
...
...
79
            else
79
            else
80
              %# direct access through the exact column name
80
              %# direct access through the exact column name
81
              indi = strmatch (S(1).subs, resu._name{2}, "exact");
81
              indi = strmatch (S(1).subs, resu._name{2}, "exact");
82
              if (~isempty (indi))
82
              if (~isempty (indi))
83
                resu = df._data{indi}; %# extract colum;
83
                resu = df._data{indi}; %# extract colum;
84
                if (strcmp (df._type{indi}, 'char') \
84
                if (strcmp (df._type{indi}, 'char') ...
85
                    && 1 == size (df._data{indi}, 2))
85
                    && 1 == size (df._data{indi}, 2))
86
                  resu = char (resu)
86
                  resu = char (resu)
87
                endif 
87
                endif 
88
                if (length (S) > 1)
88
                if (length (S) > 1)
89
                  dummy = S(2:end); S = S(1);
89
                  dummy = S(2:end); S = S(1);
90
                  switch dummy(1).type
90
                  switch dummy(1).type
91
                    case '()'
91
                    case '()'
92
                      if (isa (dummy(1).subs{1}, "char"))
92
                      if (isa (dummy(1).subs{1}, "char"))
93
                        [indr, nrow, dummy(1).subs{1}] = \
93
                        [indr, nrow, dummy(1).subs{1}] = ...
94
                            df_name2idx(df._name{1}, dummy(1).subs{1}, df._cnt(1), 'row');
94
                            df_name2idx(df._name{1}, dummy(1).subs{1}, df._cnt(1), 'row');
95
                      endif
95
                      endif
96
                      resu = feval(@subsref, resu, dummy);
96
                      resu = feval(@subsref, resu, dummy);
97
                    otherwise
97
                    otherwise
98
                      error ("Invalid column access");
98
                      error ("Invalid column access");
...
...
149
                if (~isempty (dummy))
149
                if (~isempty (dummy))
150
                  if (~further_deref)
150
                  if (~further_deref)
151
                    error ("Invalid sub-dereferencing");
151
                    error ("Invalid sub-dereferencing");
152
                  endif
152
                  endif
153
                  if (isa (dummy(1).subs{1}, "char"))
153
                  if (isa (dummy(1).subs{1}, "char"))
154
                    [indc, ncol, dummy(1).subs{1}] = \
154
                    [indc, ncol, dummy(1).subs{1}] = ...
155
                        df_name2idx (df._name{2}, dummy(1).subs{1}, \
155
                        df_name2idx (df._name{2}, dummy(1).subs{1}, ...
156
                                     df._cnt(2), 'column');
156
                                     df._cnt(2), 'column');
157
                    if (isempty (indc)) 
157
                    if (isempty (indc)) 
158
                      %# should be already catched  inside df_name2idx
158
                      %# should be already catched  inside df_name2idx
159
                      error ("Unknown column name: %s",  dummy(1).subs{1});
159
                      error ("Unknown column name: %s",  dummy(1).subs{1});
160
                    endif
160
                    endif
...
...
225
      endif
225
      endif
226
      if (length (S(1).subs) > 1)
226
      if (length (S(1).subs) > 1)
227
        if (isempty (S(1).subs{2}))
227
        if (isempty (S(1).subs{2}))
228
          error ('subsref: second dimension empty ???');
228
          error ('subsref: second dimension empty ???');
229
        endif
229
        endif
230
        [indr, nrow, S(1).subs{1}] = \
230
        [indr, nrow, S(1).subs{1}] = ...
231
            df_name2idx (df._name{1}, S(1).subs{1}, df._cnt(1), 'row');      
231
            df_name2idx (df._name{1}, S(1).subs{1}, df._cnt(1), 'row');      
232
        if (~isa(indr, 'char') && max (indr) > df._cnt(1))
232
        if (~isa(indr, 'char') && max (indr) > df._cnt(1))
233
          error ("Accessing dataframe past end of lines");
233
          error ("Accessing dataframe past end of lines");
234
        endif
234
        endif
235
        [indc, ncol, S(1).subs{2}] = \
235
        [indc, ncol, S(1).subs{2}] = ...
236
            df_name2idx (df._name{2}, S(1).subs{2}, df._cnt(2), 'column');
236
            df_name2idx (df._name{2}, S(1).subs{2}, df._cnt(2), 'column');
237
        if (max (indc) > df._cnt(2))
237
        if (max (indc) > df._cnt(2))
238
          %# is it a two index access of a 3D structure ?
238
          %# is it a two index access of a 3D structure ?
239
          if (length (df._cnt) > 2)
239
          if (length (df._cnt) > 2)
240
            [fullindc, fullinds] = ind2sub (df._cnt(2:3), indc);
240
            [fullindc, fullinds] = ind2sub (df._cnt(2:3), indc);
...
...
253
        switch class (S(1).subs{1})
253
        switch class (S(1).subs{1})
254
          case {'char'} %# one dimensional access, disallow it if not ':' 
254
          case {'char'} %# one dimensional access, disallow it if not ':' 
255
            if (strcmp (S(1).subs{1}, ':'))
255
            if (strcmp (S(1).subs{1}, ':'))
256
              fullindr = []; fullindc = []; asked_output_type = "array"; 
256
              fullindr = []; fullindc = []; asked_output_type = "array"; 
257
            else
257
            else
258
              error (["Accessing through single dimension and name " \
258
              error (["Accessing through single dimension and name " ...
259
                      S(1).subs{1} " not allowed\n-- use variable(:, 'name') instead"]);
259
                      S(1).subs{1} " not allowed\n-- use variable(:, 'name') instead"]);
260
            endif
260
            endif
261
          case {'logical'}
261
          case {'logical'}
262
            S(1).subs{1} = find(S(1).subs{1});
262
            S(1).subs{1} = find(S(1).subs{1});
263
          case {'dataframe'}
263
          case {'dataframe'}
...
...
274
          if (length (df._cnt) <= 2)
274
          if (length (df._cnt) <= 2)
275
            [fullindr, fullindc] = ind2sub (df._cnt, S(1).subs{1});
275
            [fullindr, fullindc] = ind2sub (df._cnt, S(1).subs{1});
276
            fullinds = ones (size (fullindr));
276
            fullinds = ones (size (fullindr));
277
          else
277
          else
278
            dummy = max (cellfun(@length, df._rep));
278
            dummy = max (cellfun(@length, df._rep));
279
            [fullindr, fullindc, fullinds] = ind2sub\
279
            [fullindr, fullindc, fullinds] = ind2sub...
280
                ([df._cnt dummy], S(1).subs{1});
280
                ([df._cnt dummy], S(1).subs{1});
281
          endif 
281
          endif 
282
          
282
          
283
          indr = unique (fullindr); nrow = length (indr);
283
          indr = unique (fullindr); nrow = length (indr);
284
          %# determine on which columns we'll iterate
284
          %# determine on which columns we'll iterate
...
...
307
    %# disp('line 211 '); keyboard
307
    %# disp('line 211 '); keyboard
308
    
308
    
309
    if (isempty (asked_output_type))
309
    if (isempty (asked_output_type))
310
      output_type = class (df); %# force df output
310
      output_type = class (df); %# force df output
311
    else
311
    else
312
      if (~strcmp (asked_output_type, "array") \
312
      if (~strcmp (asked_output_type, "array") ...
313
          || ~isempty (asked_output_format))
313
          || ~isempty (asked_output_format))
314
        %# override the class of the return value
314
        %# override the class of the return value
315
        output_type = asked_output_type;
315
        output_type = asked_output_type;
316
      else
316
      else
317
        %# can the data be merged ?
317
        %# can the data be merged ?
...
...
385
      %# export the result as a dataframe
385
      %# export the result as a dataframe
386
      resu = dataframe ();
386
      resu = dataframe ();
387
      resu._cnt(1) = nrow; resu._cnt(2) = ncol;
387
      resu._cnt(1) = nrow; resu._cnt(2) = ncol;
388
      if (isempty (fullindr))
388
      if (isempty (fullindr))
389
        for indi = (1:ncol)
389
        for indi = (1:ncol)
390
          resu._data{indi} =  df._data{indc(indi)}\
390
          resu._data{indi} =  df._data{indc(indi)}...
391
              (indr, df._rep{indc(indi)}(indt{indc(indi)})); 
391
              (indr, df._rep{indc(indi)}(indt{indc(indi)})); 
392
          resu._rep{indi} =  1:size (resu._data{indi}, 2);
392
          resu._rep{indi} =  1:size (resu._data{indi}, 2);
393
          resu._name{2}(indi, 1) = df._name{2}(indc(indi));
393
          resu._name{2}(indi, 1) = df._name{2}(indc(indi));
394
          resu._over{2}(1, indi) = df._over{2}(indc(indi));
394
          resu._over{2}(1, indi) = df._over{2}(indc(indi));
395
          resu._type{indi} = df._type{indc(indi)};
395
          resu._type{indi} = df._type{indc(indi)};
...
...
408
          indc = unique (fullindc(:, indi));
408
          indc = unique (fullindc(:, indi));
409
          if (1 == length (indc))
409
          if (1 == length (indc))
410
            resu._name{2}(indi)= df._name{2}(indc);
410
            resu._name{2}(indi)= df._name{2}(indc);
411
            resu._over{2}(indi)= df._over{2}(indc);
411
            resu._over{2}(indi)= df._over{2}(indc);
412
            unfolded = df._data{indc}(:, df._rep{indc});
412
            unfolded = df._data{indc}(:, df._rep{indc});
413
            indj =  sub2ind (size (unfolded), fullindr(:, indi), \
413
            indj =  sub2ind (size (unfolded), fullindr(:, indi), ...
414
                            fullinds(:, indi));
414
                            fullinds(:, indi));
415
            resu._data{indi} = unfolded(indj);
415
            resu._data{indi} = unfolded(indj);
416
            resu._type{indi} = df._type{indc};
416
            resu._type{indi} = df._type{indc};
417
            resu._rep{indi} = 1:size (resu._data{indi}, 2);  
417
            resu._rep{indi} = 1:size (resu._data{indi}, 2);  
418
          else
418
          else
...
...
471
            %# dummy = cellstr(df._data{indc(indi)}(indr, :));
471
            %# dummy = cellstr(df._data{indc(indi)}(indr, :));
472
            dummy = df._data{indc(indi)}(indr, :);
472
            dummy = df._data{indc(indi)}(indr, :);
473
            resu(1+row_offs:end, indi+col_offs) = dummy;
473
            resu(1+row_offs:end, indi+col_offs) = dummy;
474
          otherwise
474
          otherwise
475
            dummy = df._data{indc(indi)}(indr, :);
475
            dummy = df._data{indc(indi)}(indr, :);
476
            resu(1+row_offs:end, indi+col_offs) = \
476
            resu(1+row_offs:end, indi+col_offs) = ...
477
                mat2cell (dummy, ones (nrow, 1), size (dummy, 2));
477
                mat2cell (dummy, ones (nrow, 1), size (dummy, 2));
478
        endswitch
478
        endswitch
479
      endfor
479
      endfor
480
480
481
      %# did we arrive here by x.cell ?
481
      %# did we arrive here by x.cell ?
...
...
494
            %# zone containing the data
494
            %# zone containing the data
495
            dummy = S;
495
            dummy = S;
496
            if (~isempty (dummy(2).subs))
496
            if (~isempty (dummy(2).subs))
497
              dummy(2).subs{2} = ':';
497
              dummy(2).subs{2} = ':';
498
            endif
498
            endif
499
            resuf = cat (2, \
499
            resuf = cat (2, ...
500
                         %# reselect indexes
500
                         %# reselect indexes
501
                         feval (@subsref, resu(3:end, 1),
501
                         feval (@subsref, resu(3:end, 1),
502
                                dummy(2:end)), \
502
                                dummy(2:end)), ...
503
                         %# reselect rownames
503
                         %# reselect rownames
504
                         feval (@subsref, resu(3:end, 2),
504
                         feval (@subsref, resu(3:end, 2),
505
                                dummy(2:end)), \
505
                                dummy(2:end)), ...
506
                         %# extract - reorder - whatever
506
                         %# extract - reorder - whatever
507
                         feval (@subsref, resu(3:end, 3:end), S(2:end))
507
                         feval (@subsref, resu(3:end, 3:end), S(2:end))
508
                         \
508
                         ...
509
                         );
509
                         );
510
            dummy = S;
510
            dummy = S;
511
            if (~isempty (dummy(2).subs))
511
            if (~isempty (dummy(2).subs))
512
              dummy(2).subs{1} =  [1 2];
512
              dummy(2).subs{1} =  [1 2];
513
            endif
513
            endif
514
            resuf =  cat(1, \
514
            resuf =  cat(1, ...
515
                         %# reselect column names and types
515
                         %# reselect column names and types
516
                         [cell(2, 2) feval(@subsref, resu(1:2,
516
                         [cell(2, 2) feval(@subsref, resu(1:2,
517
                                                          3:end), \
517
                                                          3:end), ...
518
                                           dummy(2:end))], \
518
                                           dummy(2:end))], ...
519
                         resuf \
519
                         resuf ...
520
                         );
520
                         );
521
            resuf(1:2, 1:2) = {''}; resu = resuf;
521
            resuf(1:2, 1:2) = {''}; resu = resuf;
522
          else
522
          else
523
            %# one dimensionnal access of the whole 2D cell array -- you
523
            %# one dimensionnal access of the whole 2D cell array -- you
524
            %# asked it, you got it
524
            %# asked it, you got it
525
            resu = feval (@subsref, resu(:), S(2:end));
525
            resu = feval (@subsref, resu(:), S(2:end));
526
            if (~isa (S(2).subs{1}, 'char') \
526
            if (~isa (S(2).subs{1}, 'char') ...
527
                  && size (S(2).subs{1}, 2) > 1)
527
                  && size (S(2).subs{1}, 2) > 1)
528
              resu = resu.';
528
              resu = resu.';
529
            endif
529
            endif
530
          endif
530
          endif
531
        endif
531
        endif
532
      elseif (1 == length (S(1).subs))
532
      elseif (1 == length (S(1).subs))
533
        resu = resu(:);
533
        resu = resu(:);
534
        if (~isa(S(1).subs{1}, 'char') \
534
        if (~isa(S(1).subs{1}, 'char') ...
535
              && size (S(1).subs{1}, 2) > 1)
535
              && size (S(1).subs{1}, 2) > 1)
536
          resu = resu.';
536
          resu = resu.';
537
        endif
537
        endif
538
      endif
538
      endif
539
      return; %# no more iteration required
539
      return; %# no more iteration required
...
...
544
      %# * x(:, n:m, :) returns a 3D matrix 
544
      %# * x(:, n:m, :) returns a 3D matrix 
545
      %# * x(:, :) returns a horzcat of the third dimension 
545
      %# * x(:, :) returns a horzcat of the third dimension 
546
      %# * x(:, n:m) select only the first sequence 
546
      %# * x(:, n:m) select only the first sequence 
547
      %# * x(:) returns a vertcat of the columns of x(:, :)
547
      %# * x(:) returns a vertcat of the columns of x(:, :)
548
      %# disp('line 403 '); keyboard
548
      %# disp('line 403 '); keyboard
549
      if (isempty (S) || isempty (S(1).subs) || \
549
      if (isempty (S) || isempty (S(1).subs) || ...
550
          length (S(1).subs) > 1 || \
550
          length (S(1).subs) > 1 || ...
551
          (isnumeric (S(1).subs{1}) && ~isvector(S(1).subs{1}))) 
551
          (isnumeric (S(1).subs{1}) && ~isvector(S(1).subs{1}))) 
552
        %# access-as-matrix
552
        %# access-as-matrix
553
    if (isempty (df))
553
    if (isempty (df))
554
       resu = [];
554
       resu = [];
555
    else
555
    else
556
          df = struct (df);        %# remove the magic, avoid recursive calls 
556
          df = struct (df);        %# remove the magic, avoid recursive calls 
557
          if (isempty (fullindr)) %# two index access
557
          if (isempty (fullindr)) %# two index access
558
            if (~isempty (asked_output_format)) %# force a conversion
558
            if (~isempty (asked_output_format)) %# force a conversion
559
              if (strmatch (asked_output_format, 'cell'))
559
              if (strmatch (asked_output_format, 'cell'))
560
        extractfunc = @(x) mat2cell\
560
        extractfunc = @(x) mat2cell...
561
                   (df._data{indc(x)}(indr, df._rep{indc(x)}(inds)), \
561
                   (df._data{indc(x)}(indr, df._rep{indc(x)}(inds)), ...
562
                ones (nrow, 1));
562
                ones (nrow, 1));
563
              else
563
              else
564
        extractfunc = @(x) cast ( df._data{indc(x)}\
564
        extractfunc = @(x) cast ( df._data{indc(x)}...
565
                          (indr, df._rep{indc(x)}(inds)),\
565
                          (indr, df._rep{indc(x)}(inds)),...
566
                      asked_output_format);
566
                      asked_output_format);
567
              endif
567
              endif
568
            else %# let the usual downclassing occur
568
            else %# let the usual downclassing occur
569
              extractfunc = @(x) df._data{indc(x)}(indr, df._rep{indc(x)}(inds));
569
              extractfunc = @(x) df._data{indc(x)}(indr, df._rep{indc(x)}(inds));
570
            endif 
570
            endif 
...
...
576
        endif
576
        endif
577
              else
577
              else
578
        dummy = extractfunc (1);
578
        dummy = extractfunc (1);
579
              endif
579
              endif
580
            catch
580
            catch
581
          error ("Column %d format (%s) can't be converted to %s", \
581
          error ("Column %d format (%s) can't be converted to %s", ...
582
                     indc(1), df._type{indc(1)}, asked_output_format);
582
                     indc(1), df._type{indc(1)}, asked_output_format);
583
            end_try_catch
583
            end_try_catch
584
            if (ncol > 1)
584
            if (ncol > 1)
585
              %# dynamic allocation with the final type
585
              %# dynamic allocation with the final type
586
              resu = repmat (dummy, [1 ncol]);
586
              resu = repmat (dummy, [1 ncol]);
...
...
593
                    endif
593
                    endif
594
                  else
594
                  else
595
                    dummy = extractfunc (indi);
595
                    dummy = extractfunc (indi);
596
                  endif
596
                  endif
597
        catch
597
        catch
598
                  error ("Column %d format (%s) can't be converted to %s", \
598
                  error ("Column %d format (%s) can't be converted to %s", ...
599
             indc(indi), df._type{indc(indi)}, asked_output_format);
599
             indc(indi), df._type{indc(indi)}, asked_output_format);
600
        end_try_catch
600
        end_try_catch
601
        resu(:, indi, :) = dummy;
601
        resu(:, indi, :) = dummy;
602
              endfor
602
              endfor
603
            else
603
            else
...
...
605
        resu = char (dummy);
605
        resu = char (dummy);
606
              else
606
              else
607
        resu = dummy;
607
        resu = dummy;
608
              endif
608
              endif
609
            endif
609
            endif
610
            if (~isempty (S) && 2 == length (S(1).subs) \
610
            if (~isempty (S) && 2 == length (S(1).subs) ...
611
        && all (cellfun ('isclass', S(1).subs, 'char')))
611
        && all (cellfun ('isclass', S(1).subs, 'char')))
612
              resu = reshape (resu, nrow, ncol*nseq);
612
              resu = reshape (resu, nrow, ncol*nseq);
613
            endif
613
            endif
614
      else %# one index access
614
      else %# one index access
615
            %# disp('line 557'); keyboard
615
            %# disp('line 557'); keyboard
616
            if (~isempty (asked_output_format)) %# force a conversion
616
            if (~isempty (asked_output_format)) %# force a conversion
617
              if (strmatch (asked_output_format, 'cell'))
617
              if (strmatch (asked_output_format, 'cell'))
618
        extractfunc = @(x, y) mat2cell (df._data{x}(:, df._rep{x}(y)), \
618
        extractfunc = @(x, y) mat2cell (df._data{x}(:, df._rep{x}(y)), ...
619
                        ones (length (y), 1));
619
                        ones (length (y), 1));
620
              else
620
              else
621
        extractfunc = @(x, y) cast (df._data{x}(:, df._rep{x})(y), \
621
        extractfunc = @(x, y) cast (df._data{x}(:, df._rep{x})(y), ...
622
                                            asked_output_format);      
622
                                            asked_output_format);      
623
              endif
623
              endif
624
            else %# let the usual downclassing occur
624
            else %# let the usual downclassing occur
625
              extractfunc = @(x, y) df._data{x}(:, df._rep{x})(y);
625
              extractfunc = @(x, y) df._data{x}(:, df._rep{x})(y);
626
            endif
626
            endif
627
            try
627
            try
628
              resu = zeros(0, class (sum (cellfun (@(x) zeros (1, class (x(1))),\
628
              resu = zeros(0, class (sum (cellfun (@(x) zeros (1, class (x(1))),...
629
                                                   df._data(indc)))));
629
                                                   df._data(indc)))));
630
              for indi = (indc)
630
              for indi = (indc)
631
        dummy = find (indi == fullindc);   %# linear global index
631
        dummy = find (indi == fullindc);   %# linear global index
632
        %# linear index for this matrix
632
        %# linear index for this matrix
633
        idx = sub2ind (size (df._data{indi}), fullindr(dummy), \
633
        idx = sub2ind (size (df._data{indi}), fullindr(dummy), ...
634
                               fullinds(dummy));
634
                               fullinds(dummy));
635
        resu(dummy) = extractfunc (indi, idx);
635
        resu(dummy) = extractfunc (indi, idx);
636
              endfor
636
              endfor
637
            catch
637
            catch
638
              disp (lasterr); 
638
              disp (lasterr); 
639
              error ("Column %d format (%s) can't be converted to %s", \
639
              error ("Column %d format (%s) can't be converted to %s", ...
640
                     indi, df._type{indi}, asked_output_format);
640
                     indi, df._type{indi}, asked_output_format);
641
            end_try_catch
641
            end_try_catch
642
            resu = reshape (resu, size (onedimidx));
642
            resu = reshape (resu, size (onedimidx));
643
          endif
643
          endif
644
    endif
644
    endif
645
      else %# access-as-vector
645
      else %# access-as-vector
646
        %# disp('line 548 '); keyboard
646
        %# disp('line 548 '); keyboard
647
        if (~isempty (fullindr))
647
        if (~isempty (fullindr))
648
          switch df._type{indc(1)}
648
          switch df._type{indc(1)}
649
            case {'char'}
649
            case {'char'}
650
              resu = df._data{indc(1)}(fullindr(1), \
650
              resu = df._data{indc(1)}(fullindr(1), ...
651
                                       df._rep{indc(1)}(fullinds(1)));
651
                                       df._rep{indc(1)}(fullinds(1)));
652
              for indi = (2:length (fullindr))
652
              for indi = (2:length (fullindr))
653
                resu = char (resu, df._data{indc(indi)}\
653
                resu = char (resu, df._data{indc(indi)}...
654
                             (fullindr(indi), df._rep{indc(indi)}(fullinds(indi))));
654
                             (fullindr(indi), df._rep{indc(indi)}(fullinds(indi))));
655
              endfor
655
              endfor
656
            otherwise
656
            otherwise
657
              if (isempty (asked_output_format))
657
              if (isempty (asked_output_format))
658
                resu = df._data{fullindc(1)}\
658
                resu = df._data{fullindc(1)}...
659
                    (fullindr(1), df._rep{fullindc(1)}(fullinds(1)));
659
                    (fullindr(1), df._rep{fullindc(1)}(fullinds(1)));
660
              else      %# this type will propagate with subsequent cat
660
              else      %# this type will propagate with subsequent cat
661
                resu = cast (df._data{fullindc(1)}\
661
                resu = cast (df._data{fullindc(1)}...
662
                             (fullindr(1), df._rep{fullindc(1)}(fullinds(1))),\
662
                             (fullindr(1), df._rep{fullindc(1)}(fullinds(1))),...
663
                             asked_output_format);
663
                             asked_output_format);
664
              endif
664
              endif
665
              for indi = (2:length (fullindr))
665
              for indi = (2:length (fullindr))
666
                resu = cat(1, resu, df._data{fullindc(indi)}\
666
                resu = cat(1, resu, df._data{fullindc(indi)}...
667
                           (fullindr(indi), \
667
                           (fullindr(indi), ...
668
                            df._rep{fullindc(indi)}(fullinds(indi))));
668
                            df._rep{fullindc(indi)}(fullinds(indi))));
669
              endfor
669
              endfor
670
          endswitch
670
          endswitch
671
        else %# using the (:) operator
671
        else %# using the (:) operator
672
          resu = df_whole(df)(:);
672
          resu = df_whole(df)(:);
673
        endif
673
        endif
674
        if (~isa (S(1).subs{1}, 'char') \
674
        if (~isa (S(1).subs{1}, 'char') ...
675
              && size (S(1).subs{1}, 2) > 1)
675
              && size (S(1).subs{1}, 2) > 1)
676
          resu = resu.';
676
          resu = resu.';
677
        endif
677
        endif
678
      endif
678
      endif
679
      if (length (S) > 1) %# perform further access, if required
679
      if (length (S) > 1) %# perform further access, if required

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:





No, thanks