This file is indexed.

/usr/share/octave/packages/nurbs-1.3.10/kntbrkdegmult.m is in octave-nurbs 1.3.10-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
% KNTBRKDEGMULT: Construct an open knot vector by giving the sequence of
%                knots, the degree and the multiplicity.
%
%   knots = kntbrkdegreg (breaks, degree)
%   knots = kntbrkdegreg (breaks, degree, mult)
%
% INPUT:
%
%     breaks:  sequence of knots.
%     degree:  polynomial degree of the splines associated to the knot vector.
%     mult:    multiplicity of the knots.
%
% OUTPUT:
%
%     knots:  knot vector.
%
% If MULT has as many entries as BREAKS, or as the number of interior
%   knots, a different multiplicity will be assigned to each knot. If
%   MULT is not present, it will be taken equal to 1.
%
% Copyright (C) 2010 Carlo de Falco, Rafael Vazquez
%
%    This program is free software: you can redistribute it and/or modify
%    it under the terms of the GNU General Public License as published by
%    the Free Software Foundation, either version 3 of the License, or
%    (at your option) any later version.

%    This program is distributed in the hope that it will be useful,
%    but WITHOUT ANY WARRANTY; without even the implied warranty of
%    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%    GNU General Public License for more details.
%
%    You should have received a copy of the GNU General Public License
%    along with this program.  If not, see <http://www.gnu.org/licenses/>.

function knots = kntbrkdegmult (breaks, degree, mult)

  if (iscell (breaks))
    if (nargin == 2)
      mult = 1;
    end
  
    if (numel(breaks)~=numel(degree) || numel(breaks)~=numel(mult))
      error('kntbrkdegmult: degree and multiplicity must have the same length as the number of knot vectors')
    end

    degree = num2cell (degree);

    if (~iscell (mult))
      mult = num2cell (mult);
    end

    knots = cellfun (@do_kntbrkdegmult, breaks, degree, mult, 'uniformoutput', false);

  else

    if (nargin == 2)
      mult = 1;
    end

    knots = do_kntbrkdegmult (breaks, degree, mult);
  end
end

  
function knots = do_kntbrkdegmult (breaks, degree, mult)  

if (numel (breaks) < 2)
  error ('kntbrkdegmult: the knots sequence should contain at least two points')
end

if (numel (mult) == 1)
  mults = [degree+1, mult(ones (1, numel (breaks) - 2)), degree+1];
elseif (numel (mult) == numel (breaks))
  mults = [degree+1 mult(2:end-1) degree+1];
elseif (numel (mult) == numel (breaks) - 2)
  mults = [degree+1 mult degree+1];
else
  error('kntbrkdegmult: the length of mult should be equal to one or the number of knots')
end

if (any (mults > degree+1))
  warning ('kntbrkdegmult: some knots have higher multiplicity than the degree+1')
end

breaks = sort (breaks);

lm = numel (mults);
sm = sum (mults);

mm = zeros (1,sm);
mm (cumsum ([1 reshape(mults (1:end-1), 1, lm-1)])) = ones (1,lm);
knots = breaks (cumsum (mm));

end

%!test
%! breaks = [0 1 2 3 4];
%! degree = 3;
%! knots = kntbrkdegmult (breaks, degree);
%! assert (knots, [0 0 0 0 1 2 3 4 4 4 4])

%!test
%! breaks = [0 1 2 3 4];
%! degree = 3;
%! mult   = 2;
%! knots = kntbrkdegmult (breaks, degree, mult);
%! assert (knots, [0 0 0 0 1 1 2 2 3 3 4 4 4 4])

%!test
%! breaks = [0 1 2 3 4];
%! degree = 3;
%! mult   = [1 2 3];
%! knots = kntbrkdegmult (breaks, degree, mult);
%! assert (knots, [0 0 0 0 1 2 2 3 3 3 4 4 4 4])

%!test
%! breaks = {[0 1 2 3 4] [0 1 2 3]};
%! degree = [3 2];
%! mult   = {[1 2 3] 2};
%! knots = kntbrkdegmult (breaks, degree, mult);
%! assert (knots, {[0 0 0 0 1 2 2 3 3 3 4 4 4 4] [0 0 0 1 1 2 2 3 3 3]})