Mercurial > repos > marpiech > norwich_tools_docking
comparison tools/rdock/data/pmf/smoothed/smoother.m @ 3:b02d74d22d05 draft default tip
planemo upload
| author | marpiech |
|---|---|
| date | Mon, 29 Aug 2016 08:23:52 -0400 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| 2:bd50f811878f | 3:b02d74d22d05 |
|---|---|
| 1 ## natural-cubic-spline interpolation | |
| 2 ## usage: yspline = spline(x,y,xspline) | |
| 3 ## example: | |
| 4 ## x = 0:10; y = sin(x); | |
| 5 ## xspline = 0:0.1:10; yspline = spline(x,y,xspline); | |
| 6 ## ##plot(x,y,"+",xspline,yspline); | |
| 7 ## Given the vectors x and y, which tabulate a function, with | |
| 8 ## x(1) < x(2) < x(3) <... or x(1) > x(2) > x(3) >..., and given | |
| 9 ## the vector xspline, this function returns a natural-cubic-spline | |
| 10 ## interpolated vector yspline. | |
| 11 ## author: Zdenek Remes, May 22, 1999 | |
| 12 | |
| 13 | |
| 14 function ynew = spline(x,y,xnew) | |
| 15 [x,index]=sort(x); | |
| 16 y=y(index); | |
| 17 n=length(y); | |
| 18 y2(1)=0.0; | |
| 19 y2(n)=0.0; | |
| 20 u(1)=0.0; | |
| 21 for i=2:n-1 | |
| 22 sig=(x(i)-x(i-1))/(x(i+1)-x(i-1)); | |
| 23 p=sig*y2(i-1)+2.0; | |
| 24 y2(i)=(sig-1.0)/p; | |
| 25 u(i)=(y(i+1)-y(i))/(x(i+1)-x(i))-(y(i)-y(i-1))/(x(i)-x(i-1)); | |
| 26 u(i)=(6.0*u(i)/(x(i+1)-x(i-1))-sig*u(i-1))/p; | |
| 27 endfor; | |
| 28 k=n-1; | |
| 29 while (k >= 1) | |
| 30 y2(k)=y2(k)*y2(k+1)+u(k); | |
| 31 k--; | |
| 32 endwhile; | |
| 33 | |
| 34 i1=1; in=length(xnew); | |
| 35 | |
| 36 #if (xnew(1) < x(1)) | |
| 37 # error("spline: bad xspline"); | |
| 38 #endif; | |
| 39 #if (xnew(in) > x(n)) | |
| 40 # error("spline: bad xspline"); | |
| 41 #endif; | |
| 42 | |
| 43 if (xnew(1) == x(1)) | |
| 44 ynew(1)=y(1); | |
| 45 i1=2; | |
| 46 endif; | |
| 47 if (xnew(in) == x(n)) | |
| 48 ynew(in)=y(n); | |
| 49 in=in-1; | |
| 50 endif; | |
| 51 | |
| 52 | |
| 53 for i=i1:in | |
| 54 khi=n; | |
| 55 klo=1; | |
| 56 while ((khi-klo) > 1) | |
| 57 k=floor((khi+klo)/2); | |
| 58 if (x(k) > xnew(i)) | |
| 59 khi=k; | |
| 60 else | |
| 61 klo=k; | |
| 62 endif; | |
| 63 endwhile; | |
| 64 h=x(khi)-x(klo); | |
| 65 a=(x(khi)-xnew(i))/h; | |
| 66 b=(xnew(i)-x(klo))/h; | |
| 67 ynew(i)=a*y(klo)+b*y(khi)+((a^3-a)*y2(klo)+(b^3-b)*y2(khi))*(h*h)/6.0; | |
| 68 endfor; | |
| 69 endfunction; | |
| 70 | |
| 71 ## Savitzky-Golay smoothing filter | |
| 72 ## usage: [xsavgol,ysavgol]=savgol(x,y,nl,nr,m) | |
| 73 ## example: x=0:0.01:3;y1=sin(x.^3);y=y1+(rand(1,301)-0.5)/3; | |
| 74 ## [xsavgol,ysavgol]=savgol(x,y,10,10,2); | |
| 75 ## ##plot(x,y,"+",xsavgol,ysavgol,x,y1) | |
| 76 ## Given vectors x, y containing a tabulated data y=f(x) with | |
| 77 ## equally spaced x's this function calculates smoothed data | |
| 78 ## ysavgol=g(xsavgol) by Savitzky-Golay smoothing filter. | |
| 79 ## nl is the number of leftward (past) data points used, while | |
| 80 ## nr is the number of rightward (future) data points, making | |
| 81 ## the total number of data points used nl+nr+1. m is the order | |
| 82 ## of the smoothing polynomial, also equal to the highest | |
| 83 ## conserved moment; usual values are m=2 or m=4. | |
| 84 ## The idea of Savitzky-Golay filtering is to smooth the | |
| 85 ## underlying data y=f(x) within the moving window not by a | |
| 86 ## constant (whose estimate is the average), but by a poly- | |
| 87 ## nomial of higher order. Thus for a point y(i) the function | |
| 88 ## savgol fits by a least-squares method a polynomial to | |
| 89 ## points y(i-nl), ..., y(i+nr) in the moving window, and | |
| 90 ## then set g(i-nl+1) to the value of that polynomial at | |
| 91 ## position x(i). | |
| 92 ## Zdenek Remes, Mai 22, 1999 | |
| 93 | |
| 94 function [xnew,ynew]=savgol(x,y,nl, nr, M) | |
| 95 | |
| 96 if max(diff(x,2))>100*eps | |
| 97 error("The x's must be equally spaced.") | |
| 98 endif | |
| 99 for i=-nl:nr | |
| 100 for j=0:M | |
| 101 A(i+nl+1,j+1)=i^j; | |
| 102 endfor | |
| 103 endfor | |
| 104 AA=inv(A'*A); | |
| 105 for i=-nl:nr | |
| 106 cc=0; | |
| 107 for m=0:M | |
| 108 cc=cc+AA(1,m+1)*i^m; | |
| 109 endfor | |
| 110 c(i+nl+1)=cc; | |
| 111 endfor | |
| 112 | |
| 113 nx=length(x); | |
| 114 for i=nl:nx-nr-1 | |
| 115 yy=0; | |
| 116 for j=-nl:nr | |
| 117 yy=yy+c(j+nl+1)*y(i+j+1); | |
| 118 endfor | |
| 119 xnew(i-nl+1)=x(i+1); | |
| 120 ynew(i-nl+1)=yy; | |
| 121 endfor | |
| 122 endfunction | |
| 123 | |
| 124 ## x=0:0.01:3; | |
| 125 ## y1=sin(x.^3); | |
| 126 ## y=y1+(rand(1,301)-0.5)/3; | |
| 127 ## [xsavgol,ysavgol]=savgol(x,y,10,10,2); | |
| 128 ## plot(x,y,"+",xsavgol,ysavgol,x,y1); | |
| 129 ## pause; | |
| 130 zero=[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ]; | |
| 131 ##load -force CPNA.dat; | |
| 132 ##[xs,ys]=savgol(x,y,5,5,4); | |
| 133 ##save -ascii CPNA.sm xs ys; | |
| 134 | |
| 135 load -force CFBr.dat; | |
| 136 [xs,ys]=savgol(x,y,5,5,4); | |
| 137 save -ascii CFBr.sm xs ys; | |
| 138 printf("CFBr.sm\n"); | |
| 139 load -force CFC0.dat; | |
| 140 [xs,ys]=savgol(x,y,5,5,4); | |
| 141 save -ascii CFC0.sm xs ys; | |
| 142 printf("CFC0.sm\n"); | |
| 143 load -force CFC3.dat; | |
| 144 [xs,ys]=savgol(x,y,5,5,4); | |
| 145 save -ascii CFC3.sm xs ys; | |
| 146 printf("CFC3.sm\n"); | |
| 147 load -force CFCF.dat; | |
| 148 [xs,ys]=savgol(x,y,5,5,4); | |
| 149 save -ascii CFCF.sm xs ys; | |
| 150 printf("CFCF.sm\n"); | |
| 151 load -force CFCL.dat; | |
| 152 [xs,ys]=savgol(x,y,5,5,4); | |
| 153 save -ascii CFCL.sm xs ys; | |
| 154 printf("CFCL.sm\n"); | |
| 155 load -force CFCN.dat; | |
| 156 [xs,ys]=savgol(x,y,5,5,4); | |
| 157 save -ascii CFCN.sm xs ys; | |
| 158 printf("CFCN.sm\n"); | |
| 159 load -force CFCO.dat; | |
| 160 [xs,ys]=savgol(x,y,5,5,4); | |
| 161 save -ascii CFCO.sm xs ys; | |
| 162 printf("CFCO.sm\n"); | |
| 163 load -force CFCP.dat; | |
| 164 [xs,ys]=savgol(x,y,5,5,4); | |
| 165 save -ascii CFCP.sm xs ys; | |
| 166 printf("CFCP.sm\n"); | |
| 167 load -force CFCW.dat; | |
| 168 [xs,ys]=savgol(x,y,5,5,4); | |
| 169 save -ascii CFCW.sm xs ys; | |
| 170 printf("CFCW.sm\n"); | |
| 171 load -force CFF_.dat; | |
| 172 [xs,ys]=savgol(x,y,5,5,4); | |
| 173 save -ascii CFF_.sm xs ys; | |
| 174 printf("CFF_.sm\n"); | |
| 175 load -force CFFe.dat; | |
| 176 [xs,ys]=savgol(x,y,5,5,4); | |
| 177 save -ascii CFFe.sm xs ys; | |
| 178 printf("CFFe.sm\n"); | |
| 179 load -force CFHL.dat; | |
| 180 [xs,ys]=savgol(x,y,5,5,4); | |
| 181 save -ascii CFHL.sm xs ys; | |
| 182 printf("CFHL.sm\n"); | |
| 183 load -force CFMg.dat; | |
| 184 [xs,ys]=savgol(x,y,5,5,4); | |
| 185 save -ascii CFMg.sm xs ys; | |
| 186 printf("CFMg.sm\n"); | |
| 187 load -force CFMn.dat; | |
| 188 [xs,ys]=savgol(x,y,5,5,4); | |
| 189 save -ascii CFMn.sm xs ys; | |
| 190 printf("CFMn.sm\n"); | |
| 191 load -force CFN0.dat; | |
| 192 [xs,ys]=savgol(x,y,5,5,4); | |
| 193 save -ascii CFN0.sm xs ys; | |
| 194 printf("CFN0.sm\n"); | |
| 195 load -force CFNA.dat; | |
| 196 [xs,ys]=savgol(x,y,5,5,4); | |
| 197 save -ascii CFNA.sm xs ys; | |
| 198 printf("CFNA.sm\n"); | |
| 199 load -force CFNC.dat; | |
| 200 [xs,ys]=savgol(x,y,5,5,4); | |
| 201 save -ascii CFNC.sm xs ys; | |
| 202 printf("CFNC.sm\n"); | |
| 203 load -force CFND.dat; | |
| 204 [xs,ys]=savgol(x,y,5,5,4); | |
| 205 save -ascii CFND.sm xs ys; | |
| 206 printf("CFND.sm\n"); | |
| 207 load -force CFNP.dat; | |
| 208 [xs,ys]=savgol(x,y,5,5,4); | |
| 209 save -ascii CFNP.sm xs ys; | |
| 210 printf("CFNP.sm\n"); | |
| 211 load -force CFNR.dat; | |
| 212 [xs,ys]=savgol(x,y,5,5,4); | |
| 213 save -ascii CFNR.sm xs ys; | |
| 214 printf("CFNR.sm\n"); | |
| 215 load -force CFNS.dat; | |
| 216 [xs,ys]=savgol(x,y,5,5,4); | |
| 217 save -ascii CFNS.sm xs ys; | |
| 218 printf("CFNS.sm\n"); | |
| 219 load -force CFOA.dat; | |
| 220 [xs,ys]=savgol(x,y,5,5,4); | |
| 221 save -ascii CFOA.sm xs ys; | |
| 222 printf("CFOA.sm\n"); | |
| 223 load -force CFOC.dat; | |
| 224 [xs,ys]=savgol(x,y,5,5,4); | |
| 225 save -ascii CFOC.sm xs ys; | |
| 226 printf("CFOC.sm\n"); | |
| 227 load -force CFOD.dat; | |
| 228 [xs,ys]=savgol(x,y,5,5,4); | |
| 229 save -ascii CFOD.sm xs ys; | |
| 230 printf("CFOD.sm\n"); | |
| 231 load -force CFOE.dat; | |
| 232 [xs,ys]=savgol(x,y,5,5,4); | |
| 233 save -ascii CFOE.sm xs ys; | |
| 234 printf("CFOE.sm\n"); | |
| 235 load -force CFOR.dat; | |
| 236 [xs,ys]=savgol(x,y,5,5,4); | |
| 237 save -ascii CFOR.sm xs ys; | |
| 238 printf("CFOR.sm\n"); | |
| 239 load -force CFOS.dat; | |
| 240 [xs,ys]=savgol(x,y,5,5,4); | |
| 241 save -ascii CFOS.sm xs ys; | |
| 242 printf("CFOS.sm\n"); | |
| 243 load -force CFP_.dat; | |
| 244 [xs,ys]=savgol(x,y,5,5,4); | |
| 245 save -ascii CFP_.sm xs ys; | |
| 246 printf("CFP_.sm\n"); | |
| 247 load -force CFSA.dat; | |
| 248 [xs,ys]=savgol(x,y,5,5,4); | |
| 249 save -ascii CFSA.sm xs ys; | |
| 250 printf("CFSA.sm\n"); | |
| 251 load -force CFSD.dat; | |
| 252 [xs,ys]=savgol(x,y,5,5,4); | |
| 253 save -ascii CFSD.sm xs ys; | |
| 254 printf("CFSD.sm\n"); | |
| 255 load -force CFV_.dat; | |
| 256 [xs,ys]=savgol(x,y,5,5,4); | |
| 257 save -ascii CFV_.sm xs ys; | |
| 258 printf("CFV_.sm\n"); | |
| 259 load -force CFZn.dat; | |
| 260 [xs,ys]=savgol(x,y,5,5,4); | |
| 261 save -ascii CFZn.sm xs ys; | |
| 262 printf("CFZn.sm\n"); | |
| 263 load -force CFcF.dat; | |
| 264 [xs,ys]=savgol(x,y,5,5,4); | |
| 265 save -ascii CFcF.sm xs ys; | |
| 266 printf("CFcF.sm\n"); | |
| 267 load -force CFcP.dat; | |
| 268 [xs,ys]=savgol(x,y,5,5,4); | |
| 269 save -ascii CFcP.sm xs ys; | |
| 270 printf("CFcP.sm\n"); | |
| 271 load -force CNBr.dat; | |
| 272 [xs,ys]=savgol(x,y,5,5,4); | |
| 273 save -ascii CNBr.sm xs ys; | |
| 274 printf("CNBr.sm\n"); | |
| 275 load -force CNC0.dat; | |
| 276 [xs,ys]=savgol(x,y,5,5,4); | |
| 277 save -ascii CNC0.sm xs ys; | |
| 278 printf("CNC0.sm\n"); | |
| 279 load -force CNC3.dat; | |
| 280 [xs,ys]=savgol(x,y,5,5,4); | |
| 281 save -ascii CNC3.sm xs ys; | |
| 282 printf("CNC3.sm\n"); | |
| 283 load -force CNCF.dat; | |
| 284 [xs,ys]=savgol(x,y,5,5,4); | |
| 285 save -ascii CNCF.sm xs ys; | |
| 286 printf("CNCF.sm\n"); | |
| 287 load -force CNCL.dat; | |
| 288 [xs,ys]=savgol(x,y,5,5,4); | |
| 289 save -ascii CNCL.sm xs ys; | |
| 290 printf("CNCL.sm\n"); | |
| 291 load -force CNCN.dat; | |
| 292 [xs,ys]=savgol(x,y,5,5,4); | |
| 293 save -ascii CNCN.sm xs ys; | |
| 294 printf("CNCN.sm\n"); | |
| 295 load -force CNCO.dat; | |
| 296 [xs,ys]=savgol(x,y,5,5,4); | |
| 297 save -ascii CNCO.sm xs ys; | |
| 298 printf("CNCO.sm\n"); | |
| 299 load -force CNCP.dat; | |
| 300 [xs,ys]=savgol(x,y,5,5,4); | |
| 301 save -ascii CNCP.sm xs ys; | |
| 302 printf("CNCP.sm\n"); | |
| 303 load -force CNCW.dat; | |
| 304 [xs,ys]=savgol(x,y,5,5,4); | |
| 305 save -ascii CNCW.sm xs ys; | |
| 306 printf("CNCW.sm\n"); | |
| 307 load -force CNF_.dat; | |
| 308 [xs,ys]=savgol(x,y,5,5,4); | |
| 309 save -ascii CNF_.sm xs ys; | |
| 310 printf("CNF_.sm\n"); | |
| 311 load -force CNFe.dat; | |
| 312 [xs,ys]=savgol(x,y,5,5,4); | |
| 313 save -ascii CNFe.sm xs ys; | |
| 314 printf("CNFe.sm\n"); | |
| 315 load -force CNHL.dat; | |
| 316 [xs,ys]=savgol(x,y,5,5,4); | |
| 317 save -ascii CNHL.sm xs ys; | |
| 318 printf("CNHL.sm\n"); | |
| 319 load -force CNMg.dat; | |
| 320 [xs,ys]=savgol(x,y,5,5,4); | |
| 321 save -ascii CNMg.sm xs ys; | |
| 322 printf("CNMg.sm\n"); | |
| 323 load -force CNMn.dat; | |
| 324 [xs,ys]=savgol(x,y,5,5,4); | |
| 325 save -ascii CNMn.sm xs ys; | |
| 326 printf("CNMn.sm\n"); | |
| 327 load -force CNN0.dat; | |
| 328 [xs,ys]=savgol(x,y,5,5,4); | |
| 329 save -ascii CNN0.sm xs ys; | |
| 330 printf("CNN0.sm\n"); | |
| 331 load -force CNNA.dat; | |
| 332 [xs,ys]=savgol(x,y,5,5,4); | |
| 333 save -ascii CNNA.sm xs ys; | |
| 334 printf("CNNA.sm\n"); | |
| 335 load -force CNNC.dat; | |
| 336 [xs,ys]=savgol(x,y,5,5,4); | |
| 337 save -ascii CNNC.sm xs ys; | |
| 338 printf("CNNC.sm\n"); | |
| 339 load -force CNND.dat; | |
| 340 [xs,ys]=savgol(x,y,5,5,4); | |
| 341 save -ascii CNND.sm xs ys; | |
| 342 printf("CNND.sm\n"); | |
| 343 load -force CNNP.dat; | |
| 344 [xs,ys]=savgol(x,y,5,5,4); | |
| 345 save -ascii CNNP.sm xs ys; | |
| 346 printf("CNNP.sm\n"); | |
| 347 load -force CNNR.dat; | |
| 348 [xs,ys]=savgol(x,y,5,5,4); | |
| 349 save -ascii CNNR.sm xs ys; | |
| 350 printf("CNNR.sm\n"); | |
| 351 load -force CNNS.dat; | |
| 352 [xs,ys]=savgol(x,y,5,5,4); | |
| 353 save -ascii CNNS.sm xs ys; | |
| 354 printf("CNNS.sm\n"); | |
| 355 load -force CNOA.dat; | |
| 356 [xs,ys]=savgol(x,y,5,5,4); | |
| 357 save -ascii CNOA.sm xs ys; | |
| 358 printf("CNOA.sm\n"); | |
| 359 load -force CNOC.dat; | |
| 360 [xs,ys]=savgol(x,y,5,5,4); | |
| 361 save -ascii CNOC.sm xs ys; | |
| 362 printf("CNOC.sm\n"); | |
| 363 load -force CNOD.dat; | |
| 364 [xs,ys]=savgol(x,y,5,5,4); | |
| 365 save -ascii CNOD.sm xs ys; | |
| 366 printf("CNOD.sm\n"); | |
| 367 load -force CNOE.dat; | |
| 368 [xs,ys]=savgol(x,y,5,5,4); | |
| 369 save -ascii CNOE.sm xs ys; | |
| 370 printf("CNOE.sm\n"); | |
| 371 load -force CNOR.dat; | |
| 372 [xs,ys]=savgol(x,y,5,5,4); | |
| 373 save -ascii CNOR.sm xs ys; | |
| 374 printf("CNOR.sm\n"); | |
| 375 load -force CNOS.dat; | |
| 376 [xs,ys]=savgol(x,y,5,5,4); | |
| 377 save -ascii CNOS.sm xs ys; | |
| 378 printf("CNOS.sm\n"); | |
| 379 load -force CNP_.dat; | |
| 380 [xs,ys]=savgol(x,y,5,5,4); | |
| 381 save -ascii CNP_.sm xs ys; | |
| 382 printf("CNP_.sm\n"); | |
| 383 load -force CNSA.dat; | |
| 384 [xs,ys]=savgol(x,y,5,5,4); | |
| 385 save -ascii CNSA.sm xs ys; | |
| 386 printf("CNSA.sm\n"); | |
| 387 load -force CNSD.dat; | |
| 388 [xs,ys]=savgol(x,y,5,5,4); | |
| 389 save -ascii CNSD.sm xs ys; | |
| 390 printf("CNSD.sm\n"); | |
| 391 load -force CNV_.dat; | |
| 392 [xs,ys]=savgol(x,y,5,5,4); | |
| 393 save -ascii CNV_.sm xs ys; | |
| 394 printf("CNV_.sm\n"); | |
| 395 load -force CNZn.dat; | |
| 396 [xs,ys]=savgol(x,y,5,5,4); | |
| 397 save -ascii CNZn.sm xs ys; | |
| 398 printf("CNZn.sm\n"); | |
| 399 load -force CNcF.dat; | |
| 400 [xs,ys]=savgol(x,y,5,5,4); | |
| 401 save -ascii CNcF.sm xs ys; | |
| 402 printf("CNcF.sm\n"); | |
| 403 load -force CNcP.dat; | |
| 404 [xs,ys]=savgol(x,y,5,5,4); | |
| 405 save -ascii CNcP.sm xs ys; | |
| 406 printf("CNcP.sm\n"); | |
| 407 load -force COBr.dat; | |
| 408 [xs,ys]=savgol(x,y,5,5,4); | |
| 409 save -ascii COBr.sm xs ys; | |
| 410 printf("COBr.sm\n"); | |
| 411 load -force COC0.dat; | |
| 412 [xs,ys]=savgol(x,y,5,5,4); | |
| 413 save -ascii COC0.sm xs ys; | |
| 414 printf("COC0.sm\n"); | |
| 415 load -force COC3.dat; | |
| 416 [xs,ys]=savgol(x,y,5,5,4); | |
| 417 save -ascii COC3.sm xs ys; | |
| 418 printf("COC3.sm\n"); | |
| 419 load -force COCF.dat; | |
| 420 [xs,ys]=savgol(x,y,5,5,4); | |
| 421 save -ascii COCF.sm xs ys; | |
| 422 printf("COCF.sm\n"); | |
| 423 load -force COCL.dat; | |
| 424 [xs,ys]=savgol(x,y,5,5,4); | |
| 425 save -ascii COCL.sm xs ys; | |
| 426 printf("COCL.sm\n"); | |
| 427 load -force COCN.dat; | |
| 428 [xs,ys]=savgol(x,y,5,5,4); | |
| 429 save -ascii COCN.sm xs ys; | |
| 430 printf("COCN.sm\n"); | |
| 431 load -force COCO.dat; | |
| 432 [xs,ys]=savgol(x,y,5,5,4); | |
| 433 save -ascii COCO.sm xs ys; | |
| 434 printf("COCO.sm\n"); | |
| 435 load -force COCP.dat; | |
| 436 [xs,ys]=savgol(x,y,5,5,4); | |
| 437 save -ascii COCP.sm xs ys; | |
| 438 printf("COCP.sm\n"); | |
| 439 load -force COCW.dat; | |
| 440 [xs,ys]=savgol(x,y,5,5,4); | |
| 441 save -ascii COCW.sm xs ys; | |
| 442 printf("COCW.sm\n"); | |
| 443 load -force COF_.dat; | |
| 444 [xs,ys]=savgol(x,y,5,5,4); | |
| 445 save -ascii COF_.sm xs ys; | |
| 446 printf("COF_.sm\n"); | |
| 447 load -force COFe.dat; | |
| 448 [xs,ys]=savgol(x,y,5,5,4); | |
| 449 save -ascii COFe.sm xs ys; | |
| 450 printf("COFe.sm\n"); | |
| 451 load -force COHL.dat; | |
| 452 [xs,ys]=savgol(x,y,5,5,4); | |
| 453 save -ascii COHL.sm xs ys; | |
| 454 printf("COHL.sm\n"); | |
| 455 load -force COMg.dat; | |
| 456 [xs,ys]=savgol(x,y,5,5,4); | |
| 457 save -ascii COMg.sm xs ys; | |
| 458 printf("COMg.sm\n"); | |
| 459 load -force COMn.dat; | |
| 460 [xs,ys]=savgol(x,y,5,5,4); | |
| 461 save -ascii COMn.sm xs ys; | |
| 462 printf("COMn.sm\n"); | |
| 463 load -force CON0.dat; | |
| 464 [xs,ys]=savgol(x,y,5,5,4); | |
| 465 save -ascii CON0.sm xs ys; | |
| 466 printf("CON0.sm\n"); | |
| 467 load -force CONA.dat; | |
| 468 [xs,ys]=savgol(x,y,5,5,4); | |
| 469 save -ascii CONA.sm xs ys; | |
| 470 printf("CONA.sm\n"); | |
| 471 load -force CONC.dat; | |
| 472 [xs,ys]=savgol(x,y,5,5,4); | |
| 473 save -ascii CONC.sm xs ys; | |
| 474 printf("CONC.sm\n"); | |
| 475 load -force COND.dat; | |
| 476 [xs,ys]=savgol(x,y,5,5,4); | |
| 477 save -ascii COND.sm xs ys; | |
| 478 printf("COND.sm\n"); | |
| 479 load -force CONP.dat; | |
| 480 [xs,ys]=savgol(x,y,5,5,4); | |
| 481 save -ascii CONP.sm xs ys; | |
| 482 printf("CONP.sm\n"); | |
| 483 load -force CONR.dat; | |
| 484 [xs,ys]=savgol(x,y,5,5,4); | |
| 485 save -ascii CONR.sm xs ys; | |
| 486 printf("CONR.sm\n"); | |
| 487 load -force CONS.dat; | |
| 488 [xs,ys]=savgol(x,y,5,5,4); | |
| 489 save -ascii CONS.sm xs ys; | |
| 490 printf("CONS.sm\n"); | |
| 491 load -force COOA.dat; | |
| 492 [xs,ys]=savgol(x,y,5,5,4); | |
| 493 save -ascii COOA.sm xs ys; | |
| 494 printf("COOA.sm\n"); | |
| 495 load -force COOC.dat; | |
| 496 [xs,ys]=savgol(x,y,5,5,4); | |
| 497 save -ascii COOC.sm xs ys; | |
| 498 printf("COOC.sm\n"); | |
| 499 load -force COOD.dat; | |
| 500 [xs,ys]=savgol(x,y,5,5,4); | |
| 501 save -ascii COOD.sm xs ys; | |
| 502 printf("COOD.sm\n"); | |
| 503 load -force COOE.dat; | |
| 504 [xs,ys]=savgol(x,y,5,5,4); | |
| 505 save -ascii COOE.sm xs ys; | |
| 506 printf("COOE.sm\n"); | |
| 507 load -force COOR.dat; | |
| 508 [xs,ys]=savgol(x,y,5,5,4); | |
| 509 save -ascii COOR.sm xs ys; | |
| 510 printf("COOR.sm\n"); | |
| 511 load -force COOS.dat; | |
| 512 [xs,ys]=savgol(x,y,5,5,4); | |
| 513 save -ascii COOS.sm xs ys; | |
| 514 printf("COOS.sm\n"); | |
| 515 load -force COP_.dat; | |
| 516 [xs,ys]=savgol(x,y,5,5,4); | |
| 517 save -ascii COP_.sm xs ys; | |
| 518 printf("COP_.sm\n"); | |
| 519 load -force COSA.dat; | |
| 520 [xs,ys]=savgol(x,y,5,5,4); | |
| 521 save -ascii COSA.sm xs ys; | |
| 522 printf("COSA.sm\n"); | |
| 523 load -force COSD.dat; | |
| 524 [xs,ys]=savgol(x,y,5,5,4); | |
| 525 save -ascii COSD.sm xs ys; | |
| 526 printf("COSD.sm\n"); | |
| 527 load -force COV_.dat; | |
| 528 [xs,ys]=savgol(x,y,5,5,4); | |
| 529 save -ascii COV_.sm xs ys; | |
| 530 printf("COV_.sm\n"); | |
| 531 load -force COZn.dat; | |
| 532 [xs,ys]=savgol(x,y,5,5,4); | |
| 533 save -ascii COZn.sm xs ys; | |
| 534 printf("COZn.sm\n"); | |
| 535 load -force COcF.dat; | |
| 536 [xs,ys]=savgol(x,y,5,5,4); | |
| 537 save -ascii COcF.sm xs ys; | |
| 538 printf("COcF.sm\n"); | |
| 539 load -force COcP.dat; | |
| 540 [xs,ys]=savgol(x,y,5,5,4); | |
| 541 save -ascii COcP.sm xs ys; | |
| 542 printf("COcP.sm\n"); | |
| 543 load -force CPBr.dat; | |
| 544 [xs,ys]=savgol(x,y,5,5,4); | |
| 545 save -ascii CPBr.sm xs ys; | |
| 546 printf("CPBr.sm\n"); | |
| 547 load -force CPC0.dat; | |
| 548 [xs,ys]=savgol(x,y,5,5,4); | |
| 549 save -ascii CPC0.sm xs ys; | |
| 550 printf("CPC0.sm\n"); | |
| 551 load -force CPC3.dat; | |
| 552 [xs,ys]=savgol(x,y,5,5,4); | |
| 553 save -ascii CPC3.sm xs ys; | |
| 554 printf("CPC3.sm\n"); | |
| 555 load -force CPCF.dat; | |
| 556 [xs,ys]=savgol(x,y,5,5,4); | |
| 557 save -ascii CPCF.sm xs ys; | |
| 558 printf("CPCF.sm\n"); | |
| 559 load -force CPCL.dat; | |
| 560 [xs,ys]=savgol(x,y,5,5,4); | |
| 561 save -ascii CPCL.sm xs ys; | |
| 562 printf("CPCL.sm\n"); | |
| 563 load -force CPCN.dat; | |
| 564 [xs,ys]=savgol(x,y,5,5,4); | |
| 565 save -ascii CPCN.sm xs ys; | |
| 566 printf("CPCN.sm\n"); | |
| 567 load -force CPCO.dat; | |
| 568 [xs,ys]=savgol(x,y,5,5,4); | |
| 569 save -ascii CPCO.sm xs ys; | |
| 570 printf("CPCO.sm\n"); | |
| 571 load -force CPCP.dat; | |
| 572 [xs,ys]=savgol(x,y,5,5,4); | |
| 573 save -ascii CPCP.sm xs ys; | |
| 574 printf("CPCP.sm\n"); | |
| 575 load -force CPCW.dat; | |
| 576 [xs,ys]=savgol(x,y,5,5,4); | |
| 577 save -ascii CPCW.sm xs ys; | |
| 578 printf("CPCW.sm\n"); | |
| 579 load -force CPF_.dat; | |
| 580 [xs,ys]=savgol(x,y,5,5,4); | |
| 581 save -ascii CPF_.sm xs ys; | |
| 582 printf("CPF_.sm\n"); | |
| 583 load -force CPFe.dat; | |
| 584 [xs,ys]=savgol(x,y,5,5,4); | |
| 585 save -ascii CPFe.sm xs ys; | |
| 586 printf("CPFe.sm\n"); | |
| 587 load -force CPHL.dat; | |
| 588 [xs,ys]=savgol(x,y,5,5,4); | |
| 589 save -ascii CPHL.sm xs ys; | |
| 590 printf("CPHL.sm\n"); | |
| 591 load -force CPMg.dat; | |
| 592 [xs,ys]=savgol(x,y,5,5,4); | |
| 593 save -ascii CPMg.sm xs ys; | |
| 594 printf("CPMg.sm\n"); | |
| 595 load -force CPMn.dat; | |
| 596 [xs,ys]=savgol(x,y,5,5,4); | |
| 597 save -ascii CPMn.sm xs ys; | |
| 598 printf("CPMn.sm\n"); | |
| 599 load -force CPN0.dat; | |
| 600 [xs,ys]=savgol(x,y,5,5,4); | |
| 601 save -ascii CPN0.sm xs ys; | |
| 602 printf("CPN0.sm\n"); | |
| 603 load -force CPNA.dat; | |
| 604 [xs,ys]=savgol(x,y,5,5,4); | |
| 605 save -ascii CPNA.sm xs ys; | |
| 606 printf("CPNA.sm\n"); | |
| 607 load -force CPNC.dat; | |
| 608 [xs,ys]=savgol(x,y,5,5,4); | |
| 609 save -ascii CPNC.sm xs ys; | |
| 610 printf("CPNC.sm\n"); | |
| 611 load -force CPND.dat; | |
| 612 [xs,ys]=savgol(x,y,5,5,4); | |
| 613 save -ascii CPND.sm xs ys; | |
| 614 printf("CPND.sm\n"); | |
| 615 load -force CPNP.dat; | |
| 616 [xs,ys]=savgol(x,y,5,5,4); | |
| 617 save -ascii CPNP.sm xs ys; | |
| 618 printf("CPNP.sm\n"); | |
| 619 load -force CPNR.dat; | |
| 620 [xs,ys]=savgol(x,y,5,5,4); | |
| 621 save -ascii CPNR.sm xs ys; | |
| 622 printf("CPNR.sm\n"); | |
| 623 load -force CPNS.dat; | |
| 624 [xs,ys]=savgol(x,y,5,5,4); | |
| 625 save -ascii CPNS.sm xs ys; | |
| 626 printf("CPNS.sm\n"); | |
| 627 load -force CPOA.dat; | |
| 628 [xs,ys]=savgol(x,y,5,5,4); | |
| 629 save -ascii CPOA.sm xs ys; | |
| 630 printf("CPOA.sm\n"); | |
| 631 load -force CPOC.dat; | |
| 632 [xs,ys]=savgol(x,y,5,5,4); | |
| 633 save -ascii CPOC.sm xs ys; | |
| 634 printf("CPOC.sm\n"); | |
| 635 load -force CPOD.dat; | |
| 636 [xs,ys]=savgol(x,y,5,5,4); | |
| 637 save -ascii CPOD.sm xs ys; | |
| 638 printf("CPOD.sm\n"); | |
| 639 load -force CPOE.dat; | |
| 640 [xs,ys]=savgol(x,y,5,5,4); | |
| 641 save -ascii CPOE.sm xs ys; | |
| 642 printf("CPOE.sm\n"); | |
| 643 load -force CPOR.dat; | |
| 644 [xs,ys]=savgol(x,y,5,5,4); | |
| 645 save -ascii CPOR.sm xs ys; | |
| 646 printf("CPOR.sm\n"); | |
| 647 load -force CPOS.dat; | |
| 648 [xs,ys]=savgol(x,y,5,5,4); | |
| 649 save -ascii CPOS.sm xs ys; | |
| 650 printf("CPOS.sm\n"); | |
| 651 load -force CPP_.dat; | |
| 652 [xs,ys]=savgol(x,y,5,5,4); | |
| 653 save -ascii CPP_.sm xs ys; | |
| 654 printf("CPP_.sm\n"); | |
| 655 load -force CPSA.dat; | |
| 656 [xs,ys]=savgol(x,y,5,5,4); | |
| 657 save -ascii CPSA.sm xs ys; | |
| 658 printf("CPSA.sm\n"); | |
| 659 load -force CPSD.dat; | |
| 660 [xs,ys]=savgol(x,y,5,5,4); | |
| 661 save -ascii CPSD.sm xs ys; | |
| 662 printf("CPSD.sm\n"); | |
| 663 load -force CPV_.dat; | |
| 664 [xs,ys]=savgol(x,y,5,5,4); | |
| 665 save -ascii CPV_.sm xs ys; | |
| 666 printf("CPV_.sm\n"); | |
| 667 load -force CPZn.dat; | |
| 668 [xs,ys]=savgol(x,y,5,5,4); | |
| 669 save -ascii CPZn.sm xs ys; | |
| 670 printf("CPZn.sm\n"); | |
| 671 load -force CPcF.dat; | |
| 672 [xs,ys]=savgol(x,y,5,5,4); | |
| 673 save -ascii CPcF.sm xs ys; | |
| 674 printf("CPcF.sm\n"); | |
| 675 load -force CPcP.dat; | |
| 676 [xs,ys]=savgol(x,y,5,5,4); | |
| 677 save -ascii CPcP.sm xs ys; | |
| 678 printf("CPcP.sm\n"); | |
| 679 load -force HHBr.dat; | |
| 680 [xs,ys]=savgol(x,y,5,5,4); | |
| 681 save -ascii HHBr.sm xs ys; | |
| 682 printf("HHBr.sm\n"); | |
| 683 load -force HHC0.dat; | |
| 684 [xs,ys]=savgol(x,y,5,5,4); | |
| 685 save -ascii HHC0.sm xs ys; | |
| 686 printf("HHC0.sm\n"); | |
| 687 load -force HHC3.dat; | |
| 688 [xs,ys]=savgol(x,y,5,5,4); | |
| 689 save -ascii HHC3.sm xs ys; | |
| 690 printf("HHC3.sm\n"); | |
| 691 load -force HHCF.dat; | |
| 692 [xs,ys]=savgol(x,y,5,5,4); | |
| 693 save -ascii HHCF.sm xs ys; | |
| 694 printf("HHCF.sm\n"); | |
| 695 load -force HHCL.dat; | |
| 696 [xs,ys]=savgol(x,y,5,5,4); | |
| 697 save -ascii HHCL.sm xs ys; | |
| 698 printf("HHCL.sm\n"); | |
| 699 load -force HHCN.dat; | |
| 700 [xs,ys]=savgol(x,y,5,5,4); | |
| 701 save -ascii HHCN.sm xs ys; | |
| 702 printf("HHCN.sm\n"); | |
| 703 load -force HHCO.dat; | |
| 704 [xs,ys]=savgol(x,y,5,5,4); | |
| 705 save -ascii HHCO.sm xs ys; | |
| 706 printf("HHCO.sm\n"); | |
| 707 load -force HHCP.dat; | |
| 708 [xs,ys]=savgol(x,y,5,5,4); | |
| 709 save -ascii HHCP.sm xs ys; | |
| 710 printf("HHCP.sm\n"); | |
| 711 load -force HHCW.dat; | |
| 712 [xs,ys]=savgol(x,y,5,5,4); | |
| 713 save -ascii HHCW.sm xs ys; | |
| 714 printf("HHCW.sm\n"); | |
| 715 load -force HHF_.dat; | |
| 716 [xs,ys]=savgol(x,y,5,5,4); | |
| 717 save -ascii HHF_.sm xs ys; | |
| 718 printf("HHF_.sm\n"); | |
| 719 load -force HHFe.dat; | |
| 720 [xs,ys]=savgol(x,y,5,5,4); | |
| 721 save -ascii HHFe.sm xs ys; | |
| 722 printf("HHFe.sm\n"); | |
| 723 load -force HHHL.dat; | |
| 724 [xs,ys]=savgol(x,y,5,5,4); | |
| 725 save -ascii HHHL.sm xs ys; | |
| 726 printf("HHHL.sm\n"); | |
| 727 load -force HHMg.dat; | |
| 728 [xs,ys]=savgol(x,y,5,5,4); | |
| 729 save -ascii HHMg.sm xs ys; | |
| 730 printf("HHMg.sm\n"); | |
| 731 load -force HHMn.dat; | |
| 732 [xs,ys]=savgol(x,y,5,5,4); | |
| 733 save -ascii HHMn.sm xs ys; | |
| 734 printf("HHMn.sm\n"); | |
| 735 load -force HHN0.dat; | |
| 736 [xs,ys]=savgol(x,y,5,5,4); | |
| 737 save -ascii HHN0.sm xs ys; | |
| 738 printf("HHN0.sm\n"); | |
| 739 load -force HHNA.dat; | |
| 740 [xs,ys]=savgol(x,y,5,5,4); | |
| 741 save -ascii HHNA.sm xs ys; | |
| 742 printf("HHNA.sm\n"); | |
| 743 load -force HHNC.dat; | |
| 744 [xs,ys]=savgol(x,y,5,5,4); | |
| 745 save -ascii HHNC.sm xs ys; | |
| 746 printf("HHNC.sm\n"); | |
| 747 load -force HHND.dat; | |
| 748 [xs,ys]=savgol(x,y,5,5,4); | |
| 749 save -ascii HHND.sm xs ys; | |
| 750 printf("HHND.sm\n"); | |
| 751 load -force HHNP.dat; | |
| 752 [xs,ys]=savgol(x,y,5,5,4); | |
| 753 save -ascii HHNP.sm xs ys; | |
| 754 printf("HHNP.sm\n"); | |
| 755 load -force HHNR.dat; | |
| 756 [xs,ys]=savgol(x,y,5,5,4); | |
| 757 save -ascii HHNR.sm xs ys; | |
| 758 printf("HHNR.sm\n"); | |
| 759 load -force HHNS.dat; | |
| 760 [xs,ys]=savgol(x,y,5,5,4); | |
| 761 save -ascii HHNS.sm xs ys; | |
| 762 printf("HHNS.sm\n"); | |
| 763 load -force HHOA.dat; | |
| 764 [xs,ys]=savgol(x,y,5,5,4); | |
| 765 save -ascii HHOA.sm xs ys; | |
| 766 printf("HHOA.sm\n"); | |
| 767 load -force HHOC.dat; | |
| 768 [xs,ys]=savgol(x,y,5,5,4); | |
| 769 save -ascii HHOC.sm xs ys; | |
| 770 printf("HHOC.sm\n"); | |
| 771 load -force HHOD.dat; | |
| 772 [xs,ys]=savgol(x,y,5,5,4); | |
| 773 save -ascii HHOD.sm xs ys; | |
| 774 printf("HHOD.sm\n"); | |
| 775 load -force HHOE.dat; | |
| 776 [xs,ys]=savgol(x,y,5,5,4); | |
| 777 save -ascii HHOE.sm xs ys; | |
| 778 printf("HHOE.sm\n"); | |
| 779 load -force HHOR.dat; | |
| 780 [xs,ys]=savgol(x,y,5,5,4); | |
| 781 save -ascii HHOR.sm xs ys; | |
| 782 printf("HHOR.sm\n"); | |
| 783 load -force HHOS.dat; | |
| 784 [xs,ys]=savgol(x,y,5,5,4); | |
| 785 save -ascii HHOS.sm xs ys; | |
| 786 printf("HHOS.sm\n"); | |
| 787 load -force HHP_.dat; | |
| 788 [xs,ys]=savgol(x,y,5,5,4); | |
| 789 save -ascii HHP_.sm xs ys; | |
| 790 printf("HHP_.sm\n"); | |
| 791 load -force HHSA.dat; | |
| 792 [xs,ys]=savgol(x,y,5,5,4); | |
| 793 save -ascii HHSA.sm xs ys; | |
| 794 printf("HHSA.sm\n"); | |
| 795 load -force HHSD.dat; | |
| 796 [xs,ys]=savgol(x,y,5,5,4); | |
| 797 save -ascii HHSD.sm xs ys; | |
| 798 printf("HHSD.sm\n"); | |
| 799 load -force HHV_.dat; | |
| 800 [xs,ys]=savgol(x,y,5,5,4); | |
| 801 save -ascii HHV_.sm xs ys; | |
| 802 printf("HHV_.sm\n"); | |
| 803 load -force HHZn.dat; | |
| 804 [xs,ys]=savgol(x,y,5,5,4); | |
| 805 save -ascii HHZn.sm xs ys; | |
| 806 printf("HHZn.sm\n"); | |
| 807 load -force HHcF.dat; | |
| 808 [xs,ys]=savgol(x,y,5,5,4); | |
| 809 save -ascii HHcF.sm xs ys; | |
| 810 printf("HHcF.sm\n"); | |
| 811 load -force HHcP.dat; | |
| 812 [xs,ys]=savgol(x,y,5,5,4); | |
| 813 save -ascii HHcP.sm xs ys; | |
| 814 printf("HHcP.sm\n"); | |
| 815 load -force NCBr.dat; | |
| 816 [xs,ys]=savgol(x,y,5,5,4); | |
| 817 save -ascii NCBr.sm xs ys; | |
| 818 printf("NCBr.sm\n"); | |
| 819 load -force NCC0.dat; | |
| 820 [xs,ys]=savgol(x,y,5,5,4); | |
| 821 save -ascii NCC0.sm xs ys; | |
| 822 printf("NCC0.sm\n"); | |
| 823 load -force NCC3.dat; | |
| 824 [xs,ys]=savgol(x,y,5,5,4); | |
| 825 save -ascii NCC3.sm xs ys; | |
| 826 printf("NCC3.sm\n"); | |
| 827 load -force NCCF.dat; | |
| 828 [xs,ys]=savgol(x,y,5,5,4); | |
| 829 save -ascii NCCF.sm xs ys; | |
| 830 printf("NCCF.sm\n"); | |
| 831 load -force NCCL.dat; | |
| 832 [xs,ys]=savgol(x,y,5,5,4); | |
| 833 save -ascii NCCL.sm xs ys; | |
| 834 printf("NCCL.sm\n"); | |
| 835 load -force NCCN.dat; | |
| 836 [xs,ys]=savgol(x,y,5,5,4); | |
| 837 save -ascii NCCN.sm xs ys; | |
| 838 printf("NCCN.sm\n"); | |
| 839 load -force NCCO.dat; | |
| 840 [xs,ys]=savgol(x,y,5,5,4); | |
| 841 save -ascii NCCO.sm xs ys; | |
| 842 printf("NCCO.sm\n"); | |
| 843 load -force NCCP.dat; | |
| 844 [xs,ys]=savgol(x,y,5,5,4); | |
| 845 save -ascii NCCP.sm xs ys; | |
| 846 printf("NCCP.sm\n"); | |
| 847 load -force NCCW.dat; | |
| 848 [xs,ys]=savgol(x,y,5,5,4); | |
| 849 save -ascii NCCW.sm xs ys; | |
| 850 printf("NCCW.sm\n"); | |
| 851 load -force NCF_.dat; | |
| 852 [xs,ys]=savgol(x,y,5,5,4); | |
| 853 save -ascii NCF_.sm xs ys; | |
| 854 printf("NCF_.sm\n"); | |
| 855 load -force NCFe.dat; | |
| 856 [xs,ys]=savgol(x,y,5,5,4); | |
| 857 save -ascii NCFe.sm xs ys; | |
| 858 printf("NCFe.sm\n"); | |
| 859 load -force NCHL.dat; | |
| 860 [xs,ys]=savgol(x,y,5,5,4); | |
| 861 save -ascii NCHL.sm xs ys; | |
| 862 printf("NCHL.sm\n"); | |
| 863 load -force NCMg.dat; | |
| 864 [xs,ys]=savgol(x,y,5,5,4); | |
| 865 save -ascii NCMg.sm xs ys; | |
| 866 printf("NCMg.sm\n"); | |
| 867 load -force NCMn.dat; | |
| 868 [xs,ys]=savgol(x,y,5,5,4); | |
| 869 save -ascii NCMn.sm xs ys; | |
| 870 printf("NCMn.sm\n"); | |
| 871 load -force NCN0.dat; | |
| 872 [xs,ys]=savgol(x,y,5,5,4); | |
| 873 save -ascii NCN0.sm xs ys; | |
| 874 printf("NCN0.sm\n"); | |
| 875 load -force NCNA.dat; | |
| 876 [xs,ys]=savgol(x,y,5,5,4); | |
| 877 save -ascii NCNA.sm xs ys; | |
| 878 printf("NCNA.sm\n"); | |
| 879 load -force NCNC.dat; | |
| 880 [xs,ys]=savgol(x,y,5,5,4); | |
| 881 save -ascii NCNC.sm xs ys; | |
| 882 printf("NCNC.sm\n"); | |
| 883 load -force NCND.dat; | |
| 884 [xs,ys]=savgol(x,y,5,5,4); | |
| 885 save -ascii NCND.sm xs ys; | |
| 886 printf("NCND.sm\n"); | |
| 887 load -force NCNP.dat; | |
| 888 [xs,ys]=savgol(x,y,5,5,4); | |
| 889 save -ascii NCNP.sm xs ys; | |
| 890 printf("NCNP.sm\n"); | |
| 891 load -force NCNR.dat; | |
| 892 [xs,ys]=savgol(x,y,5,5,4); | |
| 893 save -ascii NCNR.sm xs ys; | |
| 894 printf("NCNR.sm\n"); | |
| 895 load -force NCNS.dat; | |
| 896 [xs,ys]=savgol(x,y,5,5,4); | |
| 897 save -ascii NCNS.sm xs ys; | |
| 898 printf("NCNS.sm\n"); | |
| 899 load -force NCOA.dat; | |
| 900 [xs,ys]=savgol(x,y,5,5,4); | |
| 901 save -ascii NCOA.sm xs ys; | |
| 902 printf("NCOA.sm\n"); | |
| 903 load -force NCOC.dat; | |
| 904 [xs,ys]=savgol(x,y,5,5,4); | |
| 905 save -ascii NCOC.sm xs ys; | |
| 906 printf("NCOC.sm\n"); | |
| 907 load -force NCOD.dat; | |
| 908 [xs,ys]=savgol(x,y,5,5,4); | |
| 909 save -ascii NCOD.sm xs ys; | |
| 910 printf("NCOD.sm\n"); | |
| 911 load -force NCOE.dat; | |
| 912 [xs,ys]=savgol(x,y,5,5,4); | |
| 913 save -ascii NCOE.sm xs ys; | |
| 914 printf("NCOE.sm\n"); | |
| 915 load -force NCOR.dat; | |
| 916 [xs,ys]=savgol(x,y,5,5,4); | |
| 917 save -ascii NCOR.sm xs ys; | |
| 918 printf("NCOR.sm\n"); | |
| 919 load -force NCOS.dat; | |
| 920 [xs,ys]=savgol(x,y,5,5,4); | |
| 921 save -ascii NCOS.sm xs ys; | |
| 922 printf("NCOS.sm\n"); | |
| 923 load -force NCP_.dat; | |
| 924 [xs,ys]=savgol(x,y,5,5,4); | |
| 925 save -ascii NCP_.sm xs ys; | |
| 926 printf("NCP_.sm\n"); | |
| 927 load -force NCSA.dat; | |
| 928 [xs,ys]=savgol(x,y,5,5,4); | |
| 929 save -ascii NCSA.sm xs ys; | |
| 930 printf("NCSA.sm\n"); | |
| 931 load -force NCSD.dat; | |
| 932 [xs,ys]=savgol(x,y,5,5,4); | |
| 933 save -ascii NCSD.sm xs ys; | |
| 934 printf("NCSD.sm\n"); | |
| 935 load -force NCV_.dat; | |
| 936 [xs,ys]=savgol(x,y,5,5,4); | |
| 937 save -ascii NCV_.sm xs ys; | |
| 938 printf("NCV_.sm\n"); | |
| 939 load -force NCZn.dat; | |
| 940 [xs,ys]=savgol(x,y,5,5,4); | |
| 941 save -ascii NCZn.sm xs ys; | |
| 942 printf("NCZn.sm\n"); | |
| 943 load -force NCcF.dat; | |
| 944 [xs,ys]=savgol(x,y,5,5,4); | |
| 945 save -ascii NCcF.sm xs ys; | |
| 946 printf("NCcF.sm\n"); | |
| 947 load -force NCcP.dat; | |
| 948 [xs,ys]=savgol(x,y,5,5,4); | |
| 949 save -ascii NCcP.sm xs ys; | |
| 950 printf("NCcP.sm\n"); | |
| 951 load -force NDBr.dat; | |
| 952 [xs,ys]=savgol(x,y,5,5,4); | |
| 953 save -ascii NDBr.sm xs ys; | |
| 954 printf("NDBr.sm\n"); | |
| 955 load -force NDC0.dat; | |
| 956 [xs,ys]=savgol(x,y,5,5,4); | |
| 957 save -ascii NDC0.sm xs ys; | |
| 958 printf("NDC0.sm\n"); | |
| 959 load -force NDC3.dat; | |
| 960 [xs,ys]=savgol(x,y,5,5,4); | |
| 961 save -ascii NDC3.sm xs ys; | |
| 962 printf("NDC3.sm\n"); | |
| 963 load -force NDCF.dat; | |
| 964 [xs,ys]=savgol(x,y,5,5,4); | |
| 965 save -ascii NDCF.sm xs ys; | |
| 966 printf("NDCF.sm\n"); | |
| 967 load -force NDCL.dat; | |
| 968 [xs,ys]=savgol(x,y,5,5,4); | |
| 969 save -ascii NDCL.sm xs ys; | |
| 970 printf("NDCL.sm\n"); | |
| 971 load -force NDCN.dat; | |
| 972 [xs,ys]=savgol(x,y,5,5,4); | |
| 973 save -ascii NDCN.sm xs ys; | |
| 974 printf("NDCN.sm\n"); | |
| 975 load -force NDCO.dat; | |
| 976 [xs,ys]=savgol(x,y,5,5,4); | |
| 977 save -ascii NDCO.sm xs ys; | |
| 978 printf("NDCO.sm\n"); | |
| 979 load -force NDCP.dat; | |
| 980 [xs,ys]=savgol(x,y,5,5,4); | |
| 981 save -ascii NDCP.sm xs ys; | |
| 982 printf("NDCP.sm\n"); | |
| 983 load -force NDCW.dat; | |
| 984 [xs,ys]=savgol(x,y,5,5,4); | |
| 985 save -ascii NDCW.sm xs ys; | |
| 986 printf("NDCW.sm\n"); | |
| 987 load -force NDF_.dat; | |
| 988 [xs,ys]=savgol(x,y,5,5,4); | |
| 989 save -ascii NDF_.sm xs ys; | |
| 990 printf("NDF_.sm\n"); | |
| 991 load -force NDFe.dat; | |
| 992 [xs,ys]=savgol(x,y,5,5,4); | |
| 993 save -ascii NDFe.sm xs ys; | |
| 994 printf("NDFe.sm\n"); | |
| 995 load -force NDHL.dat; | |
| 996 [xs,ys]=savgol(x,y,5,5,4); | |
| 997 save -ascii NDHL.sm xs ys; | |
| 998 printf("NDHL.sm\n"); | |
| 999 load -force NDMg.dat; | |
| 1000 [xs,ys]=savgol(x,y,5,5,4); | |
| 1001 save -ascii NDMg.sm xs ys; | |
| 1002 printf("NDMg.sm\n"); | |
| 1003 load -force NDMn.dat; | |
| 1004 [xs,ys]=savgol(x,y,5,5,4); | |
| 1005 save -ascii NDMn.sm xs ys; | |
| 1006 printf("NDMn.sm\n"); | |
| 1007 load -force NDN0.dat; | |
| 1008 [xs,ys]=savgol(x,y,5,5,4); | |
| 1009 save -ascii NDN0.sm xs ys; | |
| 1010 printf("NDN0.sm\n"); | |
| 1011 load -force NDNA.dat; | |
| 1012 [xs,ys]=savgol(x,y,5,5,4); | |
| 1013 save -ascii NDNA.sm xs ys; | |
| 1014 printf("NDNA.sm\n"); | |
| 1015 load -force NDNC.dat; | |
| 1016 [xs,ys]=savgol(x,y,5,5,4); | |
| 1017 save -ascii NDNC.sm xs ys; | |
| 1018 printf("NDNC.sm\n"); | |
| 1019 load -force NDND.dat; | |
| 1020 [xs,ys]=savgol(x,y,5,5,4); | |
| 1021 save -ascii NDND.sm xs ys; | |
| 1022 printf("NDND.sm\n"); | |
| 1023 load -force NDNP.dat; | |
| 1024 [xs,ys]=savgol(x,y,5,5,4); | |
| 1025 save -ascii NDNP.sm xs ys; | |
| 1026 printf("NDNP.sm\n"); | |
| 1027 load -force NDNR.dat; | |
| 1028 [xs,ys]=savgol(x,y,5,5,4); | |
| 1029 save -ascii NDNR.sm xs ys; | |
| 1030 printf("NDNR.sm\n"); | |
| 1031 load -force NDNS.dat; | |
| 1032 [xs,ys]=savgol(x,y,5,5,4); | |
| 1033 save -ascii NDNS.sm xs ys; | |
| 1034 printf("NDNS.sm\n"); | |
| 1035 load -force NDOA.dat; | |
| 1036 [xs,ys]=savgol(x,y,5,5,4); | |
| 1037 save -ascii NDOA.sm xs ys; | |
| 1038 printf("NDOA.sm\n"); | |
| 1039 load -force NDOC.dat; | |
| 1040 [xs,ys]=savgol(x,y,5,5,4); | |
| 1041 save -ascii NDOC.sm xs ys; | |
| 1042 printf("NDOC.sm\n"); | |
| 1043 load -force NDOD.dat; | |
| 1044 [xs,ys]=savgol(x,y,5,5,4); | |
| 1045 save -ascii NDOD.sm xs ys; | |
| 1046 printf("NDOD.sm\n"); | |
| 1047 load -force NDOE.dat; | |
| 1048 [xs,ys]=savgol(x,y,5,5,4); | |
| 1049 save -ascii NDOE.sm xs ys; | |
| 1050 printf("NDOE.sm\n"); | |
| 1051 load -force NDOR.dat; | |
| 1052 [xs,ys]=savgol(x,y,5,5,4); | |
| 1053 save -ascii NDOR.sm xs ys; | |
| 1054 printf("NDOR.sm\n"); | |
| 1055 load -force NDOS.dat; | |
| 1056 [xs,ys]=savgol(x,y,5,5,4); | |
| 1057 save -ascii NDOS.sm xs ys; | |
| 1058 printf("NDOS.sm\n"); | |
| 1059 load -force NDP_.dat; | |
| 1060 [xs,ys]=savgol(x,y,5,5,4); | |
| 1061 save -ascii NDP_.sm xs ys; | |
| 1062 printf("NDP_.sm\n"); | |
| 1063 load -force NDSA.dat; | |
| 1064 [xs,ys]=savgol(x,y,5,5,4); | |
| 1065 save -ascii NDSA.sm xs ys; | |
| 1066 printf("NDSA.sm\n"); | |
| 1067 load -force NDSD.dat; | |
| 1068 [xs,ys]=savgol(x,y,5,5,4); | |
| 1069 save -ascii NDSD.sm xs ys; | |
| 1070 printf("NDSD.sm\n"); | |
| 1071 load -force NDV_.dat; | |
| 1072 [xs,ys]=savgol(x,y,5,5,4); | |
| 1073 save -ascii NDV_.sm xs ys; | |
| 1074 printf("NDV_.sm\n"); | |
| 1075 load -force NDZn.dat; | |
| 1076 [xs,ys]=savgol(x,y,5,5,4); | |
| 1077 save -ascii NDZn.sm xs ys; | |
| 1078 printf("NDZn.sm\n"); | |
| 1079 load -force NDcF.dat; | |
| 1080 [xs,ys]=savgol(x,y,5,5,4); | |
| 1081 save -ascii NDcF.sm xs ys; | |
| 1082 printf("NDcF.sm\n"); | |
| 1083 load -force NDcP.dat; | |
| 1084 [xs,ys]=savgol(x,y,5,5,4); | |
| 1085 save -ascii NDcP.sm xs ys; | |
| 1086 printf("NDcP.sm\n"); | |
| 1087 load -force NRBr.dat; | |
| 1088 [xs,ys]=savgol(x,y,5,5,4); | |
| 1089 save -ascii NRBr.sm xs ys; | |
| 1090 printf("NRBr.sm\n"); | |
| 1091 load -force NRC0.dat; | |
| 1092 [xs,ys]=savgol(x,y,5,5,4); | |
| 1093 save -ascii NRC0.sm xs ys; | |
| 1094 printf("NRC0.sm\n"); | |
| 1095 load -force NRC3.dat; | |
| 1096 [xs,ys]=savgol(x,y,5,5,4); | |
| 1097 save -ascii NRC3.sm xs ys; | |
| 1098 printf("NRC3.sm\n"); | |
| 1099 load -force NRCF.dat; | |
| 1100 [xs,ys]=savgol(x,y,5,5,4); | |
| 1101 save -ascii NRCF.sm xs ys; | |
| 1102 printf("NRCF.sm\n"); | |
| 1103 load -force NRCL.dat; | |
| 1104 [xs,ys]=savgol(x,y,5,5,4); | |
| 1105 save -ascii NRCL.sm xs ys; | |
| 1106 printf("NRCL.sm\n"); | |
| 1107 load -force NRCN.dat; | |
| 1108 [xs,ys]=savgol(x,y,5,5,4); | |
| 1109 save -ascii NRCN.sm xs ys; | |
| 1110 printf("NRCN.sm\n"); | |
| 1111 load -force NRCO.dat; | |
| 1112 [xs,ys]=savgol(x,y,5,5,4); | |
| 1113 save -ascii NRCO.sm xs ys; | |
| 1114 printf("NRCO.sm\n"); | |
| 1115 load -force NRCP.dat; | |
| 1116 [xs,ys]=savgol(x,y,5,5,4); | |
| 1117 save -ascii NRCP.sm xs ys; | |
| 1118 printf("NRCP.sm\n"); | |
| 1119 load -force NRCW.dat; | |
| 1120 [xs,ys]=savgol(x,y,5,5,4); | |
| 1121 save -ascii NRCW.sm xs ys; | |
| 1122 printf("NRCW.sm\n"); | |
| 1123 load -force NRF_.dat; | |
| 1124 [xs,ys]=savgol(x,y,5,5,4); | |
| 1125 save -ascii NRF_.sm xs ys; | |
| 1126 printf("NRF_.sm\n"); | |
| 1127 load -force NRFe.dat; | |
| 1128 [xs,ys]=savgol(x,y,5,5,4); | |
| 1129 save -ascii NRFe.sm xs ys; | |
| 1130 printf("NRFe.sm\n"); | |
| 1131 load -force NRHL.dat; | |
| 1132 [xs,ys]=savgol(x,y,5,5,4); | |
| 1133 save -ascii NRHL.sm xs ys; | |
| 1134 printf("NRHL.sm\n"); | |
| 1135 load -force NRMg.dat; | |
| 1136 [xs,ys]=savgol(x,y,5,5,4); | |
| 1137 save -ascii NRMg.sm xs ys; | |
| 1138 printf("NRMg.sm\n"); | |
| 1139 load -force NRMn.dat; | |
| 1140 [xs,ys]=savgol(x,y,5,5,4); | |
| 1141 save -ascii NRMn.sm xs ys; | |
| 1142 printf("NRMn.sm\n"); | |
| 1143 load -force NRN0.dat; | |
| 1144 [xs,ys]=savgol(x,y,5,5,4); | |
| 1145 save -ascii NRN0.sm xs ys; | |
| 1146 printf("NRN0.sm\n"); | |
| 1147 load -force NRNA.dat; | |
| 1148 [xs,ys]=savgol(x,y,5,5,4); | |
| 1149 save -ascii NRNA.sm xs ys; | |
| 1150 printf("NRNA.sm\n"); | |
| 1151 load -force NRNC.dat; | |
| 1152 [xs,ys]=savgol(x,y,5,5,4); | |
| 1153 save -ascii NRNC.sm xs ys; | |
| 1154 printf("NRNC.sm\n"); | |
| 1155 load -force NRND.dat; | |
| 1156 [xs,ys]=savgol(x,y,5,5,4); | |
| 1157 save -ascii NRND.sm xs ys; | |
| 1158 printf("NRND.sm\n"); | |
| 1159 load -force NRNP.dat; | |
| 1160 [xs,ys]=savgol(x,y,5,5,4); | |
| 1161 save -ascii NRNP.sm xs ys; | |
| 1162 printf("NRNP.sm\n"); | |
| 1163 load -force NRNR.dat; | |
| 1164 [xs,ys]=savgol(x,y,5,5,4); | |
| 1165 save -ascii NRNR.sm xs ys; | |
| 1166 printf("NRNR.sm\n"); | |
| 1167 load -force NRNS.dat; | |
| 1168 [xs,ys]=savgol(x,y,5,5,4); | |
| 1169 save -ascii NRNS.sm xs ys; | |
| 1170 printf("NRNS.sm\n"); | |
| 1171 load -force NROA.dat; | |
| 1172 [xs,ys]=savgol(x,y,5,5,4); | |
| 1173 save -ascii NROA.sm xs ys; | |
| 1174 printf("NROA.sm\n"); | |
| 1175 load -force NROC.dat; | |
| 1176 [xs,ys]=savgol(x,y,5,5,4); | |
| 1177 save -ascii NROC.sm xs ys; | |
| 1178 printf("NROC.sm\n"); | |
| 1179 load -force NROD.dat; | |
| 1180 [xs,ys]=savgol(x,y,5,5,4); | |
| 1181 save -ascii NROD.sm xs ys; | |
| 1182 printf("NROD.sm\n"); | |
| 1183 load -force NROE.dat; | |
| 1184 [xs,ys]=savgol(x,y,5,5,4); | |
| 1185 save -ascii NROE.sm xs ys; | |
| 1186 printf("NROE.sm\n"); | |
| 1187 load -force NROR.dat; | |
| 1188 [xs,ys]=savgol(x,y,5,5,4); | |
| 1189 save -ascii NROR.sm xs ys; | |
| 1190 printf("NROR.sm\n"); | |
| 1191 load -force NROS.dat; | |
| 1192 [xs,ys]=savgol(x,y,5,5,4); | |
| 1193 save -ascii NROS.sm xs ys; | |
| 1194 printf("NROS.sm\n"); | |
| 1195 load -force NRP_.dat; | |
| 1196 [xs,ys]=savgol(x,y,5,5,4); | |
| 1197 save -ascii NRP_.sm xs ys; | |
| 1198 printf("NRP_.sm\n"); | |
| 1199 load -force NRSA.dat; | |
| 1200 [xs,ys]=savgol(x,y,5,5,4); | |
| 1201 save -ascii NRSA.sm xs ys; | |
| 1202 printf("NRSA.sm\n"); | |
| 1203 load -force NRSD.dat; | |
| 1204 [xs,ys]=savgol(x,y,5,5,4); | |
| 1205 save -ascii NRSD.sm xs ys; | |
| 1206 printf("NRSD.sm\n"); | |
| 1207 load -force NRV_.dat; | |
| 1208 [xs,ys]=savgol(x,y,5,5,4); | |
| 1209 save -ascii NRV_.sm xs ys; | |
| 1210 printf("NRV_.sm\n"); | |
| 1211 load -force NRZn.dat; | |
| 1212 [xs,ys]=savgol(x,y,5,5,4); | |
| 1213 save -ascii NRZn.sm xs ys; | |
| 1214 printf("NRZn.sm\n"); | |
| 1215 load -force NRcF.dat; | |
| 1216 [xs,ys]=savgol(x,y,5,5,4); | |
| 1217 save -ascii NRcF.sm xs ys; | |
| 1218 printf("NRcF.sm\n"); | |
| 1219 load -force NRcP.dat; | |
| 1220 [xs,ys]=savgol(x,y,5,5,4); | |
| 1221 save -ascii NRcP.sm xs ys; | |
| 1222 printf("NRcP.sm\n"); | |
| 1223 load -force OABr.dat; | |
| 1224 [xs,ys]=savgol(x,y,5,5,4); | |
| 1225 save -ascii OABr.sm xs ys; | |
| 1226 printf("OABr.sm\n"); | |
| 1227 load -force OAC0.dat; | |
| 1228 [xs,ys]=savgol(x,y,5,5,4); | |
| 1229 save -ascii OAC0.sm xs ys; | |
| 1230 printf("OAC0.sm\n"); | |
| 1231 load -force OAC3.dat; | |
| 1232 [xs,ys]=savgol(x,y,5,5,4); | |
| 1233 save -ascii OAC3.sm xs ys; | |
| 1234 printf("OAC3.sm\n"); | |
| 1235 load -force OACF.dat; | |
| 1236 [xs,ys]=savgol(x,y,5,5,4); | |
| 1237 save -ascii OACF.sm xs ys; | |
| 1238 printf("OACF.sm\n"); | |
| 1239 load -force OACL.dat; | |
| 1240 [xs,ys]=savgol(x,y,5,5,4); | |
| 1241 save -ascii OACL.sm xs ys; | |
| 1242 printf("OACL.sm\n"); | |
| 1243 load -force OACN.dat; | |
| 1244 [xs,ys]=savgol(x,y,5,5,4); | |
| 1245 save -ascii OACN.sm xs ys; | |
| 1246 printf("OACN.sm\n"); | |
| 1247 load -force OACO.dat; | |
| 1248 [xs,ys]=savgol(x,y,5,5,4); | |
| 1249 save -ascii OACO.sm xs ys; | |
| 1250 printf("OACO.sm\n"); | |
| 1251 load -force OACP.dat; | |
| 1252 [xs,ys]=savgol(x,y,5,5,4); | |
| 1253 save -ascii OACP.sm xs ys; | |
| 1254 printf("OACP.sm\n"); | |
| 1255 load -force OACW.dat; | |
| 1256 [xs,ys]=savgol(x,y,5,5,4); | |
| 1257 save -ascii OACW.sm xs ys; | |
| 1258 printf("OACW.sm\n"); | |
| 1259 load -force OAF_.dat; | |
| 1260 [xs,ys]=savgol(x,y,5,5,4); | |
| 1261 save -ascii OAF_.sm xs ys; | |
| 1262 printf("OAF_.sm\n"); | |
| 1263 load -force OAFe.dat; | |
| 1264 [xs,ys]=savgol(x,y,5,5,4); | |
| 1265 save -ascii OAFe.sm xs ys; | |
| 1266 printf("OAFe.sm\n"); | |
| 1267 load -force OAHL.dat; | |
| 1268 [xs,ys]=savgol(x,y,5,5,4); | |
| 1269 save -ascii OAHL.sm xs ys; | |
| 1270 printf("OAHL.sm\n"); | |
| 1271 load -force OAMg.dat; | |
| 1272 [xs,ys]=savgol(x,y,5,5,4); | |
| 1273 save -ascii OAMg.sm xs ys; | |
| 1274 printf("OAMg.sm\n"); | |
| 1275 load -force OAMn.dat; | |
| 1276 [xs,ys]=savgol(x,y,5,5,4); | |
| 1277 save -ascii OAMn.sm xs ys; | |
| 1278 printf("OAMn.sm\n"); | |
| 1279 load -force OAN0.dat; | |
| 1280 [xs,ys]=savgol(x,y,5,5,4); | |
| 1281 save -ascii OAN0.sm xs ys; | |
| 1282 printf("OAN0.sm\n"); | |
| 1283 load -force OANA.dat; | |
| 1284 [xs,ys]=savgol(x,y,5,5,4); | |
| 1285 save -ascii OANA.sm xs ys; | |
| 1286 printf("OANA.sm\n"); | |
| 1287 load -force OANC.dat; | |
| 1288 [xs,ys]=savgol(x,y,5,5,4); | |
| 1289 save -ascii OANC.sm xs ys; | |
| 1290 printf("OANC.sm\n"); | |
| 1291 load -force OAND.dat; | |
| 1292 [xs,ys]=savgol(x,y,5,5,4); | |
| 1293 save -ascii OAND.sm xs ys; | |
| 1294 printf("OAND.sm\n"); | |
| 1295 load -force OANP.dat; | |
| 1296 [xs,ys]=savgol(x,y,5,5,4); | |
| 1297 save -ascii OANP.sm xs ys; | |
| 1298 printf("OANP.sm\n"); | |
| 1299 load -force OANR.dat; | |
| 1300 [xs,ys]=savgol(x,y,5,5,4); | |
| 1301 save -ascii OANR.sm xs ys; | |
| 1302 printf("OANR.sm\n"); | |
| 1303 load -force OANS.dat; | |
| 1304 [xs,ys]=savgol(x,y,5,5,4); | |
| 1305 save -ascii OANS.sm xs ys; | |
| 1306 printf("OANS.sm\n"); | |
| 1307 load -force OAOA.dat; | |
| 1308 [xs,ys]=savgol(x,y,5,5,4); | |
| 1309 save -ascii OAOA.sm xs ys; | |
| 1310 printf("OAOA.sm\n"); | |
| 1311 load -force OAOC.dat; | |
| 1312 [xs,ys]=savgol(x,y,5,5,4); | |
| 1313 save -ascii OAOC.sm xs ys; | |
| 1314 printf("OAOC.sm\n"); | |
| 1315 load -force OAOD.dat; | |
| 1316 [xs,ys]=savgol(x,y,5,5,4); | |
| 1317 save -ascii OAOD.sm xs ys; | |
| 1318 printf("OAOD.sm\n"); | |
| 1319 load -force OAOE.dat; | |
| 1320 [xs,ys]=savgol(x,y,5,5,4); | |
| 1321 save -ascii OAOE.sm xs ys; | |
| 1322 printf("OAOE.sm\n"); | |
| 1323 load -force OAOR.dat; | |
| 1324 [xs,ys]=savgol(x,y,5,5,4); | |
| 1325 save -ascii OAOR.sm xs ys; | |
| 1326 printf("OAOR.sm\n"); | |
| 1327 load -force OAOS.dat; | |
| 1328 [xs,ys]=savgol(x,y,5,5,4); | |
| 1329 save -ascii OAOS.sm xs ys; | |
| 1330 printf("OAOS.sm\n"); | |
| 1331 load -force OAP_.dat; | |
| 1332 [xs,ys]=savgol(x,y,5,5,4); | |
| 1333 save -ascii OAP_.sm xs ys; | |
| 1334 printf("OAP_.sm\n"); | |
| 1335 load -force OASA.dat; | |
| 1336 [xs,ys]=savgol(x,y,5,5,4); | |
| 1337 save -ascii OASA.sm xs ys; | |
| 1338 printf("OASA.sm\n"); | |
| 1339 load -force OASD.dat; | |
| 1340 [xs,ys]=savgol(x,y,5,5,4); | |
| 1341 save -ascii OASD.sm xs ys; | |
| 1342 printf("OASD.sm\n"); | |
| 1343 load -force OAV_.dat; | |
| 1344 [xs,ys]=savgol(x,y,5,5,4); | |
| 1345 save -ascii OAV_.sm xs ys; | |
| 1346 printf("OAV_.sm\n"); | |
| 1347 load -force OAZn.dat; | |
| 1348 [xs,ys]=savgol(x,y,5,5,4); | |
| 1349 save -ascii OAZn.sm xs ys; | |
| 1350 printf("OAZn.sm\n"); | |
| 1351 load -force OAcF.dat; | |
| 1352 [xs,ys]=savgol(x,y,5,5,4); | |
| 1353 save -ascii OAcF.sm xs ys; | |
| 1354 printf("OAcF.sm\n"); | |
| 1355 load -force OAcP.dat; | |
| 1356 [xs,ys]=savgol(x,y,5,5,4); | |
| 1357 save -ascii OAcP.sm xs ys; | |
| 1358 printf("OAcP.sm\n"); | |
| 1359 load -force OCBr.dat; | |
| 1360 [xs,ys]=savgol(x,y,5,5,4); | |
| 1361 save -ascii OCBr.sm xs ys; | |
| 1362 printf("OCBr.sm\n"); | |
| 1363 load -force OCC0.dat; | |
| 1364 [xs,ys]=savgol(x,y,5,5,4); | |
| 1365 save -ascii OCC0.sm xs ys; | |
| 1366 printf("OCC0.sm\n"); | |
| 1367 load -force OCC3.dat; | |
| 1368 [xs,ys]=savgol(x,y,5,5,4); | |
| 1369 save -ascii OCC3.sm xs ys; | |
| 1370 printf("OCC3.sm\n"); | |
| 1371 load -force OCCF.dat; | |
| 1372 [xs,ys]=savgol(x,y,5,5,4); | |
| 1373 save -ascii OCCF.sm xs ys; | |
| 1374 printf("OCCF.sm\n"); | |
| 1375 load -force OCCL.dat; | |
| 1376 [xs,ys]=savgol(x,y,5,5,4); | |
| 1377 save -ascii OCCL.sm xs ys; | |
| 1378 printf("OCCL.sm\n"); | |
| 1379 load -force OCCN.dat; | |
| 1380 [xs,ys]=savgol(x,y,5,5,4); | |
| 1381 save -ascii OCCN.sm xs ys; | |
| 1382 printf("OCCN.sm\n"); | |
| 1383 load -force OCCO.dat; | |
| 1384 [xs,ys]=savgol(x,y,5,5,4); | |
| 1385 save -ascii OCCO.sm xs ys; | |
| 1386 printf("OCCO.sm\n"); | |
| 1387 load -force OCCP.dat; | |
| 1388 [xs,ys]=savgol(x,y,5,5,4); | |
| 1389 save -ascii OCCP.sm xs ys; | |
| 1390 printf("OCCP.sm\n"); | |
| 1391 load -force OCCW.dat; | |
| 1392 [xs,ys]=savgol(x,y,5,5,4); | |
| 1393 save -ascii OCCW.sm xs ys; | |
| 1394 printf("OCCW.sm\n"); | |
| 1395 load -force OCF_.dat; | |
| 1396 [xs,ys]=savgol(x,y,5,5,4); | |
| 1397 save -ascii OCF_.sm xs ys; | |
| 1398 printf("OCF_.sm\n"); | |
| 1399 load -force OCFe.dat; | |
| 1400 [xs,ys]=savgol(x,y,5,5,4); | |
| 1401 save -ascii OCFe.sm xs ys; | |
| 1402 printf("OCFe.sm\n"); | |
| 1403 load -force OCHL.dat; | |
| 1404 [xs,ys]=savgol(x,y,5,5,4); | |
| 1405 save -ascii OCHL.sm xs ys; | |
| 1406 printf("OCHL.sm\n"); | |
| 1407 load -force OCMg.dat; | |
| 1408 [xs,ys]=savgol(x,y,5,5,4); | |
| 1409 save -ascii OCMg.sm xs ys; | |
| 1410 printf("OCMg.sm\n"); | |
| 1411 load -force OCMn.dat; | |
| 1412 [xs,ys]=savgol(x,y,5,5,4); | |
| 1413 save -ascii OCMn.sm xs ys; | |
| 1414 printf("OCMn.sm\n"); | |
| 1415 load -force OCN0.dat; | |
| 1416 [xs,ys]=savgol(x,y,5,5,4); | |
| 1417 save -ascii OCN0.sm xs ys; | |
| 1418 printf("OCN0.sm\n"); | |
| 1419 load -force OCNA.dat; | |
| 1420 [xs,ys]=savgol(x,y,5,5,4); | |
| 1421 save -ascii OCNA.sm xs ys; | |
| 1422 printf("OCNA.sm\n"); | |
| 1423 load -force OCNC.dat; | |
| 1424 [xs,ys]=savgol(x,y,5,5,4); | |
| 1425 save -ascii OCNC.sm xs ys; | |
| 1426 printf("OCNC.sm\n"); | |
| 1427 load -force OCND.dat; | |
| 1428 [xs,ys]=savgol(x,y,5,5,4); | |
| 1429 save -ascii OCND.sm xs ys; | |
| 1430 printf("OCND.sm\n"); | |
| 1431 load -force OCNP.dat; | |
| 1432 [xs,ys]=savgol(x,y,5,5,4); | |
| 1433 save -ascii OCNP.sm xs ys; | |
| 1434 printf("OCNP.sm\n"); | |
| 1435 load -force OCNR.dat; | |
| 1436 [xs,ys]=savgol(x,y,5,5,4); | |
| 1437 save -ascii OCNR.sm xs ys; | |
| 1438 printf("OCNR.sm\n"); | |
| 1439 load -force OCNS.dat; | |
| 1440 [xs,ys]=savgol(x,y,5,5,4); | |
| 1441 save -ascii OCNS.sm xs ys; | |
| 1442 printf("OCNS.sm\n"); | |
| 1443 load -force OCOA.dat; | |
| 1444 [xs,ys]=savgol(x,y,5,5,4); | |
| 1445 save -ascii OCOA.sm xs ys; | |
| 1446 printf("OCOA.sm\n"); | |
| 1447 load -force OCOC.dat; | |
| 1448 [xs,ys]=savgol(x,y,5,5,4); | |
| 1449 save -ascii OCOC.sm xs ys; | |
| 1450 printf("OCOC.sm\n"); | |
| 1451 load -force OCOD.dat; | |
| 1452 [xs,ys]=savgol(x,y,5,5,4); | |
| 1453 save -ascii OCOD.sm xs ys; | |
| 1454 printf("OCOD.sm\n"); | |
| 1455 load -force OCOE.dat; | |
| 1456 [xs,ys]=savgol(x,y,5,5,4); | |
| 1457 save -ascii OCOE.sm xs ys; | |
| 1458 printf("OCOE.sm\n"); | |
| 1459 load -force OCOR.dat; | |
| 1460 [xs,ys]=savgol(x,y,5,5,4); | |
| 1461 save -ascii OCOR.sm xs ys; | |
| 1462 printf("OCOR.sm\n"); | |
| 1463 load -force OCOS.dat; | |
| 1464 [xs,ys]=savgol(x,y,5,5,4); | |
| 1465 save -ascii OCOS.sm xs ys; | |
| 1466 printf("OCOS.sm\n"); | |
| 1467 load -force OCP_.dat; | |
| 1468 [xs,ys]=savgol(x,y,5,5,4); | |
| 1469 save -ascii OCP_.sm xs ys; | |
| 1470 printf("OCP_.sm\n"); | |
| 1471 load -force OCSA.dat; | |
| 1472 [xs,ys]=savgol(x,y,5,5,4); | |
| 1473 save -ascii OCSA.sm xs ys; | |
| 1474 printf("OCSA.sm\n"); | |
| 1475 load -force OCSD.dat; | |
| 1476 [xs,ys]=savgol(x,y,5,5,4); | |
| 1477 save -ascii OCSD.sm xs ys; | |
| 1478 printf("OCSD.sm\n"); | |
| 1479 load -force OCV_.dat; | |
| 1480 [xs,ys]=savgol(x,y,5,5,4); | |
| 1481 save -ascii OCV_.sm xs ys; | |
| 1482 printf("OCV_.sm\n"); | |
| 1483 load -force OCZn.dat; | |
| 1484 [xs,ys]=savgol(x,y,5,5,4); | |
| 1485 save -ascii OCZn.sm xs ys; | |
| 1486 printf("OCZn.sm\n"); | |
| 1487 load -force OCcF.dat; | |
| 1488 [xs,ys]=savgol(x,y,5,5,4); | |
| 1489 save -ascii OCcF.sm xs ys; | |
| 1490 printf("OCcF.sm\n"); | |
| 1491 load -force OCcP.dat; | |
| 1492 [xs,ys]=savgol(x,y,5,5,4); | |
| 1493 save -ascii OCcP.sm xs ys; | |
| 1494 printf("OCcP.sm\n"); | |
| 1495 load -force ODBr.dat; | |
| 1496 [xs,ys]=savgol(x,y,5,5,4); | |
| 1497 save -ascii ODBr.sm xs ys; | |
| 1498 printf("ODBr.sm\n"); | |
| 1499 load -force ODC0.dat; | |
| 1500 [xs,ys]=savgol(x,y,5,5,4); | |
| 1501 save -ascii ODC0.sm xs ys; | |
| 1502 printf("ODC0.sm\n"); | |
| 1503 load -force ODC3.dat; | |
| 1504 [xs,ys]=savgol(x,y,5,5,4); | |
| 1505 save -ascii ODC3.sm xs ys; | |
| 1506 printf("ODC3.sm\n"); | |
| 1507 load -force ODCF.dat; | |
| 1508 [xs,ys]=savgol(x,y,5,5,4); | |
| 1509 save -ascii ODCF.sm xs ys; | |
| 1510 printf("ODCF.sm\n"); | |
| 1511 load -force ODCL.dat; | |
| 1512 [xs,ys]=savgol(x,y,5,5,4); | |
| 1513 save -ascii ODCL.sm xs ys; | |
| 1514 printf("ODCL.sm\n"); | |
| 1515 load -force ODCN.dat; | |
| 1516 [xs,ys]=savgol(x,y,5,5,4); | |
| 1517 save -ascii ODCN.sm xs ys; | |
| 1518 printf("ODCN.sm\n"); | |
| 1519 load -force ODCO.dat; | |
| 1520 [xs,ys]=savgol(x,y,5,5,4); | |
| 1521 save -ascii ODCO.sm xs ys; | |
| 1522 printf("ODCO.sm\n"); | |
| 1523 load -force ODCP.dat; | |
| 1524 [xs,ys]=savgol(x,y,5,5,4); | |
| 1525 save -ascii ODCP.sm xs ys; | |
| 1526 printf("ODCP.sm\n"); | |
| 1527 load -force ODCW.dat; | |
| 1528 [xs,ys]=savgol(x,y,5,5,4); | |
| 1529 save -ascii ODCW.sm xs ys; | |
| 1530 printf("ODCW.sm\n"); | |
| 1531 load -force ODF_.dat; | |
| 1532 [xs,ys]=savgol(x,y,5,5,4); | |
| 1533 save -ascii ODF_.sm xs ys; | |
| 1534 printf("ODF_.sm\n"); | |
| 1535 load -force ODFe.dat; | |
| 1536 [xs,ys]=savgol(x,y,5,5,4); | |
| 1537 save -ascii ODFe.sm xs ys; | |
| 1538 printf("ODFe.sm\n"); | |
| 1539 load -force ODHL.dat; | |
| 1540 [xs,ys]=savgol(x,y,5,5,4); | |
| 1541 save -ascii ODHL.sm xs ys; | |
| 1542 printf("ODHL.sm\n"); | |
| 1543 load -force ODMg.dat; | |
| 1544 [xs,ys]=savgol(x,y,5,5,4); | |
| 1545 save -ascii ODMg.sm xs ys; | |
| 1546 printf("ODMg.sm\n"); | |
| 1547 load -force ODMn.dat; | |
| 1548 [xs,ys]=savgol(x,y,5,5,4); | |
| 1549 save -ascii ODMn.sm xs ys; | |
| 1550 printf("ODMn.sm\n"); | |
| 1551 load -force ODN0.dat; | |
| 1552 [xs,ys]=savgol(x,y,5,5,4); | |
| 1553 save -ascii ODN0.sm xs ys; | |
| 1554 printf("ODN0.sm\n"); | |
| 1555 load -force ODNA.dat; | |
| 1556 [xs,ys]=savgol(x,y,5,5,4); | |
| 1557 save -ascii ODNA.sm xs ys; | |
| 1558 printf("ODNA.sm\n"); | |
| 1559 load -force ODNC.dat; | |
| 1560 [xs,ys]=savgol(x,y,5,5,4); | |
| 1561 save -ascii ODNC.sm xs ys; | |
| 1562 printf("ODNC.sm\n"); | |
| 1563 load -force ODND.dat; | |
| 1564 [xs,ys]=savgol(x,y,5,5,4); | |
| 1565 save -ascii ODND.sm xs ys; | |
| 1566 printf("ODND.sm\n"); | |
| 1567 load -force ODNP.dat; | |
| 1568 [xs,ys]=savgol(x,y,5,5,4); | |
| 1569 save -ascii ODNP.sm xs ys; | |
| 1570 printf("ODNP.sm\n"); | |
| 1571 load -force ODNR.dat; | |
| 1572 [xs,ys]=savgol(x,y,5,5,4); | |
| 1573 save -ascii ODNR.sm xs ys; | |
| 1574 printf("ODNR.sm\n"); | |
| 1575 load -force ODNS.dat; | |
| 1576 [xs,ys]=savgol(x,y,5,5,4); | |
| 1577 save -ascii ODNS.sm xs ys; | |
| 1578 printf("ODNS.sm\n"); | |
| 1579 load -force ODOA.dat; | |
| 1580 [xs,ys]=savgol(x,y,5,5,4); | |
| 1581 save -ascii ODOA.sm xs ys; | |
| 1582 printf("ODOA.sm\n"); | |
| 1583 load -force ODOC.dat; | |
| 1584 [xs,ys]=savgol(x,y,5,5,4); | |
| 1585 save -ascii ODOC.sm xs ys; | |
| 1586 printf("ODOC.sm\n"); | |
| 1587 load -force ODOD.dat; | |
| 1588 [xs,ys]=savgol(x,y,5,5,4); | |
| 1589 save -ascii ODOD.sm xs ys; | |
| 1590 printf("ODOD.sm\n"); | |
| 1591 load -force ODOE.dat; | |
| 1592 [xs,ys]=savgol(x,y,5,5,4); | |
| 1593 save -ascii ODOE.sm xs ys; | |
| 1594 printf("ODOE.sm\n"); | |
| 1595 load -force ODOR.dat; | |
| 1596 [xs,ys]=savgol(x,y,5,5,4); | |
| 1597 save -ascii ODOR.sm xs ys; | |
| 1598 printf("ODOR.sm\n"); | |
| 1599 load -force ODOS.dat; | |
| 1600 [xs,ys]=savgol(x,y,5,5,4); | |
| 1601 save -ascii ODOS.sm xs ys; | |
| 1602 printf("ODOS.sm\n"); | |
| 1603 load -force ODP_.dat; | |
| 1604 [xs,ys]=savgol(x,y,5,5,4); | |
| 1605 save -ascii ODP_.sm xs ys; | |
| 1606 printf("ODP_.sm\n"); | |
| 1607 load -force ODSA.dat; | |
| 1608 [xs,ys]=savgol(x,y,5,5,4); | |
| 1609 save -ascii ODSA.sm xs ys; | |
| 1610 printf("ODSA.sm\n"); | |
| 1611 load -force ODSD.dat; | |
| 1612 [xs,ys]=savgol(x,y,5,5,4); | |
| 1613 save -ascii ODSD.sm xs ys; | |
| 1614 printf("ODSD.sm\n"); | |
| 1615 load -force ODV_.dat; | |
| 1616 [xs,ys]=savgol(x,y,5,5,4); | |
| 1617 save -ascii ODV_.sm xs ys; | |
| 1618 printf("ODV_.sm\n"); | |
| 1619 load -force ODZn.dat; | |
| 1620 [xs,ys]=savgol(x,y,5,5,4); | |
| 1621 save -ascii ODZn.sm xs ys; | |
| 1622 printf("ODZn.sm\n"); | |
| 1623 load -force ODcF.dat; | |
| 1624 [xs,ys]=savgol(x,y,5,5,4); | |
| 1625 save -ascii ODcF.sm xs ys; | |
| 1626 printf("ODcF.sm\n"); | |
| 1627 load -force ODcP.dat; | |
| 1628 [xs,ys]=savgol(x,y,5,5,4); | |
| 1629 save -ascii ODcP.sm xs ys; | |
| 1630 printf("ODcP.sm\n"); | |
| 1631 load -force OWBr.dat; | |
| 1632 [xs,ys]=savgol(x,y,5,5,4); | |
| 1633 save -ascii OWBr.sm xs ys; | |
| 1634 printf("OWBr.sm\n"); | |
| 1635 load -force OWC0.dat; | |
| 1636 [xs,ys]=savgol(x,y,5,5,4); | |
| 1637 save -ascii OWC0.sm xs ys; | |
| 1638 printf("OWC0.sm\n"); | |
| 1639 load -force OWC3.dat; | |
| 1640 [xs,ys]=savgol(x,y,5,5,4); | |
| 1641 save -ascii OWC3.sm xs ys; | |
| 1642 printf("OWC3.sm\n"); | |
| 1643 load -force OWCF.dat; | |
| 1644 [xs,ys]=savgol(x,y,5,5,4); | |
| 1645 save -ascii OWCF.sm xs ys; | |
| 1646 printf("OWCF.sm\n"); | |
| 1647 load -force OWCL.dat; | |
| 1648 [xs,ys]=savgol(x,y,5,5,4); | |
| 1649 save -ascii OWCL.sm xs ys; | |
| 1650 printf("OWCL.sm\n"); | |
| 1651 load -force OWCN.dat; | |
| 1652 [xs,ys]=savgol(x,y,5,5,4); | |
| 1653 save -ascii OWCN.sm xs ys; | |
| 1654 printf("OWCN.sm\n"); | |
| 1655 load -force OWCO.dat; | |
| 1656 [xs,ys]=savgol(x,y,5,5,4); | |
| 1657 save -ascii OWCO.sm xs ys; | |
| 1658 printf("OWCO.sm\n"); | |
| 1659 load -force OWCP.dat; | |
| 1660 [xs,ys]=savgol(x,y,5,5,4); | |
| 1661 save -ascii OWCP.sm xs ys; | |
| 1662 printf("OWCP.sm\n"); | |
| 1663 load -force OWCW.dat; | |
| 1664 [xs,ys]=savgol(x,y,5,5,4); | |
| 1665 save -ascii OWCW.sm xs ys; | |
| 1666 printf("OWCW.sm\n"); | |
| 1667 load -force OWF_.dat; | |
| 1668 [xs,ys]=savgol(x,y,5,5,4); | |
| 1669 save -ascii OWF_.sm xs ys; | |
| 1670 printf("OWF_.sm\n"); | |
| 1671 load -force OWFe.dat; | |
| 1672 [xs,ys]=savgol(x,y,5,5,4); | |
| 1673 save -ascii OWFe.sm xs ys; | |
| 1674 printf("OWFe.sm\n"); | |
| 1675 load -force OWHL.dat; | |
| 1676 [xs,ys]=savgol(x,y,5,5,4); | |
| 1677 save -ascii OWHL.sm xs ys; | |
| 1678 printf("OWHL.sm\n"); | |
| 1679 load -force OWMg.dat; | |
| 1680 [xs,ys]=savgol(x,y,5,5,4); | |
| 1681 save -ascii OWMg.sm xs ys; | |
| 1682 printf("OWMg.sm\n"); | |
| 1683 load -force OWMn.dat; | |
| 1684 [xs,ys]=savgol(x,y,5,5,4); | |
| 1685 save -ascii OWMn.sm xs ys; | |
| 1686 printf("OWMn.sm\n"); | |
| 1687 load -force OWN0.dat; | |
| 1688 [xs,ys]=savgol(x,y,5,5,4); | |
| 1689 save -ascii OWN0.sm xs ys; | |
| 1690 printf("OWN0.sm\n"); | |
| 1691 load -force OWNA.dat; | |
| 1692 [xs,ys]=savgol(x,y,5,5,4); | |
| 1693 save -ascii OWNA.sm xs ys; | |
| 1694 printf("OWNA.sm\n"); | |
| 1695 load -force OWNC.dat; | |
| 1696 [xs,ys]=savgol(x,y,5,5,4); | |
| 1697 save -ascii OWNC.sm xs ys; | |
| 1698 printf("OWNC.sm\n"); | |
| 1699 load -force OWND.dat; | |
| 1700 [xs,ys]=savgol(x,y,5,5,4); | |
| 1701 save -ascii OWND.sm xs ys; | |
| 1702 printf("OWND.sm\n"); | |
| 1703 load -force OWNP.dat; | |
| 1704 [xs,ys]=savgol(x,y,5,5,4); | |
| 1705 save -ascii OWNP.sm xs ys; | |
| 1706 printf("OWNP.sm\n"); | |
| 1707 load -force OWNR.dat; | |
| 1708 [xs,ys]=savgol(x,y,5,5,4); | |
| 1709 save -ascii OWNR.sm xs ys; | |
| 1710 printf("OWNR.sm\n"); | |
| 1711 load -force OWNS.dat; | |
| 1712 [xs,ys]=savgol(x,y,5,5,4); | |
| 1713 save -ascii OWNS.sm xs ys; | |
| 1714 printf("OWNS.sm\n"); | |
| 1715 load -force OWOA.dat; | |
| 1716 [xs,ys]=savgol(x,y,5,5,4); | |
| 1717 save -ascii OWOA.sm xs ys; | |
| 1718 printf("OWOA.sm\n"); | |
| 1719 load -force OWOC.dat; | |
| 1720 [xs,ys]=savgol(x,y,5,5,4); | |
| 1721 save -ascii OWOC.sm xs ys; | |
| 1722 printf("OWOC.sm\n"); | |
| 1723 load -force OWOD.dat; | |
| 1724 [xs,ys]=savgol(x,y,5,5,4); | |
| 1725 save -ascii OWOD.sm xs ys; | |
| 1726 printf("OWOD.sm\n"); | |
| 1727 load -force OWOE.dat; | |
| 1728 [xs,ys]=savgol(x,y,5,5,4); | |
| 1729 save -ascii OWOE.sm xs ys; | |
| 1730 printf("OWOE.sm\n"); | |
| 1731 load -force OWOR.dat; | |
| 1732 [xs,ys]=savgol(x,y,5,5,4); | |
| 1733 save -ascii OWOR.sm xs ys; | |
| 1734 printf("OWOR.sm\n"); | |
| 1735 load -force OWOS.dat; | |
| 1736 [xs,ys]=savgol(x,y,5,5,4); | |
| 1737 save -ascii OWOS.sm xs ys; | |
| 1738 printf("OWOS.sm\n"); | |
| 1739 load -force OWP_.dat; | |
| 1740 [xs,ys]=savgol(x,y,5,5,4); | |
| 1741 save -ascii OWP_.sm xs ys; | |
| 1742 printf("OWP_.sm\n"); | |
| 1743 load -force OWSA.dat; | |
| 1744 [xs,ys]=savgol(x,y,5,5,4); | |
| 1745 save -ascii OWSA.sm xs ys; | |
| 1746 printf("OWSA.sm\n"); | |
| 1747 load -force OWSD.dat; | |
| 1748 [xs,ys]=savgol(x,y,5,5,4); | |
| 1749 save -ascii OWSD.sm xs ys; | |
| 1750 printf("OWSD.sm\n"); | |
| 1751 load -force OWV_.dat; | |
| 1752 [xs,ys]=savgol(x,y,5,5,4); | |
| 1753 save -ascii OWV_.sm xs ys; | |
| 1754 printf("OWV_.sm\n"); | |
| 1755 load -force OWZn.dat; | |
| 1756 [xs,ys]=savgol(x,y,5,5,4); | |
| 1757 save -ascii OWZn.sm xs ys; | |
| 1758 printf("OWZn.sm\n"); | |
| 1759 load -force OWcF.dat; | |
| 1760 [xs,ys]=savgol(x,y,5,5,4); | |
| 1761 save -ascii OWcF.sm xs ys; | |
| 1762 printf("OWcF.sm\n"); | |
| 1763 load -force OWcP.dat; | |
| 1764 [xs,ys]=savgol(x,y,5,5,4); | |
| 1765 save -ascii OWcP.sm xs ys; | |
| 1766 printf("OWcP.sm\n"); | |
| 1767 load -force SABr.dat; | |
| 1768 [xs,ys]=savgol(x,y,5,5,4); | |
| 1769 save -ascii SABr.sm xs ys; | |
| 1770 printf("SABr.sm\n"); | |
| 1771 load -force SAC0.dat; | |
| 1772 [xs,ys]=savgol(x,y,5,5,4); | |
| 1773 save -ascii SAC0.sm xs ys; | |
| 1774 printf("SAC0.sm\n"); | |
| 1775 load -force SAC3.dat; | |
| 1776 [xs,ys]=savgol(x,y,5,5,4); | |
| 1777 save -ascii SAC3.sm xs ys; | |
| 1778 printf("SAC3.sm\n"); | |
| 1779 load -force SACF.dat; | |
| 1780 [xs,ys]=savgol(x,y,5,5,4); | |
| 1781 save -ascii SACF.sm xs ys; | |
| 1782 printf("SACF.sm\n"); | |
| 1783 load -force SACL.dat; | |
| 1784 [xs,ys]=savgol(x,y,5,5,4); | |
| 1785 save -ascii SACL.sm xs ys; | |
| 1786 printf("SACL.sm\n"); | |
| 1787 load -force SACN.dat; | |
| 1788 [xs,ys]=savgol(x,y,5,5,4); | |
| 1789 save -ascii SACN.sm xs ys; | |
| 1790 printf("SACN.sm\n"); | |
| 1791 load -force SACO.dat; | |
| 1792 [xs,ys]=savgol(x,y,5,5,4); | |
| 1793 save -ascii SACO.sm xs ys; | |
| 1794 printf("SACO.sm\n"); | |
| 1795 load -force SACP.dat; | |
| 1796 [xs,ys]=savgol(x,y,5,5,4); | |
| 1797 save -ascii SACP.sm xs ys; | |
| 1798 printf("SACP.sm\n"); | |
| 1799 load -force SACW.dat; | |
| 1800 [xs,ys]=savgol(x,y,5,5,4); | |
| 1801 save -ascii SACW.sm xs ys; | |
| 1802 printf("SACW.sm\n"); | |
| 1803 load -force SAF_.dat; | |
| 1804 [xs,ys]=savgol(x,y,5,5,4); | |
| 1805 save -ascii SAF_.sm xs ys; | |
| 1806 printf("SAF_.sm\n"); | |
| 1807 load -force SAFe.dat; | |
| 1808 [xs,ys]=savgol(x,y,5,5,4); | |
| 1809 save -ascii SAFe.sm xs ys; | |
| 1810 printf("SAFe.sm\n"); | |
| 1811 load -force SAHL.dat; | |
| 1812 [xs,ys]=savgol(x,y,5,5,4); | |
| 1813 save -ascii SAHL.sm xs ys; | |
| 1814 printf("SAHL.sm\n"); | |
| 1815 load -force SAMg.dat; | |
| 1816 [xs,ys]=savgol(x,y,5,5,4); | |
| 1817 save -ascii SAMg.sm xs ys; | |
| 1818 printf("SAMg.sm\n"); | |
| 1819 load -force SAMn.dat; | |
| 1820 [xs,ys]=savgol(x,y,5,5,4); | |
| 1821 save -ascii SAMn.sm xs ys; | |
| 1822 printf("SAMn.sm\n"); | |
| 1823 load -force SAN0.dat; | |
| 1824 [xs,ys]=savgol(x,y,5,5,4); | |
| 1825 save -ascii SAN0.sm xs ys; | |
| 1826 printf("SAN0.sm\n"); | |
| 1827 load -force SANA.dat; | |
| 1828 [xs,ys]=savgol(x,y,5,5,4); | |
| 1829 save -ascii SANA.sm xs ys; | |
| 1830 printf("SANA.sm\n"); | |
| 1831 load -force SANC.dat; | |
| 1832 [xs,ys]=savgol(x,y,5,5,4); | |
| 1833 save -ascii SANC.sm xs ys; | |
| 1834 printf("SANC.sm\n"); | |
| 1835 load -force SAND.dat; | |
| 1836 [xs,ys]=savgol(x,y,5,5,4); | |
| 1837 save -ascii SAND.sm xs ys; | |
| 1838 printf("SAND.sm\n"); | |
| 1839 load -force SANP.dat; | |
| 1840 [xs,ys]=savgol(x,y,5,5,4); | |
| 1841 save -ascii SANP.sm xs ys; | |
| 1842 printf("SANP.sm\n"); | |
| 1843 load -force SANR.dat; | |
| 1844 [xs,ys]=savgol(x,y,5,5,4); | |
| 1845 save -ascii SANR.sm xs ys; | |
| 1846 printf("SANR.sm\n"); | |
| 1847 load -force SANS.dat; | |
| 1848 [xs,ys]=savgol(x,y,5,5,4); | |
| 1849 save -ascii SANS.sm xs ys; | |
| 1850 printf("SANS.sm\n"); | |
| 1851 load -force SAOA.dat; | |
| 1852 [xs,ys]=savgol(x,y,5,5,4); | |
| 1853 save -ascii SAOA.sm xs ys; | |
| 1854 printf("SAOA.sm\n"); | |
| 1855 load -force SAOC.dat; | |
| 1856 [xs,ys]=savgol(x,y,5,5,4); | |
| 1857 save -ascii SAOC.sm xs ys; | |
| 1858 printf("SAOC.sm\n"); | |
| 1859 load -force SAOD.dat; | |
| 1860 [xs,ys]=savgol(x,y,5,5,4); | |
| 1861 save -ascii SAOD.sm xs ys; | |
| 1862 printf("SAOD.sm\n"); | |
| 1863 load -force SAOE.dat; | |
| 1864 [xs,ys]=savgol(x,y,5,5,4); | |
| 1865 save -ascii SAOE.sm xs ys; | |
| 1866 printf("SAOE.sm\n"); | |
| 1867 load -force SAOR.dat; | |
| 1868 [xs,ys]=savgol(x,y,5,5,4); | |
| 1869 save -ascii SAOR.sm xs ys; | |
| 1870 printf("SAOR.sm\n"); | |
| 1871 load -force SAOS.dat; | |
| 1872 [xs,ys]=savgol(x,y,5,5,4); | |
| 1873 save -ascii SAOS.sm xs ys; | |
| 1874 printf("SAOS.sm\n"); | |
| 1875 load -force SAP_.dat; | |
| 1876 [xs,ys]=savgol(x,y,5,5,4); | |
| 1877 save -ascii SAP_.sm xs ys; | |
| 1878 printf("SAP_.sm\n"); | |
| 1879 load -force SASA.dat; | |
| 1880 [xs,ys]=savgol(x,y,5,5,4); | |
| 1881 save -ascii SASA.sm xs ys; | |
| 1882 printf("SASA.sm\n"); | |
| 1883 load -force SASD.dat; | |
| 1884 [xs,ys]=savgol(x,y,5,5,4); | |
| 1885 save -ascii SASD.sm xs ys; | |
| 1886 printf("SASD.sm\n"); | |
| 1887 load -force SAV_.dat; | |
| 1888 [xs,ys]=savgol(x,y,5,5,4); | |
| 1889 save -ascii SAV_.sm xs ys; | |
| 1890 printf("SAV_.sm\n"); | |
| 1891 load -force SAZn.dat; | |
| 1892 [xs,ys]=savgol(x,y,5,5,4); | |
| 1893 save -ascii SAZn.sm xs ys; | |
| 1894 printf("SAZn.sm\n"); | |
| 1895 load -force SAcF.dat; | |
| 1896 [xs,ys]=savgol(x,y,5,5,4); | |
| 1897 save -ascii SAcF.sm xs ys; | |
| 1898 printf("SAcF.sm\n"); | |
| 1899 load -force SAcP.dat; | |
| 1900 [xs,ys]=savgol(x,y,5,5,4); | |
| 1901 save -ascii SAcP.sm xs ys; | |
| 1902 printf("SAcP.sm\n"); | |
| 1903 load -force SDBr.dat; | |
| 1904 [xs,ys]=savgol(x,y,5,5,4); | |
| 1905 save -ascii SDBr.sm xs ys; | |
| 1906 printf("SDBr.sm\n"); | |
| 1907 load -force SDC0.dat; | |
| 1908 [xs,ys]=savgol(x,y,5,5,4); | |
| 1909 save -ascii SDC0.sm xs ys; | |
| 1910 printf("SDC0.sm\n"); | |
| 1911 load -force SDC3.dat; | |
| 1912 [xs,ys]=savgol(x,y,5,5,4); | |
| 1913 save -ascii SDC3.sm xs ys; | |
| 1914 printf("SDC3.sm\n"); | |
| 1915 load -force SDCF.dat; | |
| 1916 [xs,ys]=savgol(x,y,5,5,4); | |
| 1917 save -ascii SDCF.sm xs ys; | |
| 1918 printf("SDCF.sm\n"); | |
| 1919 load -force SDCL.dat; | |
| 1920 [xs,ys]=savgol(x,y,5,5,4); | |
| 1921 save -ascii SDCL.sm xs ys; | |
| 1922 printf("SDCL.sm\n"); | |
| 1923 load -force SDCN.dat; | |
| 1924 [xs,ys]=savgol(x,y,5,5,4); | |
| 1925 save -ascii SDCN.sm xs ys; | |
| 1926 printf("SDCN.sm\n"); | |
| 1927 load -force SDCO.dat; | |
| 1928 [xs,ys]=savgol(x,y,5,5,4); | |
| 1929 save -ascii SDCO.sm xs ys; | |
| 1930 printf("SDCO.sm\n"); | |
| 1931 load -force SDCP.dat; | |
| 1932 [xs,ys]=savgol(x,y,5,5,4); | |
| 1933 save -ascii SDCP.sm xs ys; | |
| 1934 printf("SDCP.sm\n"); | |
| 1935 load -force SDCW.dat; | |
| 1936 [xs,ys]=savgol(x,y,5,5,4); | |
| 1937 save -ascii SDCW.sm xs ys; | |
| 1938 printf("SDCW.sm\n"); | |
| 1939 load -force SDF_.dat; | |
| 1940 [xs,ys]=savgol(x,y,5,5,4); | |
| 1941 save -ascii SDF_.sm xs ys; | |
| 1942 printf("SDF_.sm\n"); | |
| 1943 load -force SDFe.dat; | |
| 1944 [xs,ys]=savgol(x,y,5,5,4); | |
| 1945 save -ascii SDFe.sm xs ys; | |
| 1946 printf("SDFe.sm\n"); | |
| 1947 load -force SDHL.dat; | |
| 1948 [xs,ys]=savgol(x,y,5,5,4); | |
| 1949 save -ascii SDHL.sm xs ys; | |
| 1950 printf("SDHL.sm\n"); | |
| 1951 load -force SDMg.dat; | |
| 1952 [xs,ys]=savgol(x,y,5,5,4); | |
| 1953 save -ascii SDMg.sm xs ys; | |
| 1954 printf("SDMg.sm\n"); | |
| 1955 load -force SDMn.dat; | |
| 1956 [xs,ys]=savgol(x,y,5,5,4); | |
| 1957 save -ascii SDMn.sm xs ys; | |
| 1958 printf("SDMn.sm\n"); | |
| 1959 load -force SDN0.dat; | |
| 1960 [xs,ys]=savgol(x,y,5,5,4); | |
| 1961 save -ascii SDN0.sm xs ys; | |
| 1962 printf("SDN0.sm\n"); | |
| 1963 load -force SDNA.dat; | |
| 1964 [xs,ys]=savgol(x,y,5,5,4); | |
| 1965 save -ascii SDNA.sm xs ys; | |
| 1966 printf("SDNA.sm\n"); | |
| 1967 load -force SDNC.dat; | |
| 1968 [xs,ys]=savgol(x,y,5,5,4); | |
| 1969 save -ascii SDNC.sm xs ys; | |
| 1970 printf("SDNC.sm\n"); | |
| 1971 load -force SDND.dat; | |
| 1972 [xs,ys]=savgol(x,y,5,5,4); | |
| 1973 save -ascii SDND.sm xs ys; | |
| 1974 printf("SDND.sm\n"); | |
| 1975 load -force SDNP.dat; | |
| 1976 [xs,ys]=savgol(x,y,5,5,4); | |
| 1977 save -ascii SDNP.sm xs ys; | |
| 1978 printf("SDNP.sm\n"); | |
| 1979 load -force SDNR.dat; | |
| 1980 [xs,ys]=savgol(x,y,5,5,4); | |
| 1981 save -ascii SDNR.sm xs ys; | |
| 1982 printf("SDNR.sm\n"); | |
| 1983 load -force SDNS.dat; | |
| 1984 [xs,ys]=savgol(x,y,5,5,4); | |
| 1985 save -ascii SDNS.sm xs ys; | |
| 1986 printf("SDNS.sm\n"); | |
| 1987 load -force SDOA.dat; | |
| 1988 [xs,ys]=savgol(x,y,5,5,4); | |
| 1989 save -ascii SDOA.sm xs ys; | |
| 1990 printf("SDOA.sm\n"); | |
| 1991 load -force SDOC.dat; | |
| 1992 [xs,ys]=savgol(x,y,5,5,4); | |
| 1993 save -ascii SDOC.sm xs ys; | |
| 1994 printf("SDOC.sm\n"); | |
| 1995 load -force SDOD.dat; | |
| 1996 [xs,ys]=savgol(x,y,5,5,4); | |
| 1997 save -ascii SDOD.sm xs ys; | |
| 1998 printf("SDOD.sm\n"); | |
| 1999 load -force SDOE.dat; | |
| 2000 [xs,ys]=savgol(x,y,5,5,4); | |
| 2001 save -ascii SDOE.sm xs ys; | |
| 2002 printf("SDOE.sm\n"); | |
| 2003 load -force SDOR.dat; | |
| 2004 [xs,ys]=savgol(x,y,5,5,4); | |
| 2005 save -ascii SDOR.sm xs ys; | |
| 2006 printf("SDOR.sm\n"); | |
| 2007 load -force SDOS.dat; | |
| 2008 [xs,ys]=savgol(x,y,5,5,4); | |
| 2009 save -ascii SDOS.sm xs ys; | |
| 2010 printf("SDOS.sm\n"); | |
| 2011 load -force SDP_.dat; | |
| 2012 [xs,ys]=savgol(x,y,5,5,4); | |
| 2013 save -ascii SDP_.sm xs ys; | |
| 2014 printf("SDP_.sm\n"); | |
| 2015 load -force SDSA.dat; | |
| 2016 [xs,ys]=savgol(x,y,5,5,4); | |
| 2017 save -ascii SDSA.sm xs ys; | |
| 2018 printf("SDSA.sm\n"); | |
| 2019 load -force SDSD.dat; | |
| 2020 [xs,ys]=savgol(x,y,5,5,4); | |
| 2021 save -ascii SDSD.sm xs ys; | |
| 2022 printf("SDSD.sm\n"); | |
| 2023 load -force SDV_.dat; | |
| 2024 [xs,ys]=savgol(x,y,5,5,4); | |
| 2025 save -ascii SDV_.sm xs ys; | |
| 2026 printf("SDV_.sm\n"); | |
| 2027 load -force SDZn.dat; | |
| 2028 [xs,ys]=savgol(x,y,5,5,4); | |
| 2029 save -ascii SDZn.sm xs ys; | |
| 2030 printf("SDZn.sm\n"); | |
| 2031 load -force SDcF.dat; | |
| 2032 [xs,ys]=savgol(x,y,5,5,4); | |
| 2033 save -ascii SDcF.sm xs ys; | |
| 2034 printf("SDcF.sm\n"); | |
| 2035 load -force SDcP.dat; | |
| 2036 [xs,ys]=savgol(x,y,5,5,4); | |
| 2037 save -ascii SDcP.sm xs ys; | |
| 2038 printf("SDcP.sm\n"); | |
| 2039 load -force cFBr.dat; | |
| 2040 [xs,ys]=savgol(x,y,5,5,4); | |
| 2041 save -ascii cFBr.sm xs ys; | |
| 2042 printf("cFBr.sm\n"); | |
| 2043 load -force cFC0.dat; | |
| 2044 [xs,ys]=savgol(x,y,5,5,4); | |
| 2045 save -ascii cFC0.sm xs ys; | |
| 2046 printf("cFC0.sm\n"); | |
| 2047 load -force cFC3.dat; | |
| 2048 [xs,ys]=savgol(x,y,5,5,4); | |
| 2049 save -ascii cFC3.sm xs ys; | |
| 2050 printf("cFC3.sm\n"); | |
| 2051 load -force cFCF.dat; | |
| 2052 [xs,ys]=savgol(x,y,5,5,4); | |
| 2053 save -ascii cFCF.sm xs ys; | |
| 2054 printf("cFCF.sm\n"); | |
| 2055 load -force cFCL.dat; | |
| 2056 [xs,ys]=savgol(x,y,5,5,4); | |
| 2057 save -ascii cFCL.sm xs ys; | |
| 2058 printf("cFCL.sm\n"); | |
| 2059 load -force cFCN.dat; | |
| 2060 [xs,ys]=savgol(x,y,5,5,4); | |
| 2061 save -ascii cFCN.sm xs ys; | |
| 2062 printf("cFCN.sm\n"); | |
| 2063 load -force cFCO.dat; | |
| 2064 [xs,ys]=savgol(x,y,5,5,4); | |
| 2065 save -ascii cFCO.sm xs ys; | |
| 2066 printf("cFCO.sm\n"); | |
| 2067 load -force cFCP.dat; | |
| 2068 [xs,ys]=savgol(x,y,5,5,4); | |
| 2069 save -ascii cFCP.sm xs ys; | |
| 2070 printf("cFCP.sm\n"); | |
| 2071 load -force cFCW.dat; | |
| 2072 [xs,ys]=savgol(x,y,5,5,4); | |
| 2073 save -ascii cFCW.sm xs ys; | |
| 2074 printf("cFCW.sm\n"); | |
| 2075 load -force cFF_.dat; | |
| 2076 [xs,ys]=savgol(x,y,5,5,4); | |
| 2077 save -ascii cFF_.sm xs ys; | |
| 2078 printf("cFF_.sm\n"); | |
| 2079 load -force cFFe.dat; | |
| 2080 [xs,ys]=savgol(x,y,5,5,4); | |
| 2081 save -ascii cFFe.sm xs ys; | |
| 2082 printf("cFFe.sm\n"); | |
| 2083 load -force cFHL.dat; | |
| 2084 [xs,ys]=savgol(x,y,5,5,4); | |
| 2085 save -ascii cFHL.sm xs ys; | |
| 2086 printf("cFHL.sm\n"); | |
| 2087 load -force cFMg.dat; | |
| 2088 [xs,ys]=savgol(x,y,5,5,4); | |
| 2089 save -ascii cFMg.sm xs ys; | |
| 2090 printf("cFMg.sm\n"); | |
| 2091 load -force cFMn.dat; | |
| 2092 [xs,ys]=savgol(x,y,5,5,4); | |
| 2093 save -ascii cFMn.sm xs ys; | |
| 2094 printf("cFMn.sm\n"); | |
| 2095 load -force cFN0.dat; | |
| 2096 [xs,ys]=savgol(x,y,5,5,4); | |
| 2097 save -ascii cFN0.sm xs ys; | |
| 2098 printf("cFN0.sm\n"); | |
| 2099 load -force cFNA.dat; | |
| 2100 [xs,ys]=savgol(x,y,5,5,4); | |
| 2101 save -ascii cFNA.sm xs ys; | |
| 2102 printf("cFNA.sm\n"); | |
| 2103 load -force cFNC.dat; | |
| 2104 [xs,ys]=savgol(x,y,5,5,4); | |
| 2105 save -ascii cFNC.sm xs ys; | |
| 2106 printf("cFNC.sm\n"); | |
| 2107 load -force cFND.dat; | |
| 2108 [xs,ys]=savgol(x,y,5,5,4); | |
| 2109 save -ascii cFND.sm xs ys; | |
| 2110 printf("cFND.sm\n"); | |
| 2111 load -force cFNP.dat; | |
| 2112 [xs,ys]=savgol(x,y,5,5,4); | |
| 2113 save -ascii cFNP.sm xs ys; | |
| 2114 printf("cFNP.sm\n"); | |
| 2115 load -force cFNR.dat; | |
| 2116 [xs,ys]=savgol(x,y,5,5,4); | |
| 2117 save -ascii cFNR.sm xs ys; | |
| 2118 printf("cFNR.sm\n"); | |
| 2119 load -force cFNS.dat; | |
| 2120 [xs,ys]=savgol(x,y,5,5,4); | |
| 2121 save -ascii cFNS.sm xs ys; | |
| 2122 printf("cFNS.sm\n"); | |
| 2123 load -force cFOA.dat; | |
| 2124 [xs,ys]=savgol(x,y,5,5,4); | |
| 2125 save -ascii cFOA.sm xs ys; | |
| 2126 printf("cFOA.sm\n"); | |
| 2127 load -force cFOC.dat; | |
| 2128 [xs,ys]=savgol(x,y,5,5,4); | |
| 2129 save -ascii cFOC.sm xs ys; | |
| 2130 printf("cFOC.sm\n"); | |
| 2131 load -force cFOD.dat; | |
| 2132 [xs,ys]=savgol(x,y,5,5,4); | |
| 2133 save -ascii cFOD.sm xs ys; | |
| 2134 printf("cFOD.sm\n"); | |
| 2135 load -force cFOE.dat; | |
| 2136 [xs,ys]=savgol(x,y,5,5,4); | |
| 2137 save -ascii cFOE.sm xs ys; | |
| 2138 printf("cFOE.sm\n"); | |
| 2139 load -force cFOR.dat; | |
| 2140 [xs,ys]=savgol(x,y,5,5,4); | |
| 2141 save -ascii cFOR.sm xs ys; | |
| 2142 printf("cFOR.sm\n"); | |
| 2143 load -force cFOS.dat; | |
| 2144 [xs,ys]=savgol(x,y,5,5,4); | |
| 2145 save -ascii cFOS.sm xs ys; | |
| 2146 printf("cFOS.sm\n"); | |
| 2147 load -force cFP_.dat; | |
| 2148 [xs,ys]=savgol(x,y,5,5,4); | |
| 2149 save -ascii cFP_.sm xs ys; | |
| 2150 printf("cFP_.sm\n"); | |
| 2151 load -force cFSA.dat; | |
| 2152 [xs,ys]=savgol(x,y,5,5,4); | |
| 2153 save -ascii cFSA.sm xs ys; | |
| 2154 printf("cFSA.sm\n"); | |
| 2155 load -force cFSD.dat; | |
| 2156 [xs,ys]=savgol(x,y,5,5,4); | |
| 2157 save -ascii cFSD.sm xs ys; | |
| 2158 printf("cFSD.sm\n"); | |
| 2159 load -force cFV_.dat; | |
| 2160 [xs,ys]=savgol(x,y,5,5,4); | |
| 2161 save -ascii cFV_.sm xs ys; | |
| 2162 printf("cFV_.sm\n"); | |
| 2163 load -force cFZn.dat; | |
| 2164 [xs,ys]=savgol(x,y,5,5,4); | |
| 2165 save -ascii cFZn.sm xs ys; | |
| 2166 printf("cFZn.sm\n"); | |
| 2167 load -force cFcF.dat; | |
| 2168 [xs,ys]=savgol(x,y,5,5,4); | |
| 2169 save -ascii cFcF.sm xs ys; | |
| 2170 printf("cFcF.sm\n"); | |
| 2171 load -force cFcP.dat; | |
| 2172 [xs,ys]=savgol(x,y,5,5,4); | |
| 2173 save -ascii cFcP.sm xs ys; | |
| 2174 printf("cFcP.sm\n"); | |
| 2175 load -force cPBr.dat; | |
| 2176 [xs,ys]=savgol(x,y,5,5,4); | |
| 2177 save -ascii cPBr.sm xs ys; | |
| 2178 printf("cPBr.sm\n"); | |
| 2179 load -force cPC0.dat; | |
| 2180 [xs,ys]=savgol(x,y,5,5,4); | |
| 2181 save -ascii cPC0.sm xs ys; | |
| 2182 printf("cPC0.sm\n"); | |
| 2183 load -force cPC3.dat; | |
| 2184 [xs,ys]=savgol(x,y,5,5,4); | |
| 2185 save -ascii cPC3.sm xs ys; | |
| 2186 printf("cPC3.sm\n"); | |
| 2187 load -force cPCF.dat; | |
| 2188 [xs,ys]=savgol(x,y,5,5,4); | |
| 2189 save -ascii cPCF.sm xs ys; | |
| 2190 printf("cPCF.sm\n"); | |
| 2191 load -force cPCL.dat; | |
| 2192 [xs,ys]=savgol(x,y,5,5,4); | |
| 2193 save -ascii cPCL.sm xs ys; | |
| 2194 printf("cPCL.sm\n"); | |
| 2195 load -force cPCN.dat; | |
| 2196 [xs,ys]=savgol(x,y,5,5,4); | |
| 2197 save -ascii cPCN.sm xs ys; | |
| 2198 printf("cPCN.sm\n"); | |
| 2199 load -force cPCO.dat; | |
| 2200 [xs,ys]=savgol(x,y,5,5,4); | |
| 2201 save -ascii cPCO.sm xs ys; | |
| 2202 printf("cPCO.sm\n"); | |
| 2203 load -force cPCP.dat; | |
| 2204 [xs,ys]=savgol(x,y,5,5,4); | |
| 2205 save -ascii cPCP.sm xs ys; | |
| 2206 printf("cPCP.sm\n"); | |
| 2207 load -force cPCW.dat; | |
| 2208 [xs,ys]=savgol(x,y,5,5,4); | |
| 2209 save -ascii cPCW.sm xs ys; | |
| 2210 printf("cPCW.sm\n"); | |
| 2211 load -force cPF_.dat; | |
| 2212 [xs,ys]=savgol(x,y,5,5,4); | |
| 2213 save -ascii cPF_.sm xs ys; | |
| 2214 printf("cPF_.sm\n"); | |
| 2215 load -force cPFe.dat; | |
| 2216 [xs,ys]=savgol(x,y,5,5,4); | |
| 2217 save -ascii cPFe.sm xs ys; | |
| 2218 printf("cPFe.sm\n"); | |
| 2219 load -force cPHL.dat; | |
| 2220 [xs,ys]=savgol(x,y,5,5,4); | |
| 2221 save -ascii cPHL.sm xs ys; | |
| 2222 printf("cPHL.sm\n"); | |
| 2223 load -force cPMg.dat; | |
| 2224 [xs,ys]=savgol(x,y,5,5,4); | |
| 2225 save -ascii cPMg.sm xs ys; | |
| 2226 printf("cPMg.sm\n"); | |
| 2227 load -force cPMn.dat; | |
| 2228 [xs,ys]=savgol(x,y,5,5,4); | |
| 2229 save -ascii cPMn.sm xs ys; | |
| 2230 printf("cPMn.sm\n"); | |
| 2231 load -force cPN0.dat; | |
| 2232 [xs,ys]=savgol(x,y,5,5,4); | |
| 2233 save -ascii cPN0.sm xs ys; | |
| 2234 printf("cPN0.sm\n"); | |
| 2235 load -force cPNA.dat; | |
| 2236 [xs,ys]=savgol(x,y,5,5,4); | |
| 2237 save -ascii cPNA.sm xs ys; | |
| 2238 printf("cPNA.sm\n"); | |
| 2239 load -force cPNC.dat; | |
| 2240 [xs,ys]=savgol(x,y,5,5,4); | |
| 2241 save -ascii cPNC.sm xs ys; | |
| 2242 printf("cPNC.sm\n"); | |
| 2243 load -force cPND.dat; | |
| 2244 [xs,ys]=savgol(x,y,5,5,4); | |
| 2245 save -ascii cPND.sm xs ys; | |
| 2246 printf("cPND.sm\n"); | |
| 2247 load -force cPNP.dat; | |
| 2248 [xs,ys]=savgol(x,y,5,5,4); | |
| 2249 save -ascii cPNP.sm xs ys; | |
| 2250 printf("cPNP.sm\n"); | |
| 2251 load -force cPNR.dat; | |
| 2252 [xs,ys]=savgol(x,y,5,5,4); | |
| 2253 save -ascii cPNR.sm xs ys; | |
| 2254 printf("cPNR.sm\n"); | |
| 2255 load -force cPNS.dat; | |
| 2256 [xs,ys]=savgol(x,y,5,5,4); | |
| 2257 save -ascii cPNS.sm xs ys; | |
| 2258 printf("cPNS.sm\n"); | |
| 2259 load -force cPOA.dat; | |
| 2260 [xs,ys]=savgol(x,y,5,5,4); | |
| 2261 save -ascii cPOA.sm xs ys; | |
| 2262 printf("cPOA.sm\n"); | |
| 2263 load -force cPOC.dat; | |
| 2264 [xs,ys]=savgol(x,y,5,5,4); | |
| 2265 save -ascii cPOC.sm xs ys; | |
| 2266 printf("cPOC.sm\n"); | |
| 2267 load -force cPOD.dat; | |
| 2268 [xs,ys]=savgol(x,y,5,5,4); | |
| 2269 save -ascii cPOD.sm xs ys; | |
| 2270 printf("cPOD.sm\n"); | |
| 2271 load -force cPOE.dat; | |
| 2272 [xs,ys]=savgol(x,y,5,5,4); | |
| 2273 save -ascii cPOE.sm xs ys; | |
| 2274 printf("cPOE.sm\n"); | |
| 2275 load -force cPOR.dat; | |
| 2276 [xs,ys]=savgol(x,y,5,5,4); | |
| 2277 save -ascii cPOR.sm xs ys; | |
| 2278 printf("cPOR.sm\n"); | |
| 2279 load -force cPOS.dat; | |
| 2280 [xs,ys]=savgol(x,y,5,5,4); | |
| 2281 save -ascii cPOS.sm xs ys; | |
| 2282 printf("cPOS.sm\n"); | |
| 2283 load -force cPP_.dat; | |
| 2284 [xs,ys]=savgol(x,y,5,5,4); | |
| 2285 save -ascii cPP_.sm xs ys; | |
| 2286 printf("cPP_.sm\n"); | |
| 2287 load -force cPSA.dat; | |
| 2288 [xs,ys]=savgol(x,y,5,5,4); | |
| 2289 save -ascii cPSA.sm xs ys; | |
| 2290 printf("cPSA.sm\n"); | |
| 2291 load -force cPSD.dat; | |
| 2292 [xs,ys]=savgol(x,y,5,5,4); | |
| 2293 save -ascii cPSD.sm xs ys; | |
| 2294 printf("cPSD.sm\n"); | |
| 2295 load -force cPV_.dat; | |
| 2296 [xs,ys]=savgol(x,y,5,5,4); | |
| 2297 save -ascii cPV_.sm xs ys; | |
| 2298 printf("cPV_.sm\n"); | |
| 2299 load -force cPZn.dat; | |
| 2300 [xs,ys]=savgol(x,y,5,5,4); | |
| 2301 save -ascii cPZn.sm xs ys; | |
| 2302 printf("cPZn.sm\n"); | |
| 2303 load -force cPcF.dat; | |
| 2304 [xs,ys]=savgol(x,y,5,5,4); | |
| 2305 save -ascii cPcF.sm xs ys; | |
| 2306 printf("cPcF.sm\n"); | |
| 2307 load -force cPcP.dat; | |
| 2308 [xs,ys]=savgol(x,y,5,5,4); | |
| 2309 save -ascii cPcP.sm xs ys; | |
| 2310 printf("cPcP.sm\n"); |