This file is indexed.

/usr/share/openturns/validation/ValidRayleigh.txt is in openturns-validation 1.5-7build2.

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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
> restart:
> with(Statistics):
> assume(u>0,sigma>0):
> rayleigh_:=RandomVariable(Rayleigh(sigma)):
> pdf:=subs(u=x-_gamma,PDF(rayleigh_,u));
> ddf:=factor(diff(pdf,x));
> cdf:=subs(u=x-_gamma,CDF(rayleigh_,u));
> cf:=CharacteristicFunction(rayleigh_,x)*exp(I*x*_gamma);
> mu_:=_gamma+Mean(rayleigh_);
> evalf[25](mu_);
> var_:=Variance(rayleigh_);
> evalf[25](sqrt(var_));
> evalf[25](var_);
> skew_:=simplify((Skewness(rayleigh_)));
> evalf[25](skew_);
> kurt_:=simplify((Kurtosis(rayleigh_)));
> evalf[25](kurt_);
> qdf:=_gamma+Quantile(rayleigh_,p);
> pdfgr:=map(factor,[diff(pdf,sigma),diff(pdf,_gamma)]);
> cdfgr:=map(factor,[diff(cdf,sigma),diff(cdf,_gamma)]);
> valnum:=sigma=2.5,_gamma=-0.5;
> evalf(subs(valnum,x=1,ddf));
> evalf(subs(valnum,x=1,pdf));
> evalf(subs(valnum,x=1,cdf));
> evalf(subs(valnum,x=1,cf));
> evalf(subs(valnum,x=1,map(_x->_x,pdfgr)));
> evalf(subs(valnum,x=1,cdfgr));
> evalf(subs(valnum,p=0.95,qdf));
> evalf(subs(valnum,mu_));
> evalf(subs(valnum,sqrt(var_)));
> evalf(subs(valnum,skew_));
> evalf(subs(valnum,kurt_));
> evalf(subs(valnum,var_));

                                                     2
                                         (x - _gamma)
                      (x - _gamma) exp(- -------------)
                                                   2
                                           2 sigma~
               pdf := ---------------------------------
                                         2
                                   sigma~


                             2
                 (x - _gamma)
  ddf := - exp(- -------------) (-_gamma + x - sigma~)
                           2
                   2 sigma~

                                 /       4
        (-_gamma + x + sigma~)  /  sigma~
                               /


                                                2
                                    (x - _gamma)
                   cdf := 1 - exp(- -------------)
                                              2
                                      2 sigma~


        /                        /    1    \(- k/2)      k\
        |infinity GAMMA(1 + k/2) |---------|        (x I) |
        | -----                  |        2|              |
        |  \                     \2 sigma~ /              |
  cf := |   )     ----------------------------------------|
        |  /                         k!                   |
        | -----                                           |
        \ k = 0                                           /

        exp(x _gamma I)


                                          1/2   1/2
                                  sigma~ 2    Pi
                  mu_ := _gamma + -----------------
                                          2


              _gamma + 1.253314137315500251207882 sigma~


                              /     Pi \       2
                      var_ := |2 - ----| sigma~
                              \     2  /


                  0.6551363775620335530939357 sigma~


                                                   2
                  0.429203673205103380768678 sigma~


                                1/2   1/2
                             2 2    Pi    (-3 + Pi)
                  skew_ := - -----------------------
                                                 1/2
                             (-4 + Pi) (8 - 2 Pi)


                     0.6311106578189371381918970


                                             2
                                   -32 + 3 Pi
                        kurt_ := - -----------
                                            2
                                   (-4 + Pi)


                      3.245089300687638062848662


                                        2           1/2
              qdf := _gamma + (-2 sigma~  ln(1 - p))


                                           2
                               (x - _gamma)
  pdfgr := [(x - _gamma) exp(- -------------)
                                         2
                                 2 sigma~

                  2    2                      2    /       5
        (-2 sigma~  + x  - 2 x _gamma + _gamma )  /  sigma~ ,
                                                 /

                          2
              (x - _gamma)
        exp(- -------------) (-_gamma + x - sigma~)
                        2
                2 sigma~

                                 /       4
        (-_gamma + x + sigma~)  /  sigma~ ]
                               /


                                              2
                          2       (x - _gamma)
              (x - _gamma)  exp(- -------------)
                                            2
                                    2 sigma~
  cdfgr := [- ----------------------------------,
                                 3
                           sigma~

                                         2
                             (x - _gamma)
          (x - _gamma) exp(- -------------)
                                       2
                               2 sigma~
        - ---------------------------------]
                             2
                       sigma~


                valnum := sigma~ = 2.5, _gamma = -0.5


                            0.08553166965


                             0.2004648507


                             0.1647297886


                    -0.1575153039 + 0.2429216564 I


                   [-0.1315049421, -0.08553166965]


                    [-0.1202789104, -0.2004648507]


                             5.619367077


                             2.633285342


                             1.637840944


                             0.6311106598


                             3.245089294


                             2.682522956

> cf2:=proc(x, sigma, _gamma)
>   local t;
>   t := sigma * x / sqrt(2);
>   (1 - t * (2 * dawson(t) - I * exp(-t * t) * sqrt(Pi))) * exp(I *
> _gamma * x)
> end:  
> evalf(cf2(1.0, 2.5, -0.5));

                    -0.1575153040 + 0.2429216564 I

>