Data-EventStream

 view release on metacpan or  search on metacpan

t/event_stream_mixed.t  view on Meta::CPAN

    },
    {
        time   => 7,
        val    => 47,
        resets => { ctb => "33,52,1", },
        ins    => { t10 => "33,52,1", c3 => "33,52,3", ct => "33,52,1", ctb => "33,52,1", },
    },
    {
        time => 16,
        outs => { t10 => [ "33,52,3", "33,47,5", ], ct => [ "33,52,3", "33,47,5", ], },
        vals => { t10 => "47,47,6", c3 => "33,52,3", ct => "47,47,6", ctb => "NaN,NaN,7", },
    },
    {
        time   => 18,
        val    => 23,
        resets => { ctb => "NaN,NaN,7" },
        outs   => { t10 => "47,47,7", c3 => "33,52,3", ct => "47,47,7", },
        ins    => { t10 => "23,23,8", c3 => "23,47,5", ct => "23,23,8", ctb => "23,23,17", },
    },
    {
        time => 19,
        val  => 15,
        outs => { c3 => "23,47,5", },
        ins  => { t10 => "15,23,9", c3 => "15,47,7", ct => "15,23,9", ctb => "15,23,17", },
    },
    {

t/event_stream_time.t  view on Meta::CPAN

        vals => { t3 => 3.13333, t5 => 2.72973, b4 => 3.13333, b3 => 3.9, },
        add_aggregator => {
            d5 => { duration => 5, batch => 1, disposable => 1, },
        },
        stream => { next_leave => 15.7, },
    },
    {
        time   => 16,
        resets => { b4 => 3.35, },
        outs   => { t3 => 3.84848, },
        vals   => { t3 => 3.93333, t5 => 3, b4 => 4, b3 => 3.93333, d5 => 'NaN', },
        stream => { next_leave => 16.2, },
    },
    {
        time   => 17.1,
        val    => 8,
        resets => { b3 => 3.94286, },
        outs   => { t3 => 4, t5 => 3.18966, },
        ins    => { t3 => 4, t5 => 3.54, b4 => 4, b3 => 4, d5 => 8, },
        stream => { next_leave => 17.7, },
    },

t/lib/Averager.pm  view on Meta::CPAN

    default => 0,
    handles => {
        _inc_count   => 'inc',
        _dec_count   => 'dec',
        _reset_count => 'reset',
    },
);

sub value {
    my $self = shift;
    return $self->_count ? sprintf( "%.6g", $self->_sum / $self->_count ) : 'NaN';
}

sub enter {
    my ( $self, $event ) = @_;
    my $val = $self->value_sub->($event);
    $self->_sum_add($val);
    $self->_inc_count;
}

sub reset {

t/lib/MinMax.pm  view on Meta::CPAN

use Moose;
with 'Data::EventStream::Aggregator';

has value_sub => (
    is      => 'ro',
    default => sub {
        sub { $_[0]->{val} }
    },
);

has max => ( is => 'ro', writer => '_set_max', default => 'NaN', );

has min => ( is => 'ro', writer => '_set_min', default => 'NaN', );

has since => ( is => 'ro', writer => '_set_since', default => 0, );

sub value {
    my $self = shift;
    return join ",", $self->min, $self->max, $self->since;
}

sub enter {
    my ( $self, $event, $window ) = @_;
    my $value = $self->value_sub->($event);
    if ( $self->max ne 'NaN' ) {
        if ( $value > $self->max ) {
            $self->_set_max($value);
        }
        elsif ( $value < $self->min ) {
            $self->_set_min($value);
        }
    }
    else {
        $self->_set_max($value);
        $self->_set_min($value);
        $self->_set_since( $window->start_time );
    }
}

sub reset {
    my ( $self, $window ) = @_;
    $self->_set_max('NaN');
    $self->_set_min('NaN');
    $self->_set_since( $window->start_time );
}

sub leave {
    my ( $self, $event, $window ) = @_;
    my $value = $self->value_sub->($event);
    $self->_set_since( $window->start_time );
    if ( $window->count == 0 ) {
        $self->_set_max('NaN');
        $self->_set_min('NaN');
    }
    elsif ( $value >= $self->max or $value <= $self->min ) {
        my $vs   = $self->value_sub;
        my $min  = my $max = $vs->( $window->get_event(-1) );
        my $next_event = $window->get_iterator;
        while ( my $event = $next_event->() ) {
            my $val = $vs->($event);
            if ( $val < $min ) {
                $min = $val;
            }

t/lib/TimeAverager.pm  view on Meta::CPAN

sub duration {
    my ($self) = @_;
    $self->{_start_point} ? $self->{_end_point}[0] - $self->{_start_point}[0] : 0;
}

sub value {
    my ($self) = @_;
        $self->duration ? 0 + sprintf( "%.6g", $self->{_sum} / $self->duration )
      : $self->{_start_point} ? $self->{_start_point}[1]
      :                         'NaN';
}

sub enter {
    my ( $self, $event, $win ) = @_;
    my ( $time, $value ) = $self->{time_value_sub}->($event);
    $self->{_end_point} = [ $time, $value ];
    unless ( $self->{_start_point} ) {

        # this is the first event we've got
        $self->{_start_point} = [ $time, $value ];