lib/CXC/PDL/Bin1D.pd

filter: Statementstmt 76.9% 20 / 26 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 7 / 7 Podpod n/a totaltotal 81.8% 27 / 33 CC 1 SCAR 0.0
CC
1
Cov
77%
BEGIN
1.0
BEGIN
1.0
BEGIN
1.0
CRAP 1.0
« Bin1D.xs ↑ Summary
1 #!perl
2  
3 # --8<--8<--8<--8<--
4 #
5 # Copyright (C) 2014 Smithsonian Astrophysical Observatory
6 #
7 # This file is part of CXC::PDL::Bin1D
8 #
9 # CXC::PDL::Bin1D is free software: you can redistribute it and/or modify
10 # it under the terms of the GNU General Public License as published by
11 # the Free Software Foundation, either version 3 of the License, or
12 # (at your option) any later version.
13 #
14 # This program is distributed in the hope that it will be useful,
15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 # GNU General Public License for more details.
18 #
19 # You should have received a copy of the GNU General Public License
20 # along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #
22 # -->8-->8-->8-->8--
23  
24 use v5.10;
25  
26 use strict;
27 use warnings;
28 use version;
29  
30 use IO::File;
31 use File::Spec::Functions qw[ catfile ];
32  
33 use lib 'lib';
34  
35 use CXC::PDL::Bin1D::Utils '_bitflags';
36 use PDL ();
37 use PDL::Bad;
38  
39 use File::Basename qw[ fileparse ];
40  
41 # this file is executed directly by Perl, so $0 will be our filename,
42 # which allows us to find the parent directory.
43 use constant LIBDIR => ( fileparse( $0 ) )[1];
44  
45 use PDL::Types qw[ typefld ];
46  
47  
48 # later versions of PDL define index types:
49 # 'PDL_Indx' (as a C typedef) and 'indx' for signatures
50 # for backwards compatibility, support long as well as the others
51  
52 my ( $IndexParsType, $IndexCType ) = do {
53  
54 my $type = eval { typefld( 'PDL_IND', 'ctype' ); 1 } ? 'PDL_IND' : 'PDL_L';
55  
56 map { typefld( $type, $_ ) } qw( ppforcetype ctype );
57 };
58  
59 our $VERSION = '0.28';
60 pp_setversion( $VERSION );
61  
62 {
63 package CXC::PDL::Bin1D;
64  
65 use Text::Template::LocalVars;
66 use File::Spec::Functions qw[ catfile ];
67  
68 use Exporter 'import';
69 ## no critic (Modules::ProhibitAutomaticExportation)
70 our @EXPORT = qw< fill_in fill_in_string >;
71  
72 # this code must be compiled in the template variable package
73 sub init_fill_package {
74  
75 Text::Template::LocalVars->new(
76 type => 'string',
77 delimiters => [qw( <% %> )],
78 source => <<'EOS',
79 *fill_in = \&<% $PACKAGE %>::fill_in;
80 *fill_in_string = \&<% $PACKAGE %>::fill_in_string;
81 EOS
82 )->fill_in( hash => { PACKAGE => __PACKAGE__ } );
83  
84 }
85  
86 # fill in templates using Text::Template::LocalVars. This routine
87 # is also imported into all of the template fragments.
88 sub fill_in {
89  
90 my ( $type, $src ) = ( shift, shift );
91  
92 $src = catfile( ::LIBDIR, $src )
93 if lc $type eq 'file' && $src !~ m{^[./]}s;
94  
95 my $tpl = Text::Template::LocalVars->new(
96 type => $type,
97 source => $src,
98 delimiters => [qw( <% %> )],
99 broken => sub { my %args = @_; die $args{error}; },
100 prepend => init_fill_package(),
101 );
102  
103 die $Text::Template::ERROR unless defined $tpl;
104  
105 # by default, localize the variable packages, and insert the last one
106 # in the call chain if not explicitly specified.
107 my %args = ( localize => 1, trackpkgvars => 1, @_ );
108  
109 my $hash = $args{hash} ||= {};
110 $hash->{PDL_Indx} = $IndexCType;
111  
112 my $txt;
113 eval {
114 $txt = $tpl->fill_in( %args );
115 die unless defined $txt;
116 1;
117 }
118 or die defined $Text::Template::LocalVars::ERROR
119 ? $Text::Template::LocalVars::ERROR
120 : $@;
121  
122 return $txt;
123 }
124  
125 sub fill_in_string {
126  
127 unshift @_, 'string';
128 goto \&fill_in;
129  
130 }
131  
132 }
133  
134 CXC::PDL::Bin1D->import;
135  
136  
137 my %CONSTANTS = (
138 BIN_ARG => {
139 _bitflags( qw[
140 BIN_ARG_HAVE_ERROR
141 BIN_ARG_HAVE_WEIGHT
142 BIN_ARG_SET_BAD
143 BIN_ARG_FOLD
144 BIN_ARG_HAVE_WIDTH
145 BIN_ARG_ERROR_SDEV
146 BIN_ARG_ERROR_POISSON
147 BIN_ARG_ERROR_RSS
148 BIN_ARG_HAVE_SIGNAL
149 BIN_ARG_SAVE_OOB_START_END
150 BIN_ARG_SAVE_OOB_START_NBINS
151 BIN_ARG_SAVE_OOB_END
152 BIN_ARG_SAVE_OOB_NBINS
153 BIN_ARG_WANT_EXTREMA
154 BIN_ARG_WANT_SUM_WEIGHT
155 BIN_ARG_WANT_SUM_WEIGHT2
156 ],
157 ),
158 },
159 BIN_RC => {
160 _bitflags( qw[
161 BIN_RC_OK
162 BIN_RC_GEWMAX
163 BIN_RC_GENMAX
164 BIN_RC_FOLDED
165 BIN_RC_GTMINSN
166 ],
167 ),
168  
169 },
170 );
171  
172 {
173 $CONSTANTS{BIN_ARG}{BIN_ARG_SAVE_OOB} = 0;
174 $CONSTANTS{BIN_ARG}{BIN_ARG_SAVE_OOB} |= $CONSTANTS{BIN_ARG}{$_}
175 for grep { /BIN_ARG_SAVE_OOB/ } keys %{ $CONSTANTS{BIN_ARG} };
176  
177 $CONSTANTS{BIN_ARG}{BIN_ARG_SHIFT_IMIN} = $CONSTANTS{BIN_ARG}{BIN_ARG_SAVE_OOB_START_END}
178 | $CONSTANTS{BIN_ARG}{BIN_ARG_SAVE_OOB_START_NBINS};
179 }
180  
181  
182 # convert hash into [key => value] tuples, sorted by group, then value in group
183 ## no critic (BuiltinFunctions::ProhibitComplexMappings)
184 my @CONSTANTS = map {
185 my $h = $_;
186 map { [ $_, $h->{$_} ] } sort { $h->{$a} <=> $h->{$b} } keys %$h;
187 } values %CONSTANTS;
188  
189 my @CONSTANT_NAMES = ( map { keys %$_ } values %CONSTANTS );
190 my @EXPORT_OK;
191  
192 sub slurp {
193 my $file = catfile( LIBDIR, shift );
194 local $/ = undef;
195 ( IO::File->new( $file, 'r' ) or die( "can't slurp $file" ) )->getline;
196 }
197  
198  
199 pp_core_importList( '()' );
200  
201 pp_bless( 'CXC::PDL::Bin1D' );
202  
203 pp_addpm( { At => 'Top' }, <<'EOD' );
204 4 ▶use v5.10;
Subroutine BEGIN: called CC=1 SCAR=0.0
205 4 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
206 4 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
207 4 ▶no namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
208 4 ▶use CXC::PDL::Bin1D::Utils;
Subroutine BEGIN: called CC=1 SCAR=0.0
209 4 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
210  
211 EOD
212  
213 if ( version->parse( PDL->VERSION ) < version->parse( '2.030' ) ) {
214 pp_addpm( { At => 'Top' }, <<'EOD' );
215 our @EXPORT_OK;
216 our %EXPORT_TAGS;
217 EOD
218 }
219  
220 pp_addpm(
221 { At => 'Top' },
222 4 ▶ join( "\n", 'use constant {', ( map { "$_->[0] => $_->[1]," } @CONSTANTS ), '};', q{} ),
Subroutine BEGIN: called CC=1 SCAR=0.2
223 4 );
224  
225 pp_addpm(
226 { At => 'Top' },
227 join( "\n", '=for Pod::Coverage', ( map { "$_->[0]" } @CONSTANTS ), q{}, '=cut', q{} ),
228 );
229  
230 0 pp_addpm( { At => 'Top' }, <<'EOD' );
231 my %MapErrorAlgo = (
232  
233 sdev => BIN_ARG_ERROR_SDEV,
234 rss => BIN_ARG_ERROR_RSS,
235 poisson => BIN_ARG_ERROR_POISSON,
236 );
237 EOD
238  
239 pp_addpm( { At => 'Top' }, <<'EOD' );
240 =for Pod::Coverage
241 set_boundscheck
242 set_debugging
243  
244 =for stopwords
245 merchantability
246 4  
247 =cut
248  
249 =head1 NAME
250  
251 CXC::PDL::Bin1D - one dimensional binning functions
252  
253 =head1 SYNOPSIS
254  
255 use PDL;
256 use CXC::PDL::Bin1D;
257  
258 =head1 DESCRIPTION
259  
260 One dimensional binning functions,
261  
262 =over
263  
264 =item *
265  
266 binning up to a given S/N
267  
268 =item *
269  
270 optimized one-pass robust statistics
271  
272 =back
273  
274 All functions are made available in the B<CXC::PDL::Bin1D> namespace.
275  
276 =head1 SUBROUTINES
277  
278 =cut
279 EOD
280  
281 pp_addhdr(
282 join( "\n",
283 '#include <float.h>',
284 '#include <limits.h>',
285 map { "#define $_->[0] $_->[1]" } @CONSTANTS )
286 . "\n",
287 );
288  
289  
290 push @EXPORT_OK, 'bin_adaptive_snr';
291 pp_def(
292 'bin_adaptive_snr',
293 Pars => join(
294 q{;},
295 'signal(n)', # piddle containing signal to bin
296 'error(n)', # error piddle if flags && HAVE_ERROR or HAVE_ERROR2
297 'width(n)', # optional width for each signal datum
298 "$IndexParsType [o] index(n)", # output index
299 "$IndexParsType [o] nbins()",
300 "$IndexParsType [o] nelem(n)",
301 'double [o] b_signal(n)',
302 'double [o] b_error(n)',
303 'double [o] b_mean(n)',
304 'double [o] b_snr(n)',
305 'double [o] b_width(nwidth)',
306 "$IndexParsType [o] ifirst(n)",
307 "$IndexParsType [o] ilast(n)",
308 'int [o] rc(n)',
309 'double [t] b_error2(nrss)',
310 'double [t] b_signal2(nsdev)',
311 'double [t] b_m2(nsdev)',
312 'double [t] b_weight(nweight)', # use only for SDEV (with or without errors) & RSS
313 'double [t] b_weight_sig(nwsdev)',
314 'double [t] b_weight_sig2(nwsdev)',
315 ),
316 RedoDimsCode => fill_in_string(
317 <<'EOS'
318 PDL_Indx n = $PDL(signal)->dims[0];
319 $SIZE(nrss) = $COMP(optflags) & BIN_ARG_ERROR_RSS ? n : 0 ;
320 $SIZE(nwidth) = $COMP(optflags) & BIN_ARG_HAVE_WIDTH ? n : 0 ;
321 $SIZE(nsdev) = $COMP(optflags) & BIN_ARG_ERROR_SDEV ? n : 0 ;
322 $SIZE(nwsdev) = $COMP(optflags) & (BIN_ARG_ERROR_SDEV | BIN_ARG_HAVE_ERROR )
323 == (BIN_ARG_ERROR_SDEV | BIN_ARG_HAVE_ERROR ) ? n : 0 ;
324 $SIZE(nweight) = $COMP(optflags) & (BIN_ARG_ERROR_SDEV | BIN_ARG_ERROR_RSS) ? n : 0 ;
325 EOS
326 ),
327 OtherPars => fill_in_string(
328 join(
329 q{;},
330 'unsigned long optflags'
331 , # can't call it flags; clashes with PDL internals
332 'double min_snr',
333 'PDL_Indx min_nelem',
334 'PDL_Indx max_nelem',
335 'double min_width',
336 'double max_width',
337 ),
338 ),
339 Code => fill_in(
340 file => 'bin_adaptive_snr.c',
341 package => 'bin_adaptive_snr',
342 ),
343 HandleBad => 1,
344 BadCode => fill_in(
345 file => 'bin_adaptive_snr.c',
346 package => 'bin_adaptive_snr_bad',
347 hash => { PDL_BAD_CODE => 1 },
348 ),
349 PMCode => slurp( 'bin_adaptive_snr.pl' ),
350 PMFunc => q{},
351 Doc => undef,
352 );
353  
354 push @EXPORT_OK, 'bin_on_index';
355 pp_def(
356 'bin_on_index',
357 Pars => join(
358 q{;},
359  
360 # inputs
361 'data(n)', # piddle containing data to bin
362 "$IndexParsType index(n)", # input index
363 'weight(n)', # populated if flags && HAVE_WEIGHT
364 "$IndexParsType imin(nt)", # minimum index value to consider
365 "$IndexParsType nbins(nt)", # number of bins
366  
367 # outputs
368 "$IndexParsType [o] b_count(nb)", # number of data values
369 'double [o] b_data(nb)', # sum of the data
370 'double [o] b_weight(nb)',
371 'double [o] b_weight2(nb)',
372 'double [o] b_mean(nb)',
373 'double [o] b_dmin(nb)',
374 'double [o] b_dmax(nb)',
375 'double [o] b_dev2(nb)',
376  
377 # temporaries
378 'double [t] b_data_error(nb)',
379 'double [t] b_weight_error(nb)',
380 'double [t] b_weight2_error(nb)',
381 ),
382 OtherPars => fill_in_string(
383 join(
384 q{;},
385 'unsigned long optflags', # can't call it flags; clashes with PDL internals
386 'PDL_Indx nbins_max', # maximum number of bins
387 ),
388 ),
389 RedoDimsCode =>
390 q/ $SIZE(nb) = $COMP(nbins_max) + ($COMP(optflags) & BIN_ARG_SAVE_OOB ? 2 : 0 ); /,
391 Code => fill_in(
392 file => 'bin_on_index.c',
393 package => 'bin_on_index',
394 ),
395 HandleBad => 1,
396 BadCode => fill_in(
397 file => 'bin_on_index.c',
398 package => 'bin_on_index_bad',
399 hash => { PDL_BAD_CODE => 1 },
400 ),
401 PMCode => slurp( 'bin_on_index.pl' ),
402 PMFunc => q{},
403 Doc => undef,
404 );
405  
406  
407  
408 pp_addpm( { At => 'Bot' }, <<'EOD' );
409  
410 =head1 BUGS AND LIMITATIONS
411  
412 No bugs have been reported.
413  
414 =head1 AUTHOR
415  
416 Diab Jerius, E<lt>djerius@cpan.orgE<gt>
417  
418 =head1 COPYRIGHT AND LICENSE
419  
420 Copyright 2008 Smithsonian Astrophysical Observatory
421  
422 CXC::PDL::Bin1D is free software: you can redistribute it and/or modify
423 it under the terms of the GNU General Public License as published by
424 the Free Software Foundation, either version 3 of the License, or (at
425 your option) any later version.
426  
427 This program is distributed in the hope that it will be useful,
428 but without any warranty; without even the implied warranty of
429 merchantability or fitness for a particular purpose. See the
430 GNU General Public License for more details.
431  
432 You should have received a copy of the GNU General Public License
433 along with this program. If not, see L<http://www.gnu.org/licenses/>.
434  
435 =cut
436 EOD
437  
438  
439 pp_export_nothing();
440  
441 0 pp_addpm( { At => 'Top' },
442 qq[\$EXPORT_TAGS{constants} = [ qw(\n@{[ join "\n", @CONSTANT_NAMES ]}\n)];\n] );
443 0 pp_addpm( { At => 'Top' }, qq[\$EXPORT_TAGS{Func} = [ qw(\n@{[ join "\n", @EXPORT_OK ]}\n)];\n] );
444 0 pp_addpm( { At => 'Top' }, q[@EXPORT_OK = map { @{$_} } values %EXPORT_TAGS] . ";\n" );
445  
446 pp_done();
447  
448 1;
« Bin1D.xs ↑ Summary