view release on metacpan or  search on metacpan

lib/Chart/GGPlot/Util.pm  view on Meta::CPAN

    scales => \@Chart::GGPlot::Util::Scales::EXPORT_OK,
    ggplot => \@export_ggplot,
);

use constant pt     => 72.27 / 25.4;
use constant stroke => 96 / 25.4;

fun expand_range4 ( $limits, $expand ) {
    return $limits if ($limits->length) == 0;

    die unless ( $expand->length == 2 or $expand->length == 4 );

    if ( $expand->length == 2 ) {
        $expand = pdl([(@{ $expand->unpdl })x2]);
    }

    my $lower =
      expand_range( $limits, $expand->at(0), $expand->at(1) )->at(0);
    my $upper =
      expand_range( $limits, $expand->at(2), $expand->at(3) )->at(1);
    return pdl( [ $lower, $upper ] );
}


fun remove_missing ($df,
                    :$vars = $df->names, :$na_rm = false,
                    :$name = '', :$finite = false) {
    $vars = $vars->intersect( $df->names );

    my $missing = PDL::Core::zeros( $df->nrow );

    for my $var (@$vars) {
        my $col = $df->at($var);
        my $bad = $col->isbad;
        if ($finite and !is_discrete($col)) {
            $bad = ( $bad | !( $col->isfinite ) );
        }
        $missing->where( $bad ) .= 1;
    }

    if ( $missing->any ) {
        if ( !$na_rm ) {
            carp(
                sprintf(
                    "Removed %s rows containing %s values%s.",
                    which($missing)->length,
                    ( $finite       ? 'non-finite' : 'missing' ),
                    ( length($name) ? " ($name)"   : $name )
                )
            );
        }
        return $df->select_rows( which( !$missing ) );
    }
    else {
        return $df;
    }
}


fun call_if_coderef ($x, @args) {
    return ( Ref::Util::is_coderef($x) ? $x->(@args) : $x );
}

fun clist ($hash_like) {
    unless ( Ref::Util::is_plain_hashref($hash_like) ) {
        $hash_like = { map { $_ => $hash_like->at($_) } @{ $hash_like->keys } };
    }
    return Data::Dumper::Concise::Dumper($hash_like);
}


fun alias_color_functions ($package, @function_names) {
    return map {
        if ( $_ =~ /color/ ) {
            my $alias_name = $_ =~ s/color/colour/gr;
            {
                no strict 'refs';
                *{"${package}::${alias_name}"} = \&{"${package}::$_"};
            }
            ( $_, $alias_name );
        }
        else {
            $_;
        }
    } @function_names;
}

fun find_global ($name) {
    my $trace = Devel::StackTrace->new;

    my $frame = $trace->prev_frame;
    while ( $frame = $trace->prev_frame ) {
        my $stash = Package::Stash->new( $frame->package );
        if ( $stash->has_symbol($name) ) {
            return $stash->get_symbol($name);
        }
    }
    return;
}

fun isnt_null_or ( $a, $b ) { !is_null($a) ? $a : $b; }

# Euclidean distance between points.
fun dist_euclidean ($x, $y) {
    my $n   = $x->length;
    my $idx = sequence( $n - 1 );
    return ( ( $x->slice($idx) - $x->slice( $idx + 1 ) )**2 +
          ( $y->slice($idx) - $y->slice( $idx + 1 ) )**2 )->sqrt;
}

# Polar distance between points.
fun dist_polar ($r, $theta) {
    my $lf = find_line_formula( $theta, $r );

    # Rename x and y columns to r and t, since we're working in polar
    $lf = $lf->rename(
        {
            x1          => 't1',
            x2          => 't2',
            y1          => 'r1',
            y2          => 'r2',
            x_intercept => 't_int',
            yintercept  => 'r_int'
        }
    );