7 More Discussions You Might Find Interesting
1. Shell Programming and Scripting
Heya
Ever wanted to have some basic stats of your projects?
Like:
./stats.sh
########################################
Project stats for "tui"
########################################
260 kb in bin
24 kb in conf.etc
12 kb in conf.home
32 kb in docs/samples
176 kb in docs/wiki
280... (5 Replies)
Discussion started by: sea
5 Replies
2. Linux
Please help me with a shell script to get the stats on many subdirectories (sub1), (sub2) etc under a mother directory (big)
/big

_______sub1
_______sub2
_______sub3

I want to know
1. What is the last file accessed in each subdirectory with date and by whom
2.... (2 Replies)
Discussion started by: digipak
2 Replies
3. Shell Programming and Scripting
So, I have a php program that i need to delete ALL files in a directory that are older than a certain age.
<?php
/* Get file stat */
$stat = stat('/apps/security/ajaba');
This is as far as I've been able to get. I know in shell programming you can easily do something like this. but I'm... (2 Replies)
Discussion started by: SkySmart
2 Replies
4. Shell Programming and Scripting
Hi guys
I need a script that can ping a list of hosts and print the output to my homepage, with the result "running" or "dead".
I'm new in this so please be patient with me.
Can anybody help me? (1 Reply)
Discussion started by: NickB
1 Replies
5. AIX
Aix 5.3 I am trying to view the IO stats. I do the sar 5 5 but that is the WIO and si different than the IO stats right? I am just blanking on this. I know there is a command that I used to run that brings up a whole bunch of live stats that run live such as mem and so on just can't rememeber... (4 Replies)
Discussion started by: rocker40
4 Replies
6. AIX
I recieved this out put below soemhow. Unfortunatly I did not write down the command I used to get it. Can someone tell me what command I use to gather these stats?
OS = AIX 5.3 64Bit
System Model: IBM,70266H1
Machine Serial Number:... (2 Replies)
Discussion started by: rocker40
2 Replies
7. UNIX for Advanced & Expert Users
What do others use for measuring I/O statistics? I'd like something versatile, as in being able to watch (like iostat, but easier to trend), generate load (like iozone, but more realistic), and perform somewhat generalized benchmarks (like bonnie, but more current.) It would scale from a few... (0 Replies)
Discussion started by: LivinFree
0 Replies
Stats(3pm) User Contributed Perl Documentation Stats(3pm)
NAME
PDL::Stats  a collection of statistics modules in Perl Data Language, with a quickstart guide for nonPDL people.
VERSION
Version 0.6.2
DESCRIPTION
Loads modules named below, making the functions available in the current namespace.
Properly formated documentations online at http://pdlstats.sf.net
SYNOPSIS
use PDL::LiteF; # loads less modules
use PDL::NiceSlice; # preprocessor for easier pdl indexing syntax
use PDL::Stats;
# Is equivalent to the following:
use PDL::Stats::Basic;
use PDL::Stats::GLM;
use PDL::Stats::Kmeans;
use PDL::Stats::TS;
# and the following if installed;
use PDL::Stats::Distr;
use PDL::GSL::CDF;
QUICKSTART FOR NONPDL PEOPLE
Enjoy PDL::Stats without having to dive into PDL, just wet your feet a little. Three key words two concepts and an icing on the cake, you
should be well on your way there.
pdl
The magic word that puts PDL::Stats at your disposal. pdl creates a PDL numeric data object (a pdl, pronounced "piddle" :/ ) from perl
array or array ref. All PDL::Stats methods, unless meant for regular perl array, can then be called from the data object.
my @y = 0..5;
my $y = pdl @y;
# a simple function
my $stdv = $y>stdv;
# you can skip the intermediate $y
my $stdv = stdv( pdl @y );
# a more complex method, skipping intermediate $y
my @x1 = qw( y y y n n n );
my @x2 = qw( 1 0 1 0 1 0 )
# do a twoway analysis of variance with y as DV and x1 x2 as IVs
my %result = pdl(@y)>anova( @x1, @x2 );
print "$_ $result{$_}
" for (sort keys %result);
If you have a list of list, ie array of array refs, pdl will create a multidimensional data object.
my @a = ( [1,2,3,4], [0,1,2,3], [4,5,6,7] );
my $a = pdl @a;
print $a . $a>info;
# here's what you will get
[
[1 2 3 4]
[0 1 2 3]
[4 5 6 7]
]
PDL: Double D [4,3]
PDL::Stats puts observations in the first dimension and variables in the second dimension, ie pdl [obs, var]. In PDL::Stats the above
example represents 4 observations on 3 variables.
# you can do all kinds of fancy stuff on such a 2D pdl.
my %result = $a>kmeans( {NCLUS=>2} );
print "$_ $result{$_}
" for (sort keys %result);
Make sure the array of array refs is rectangular. If the array refs are of unequal sizes, pdl will pad it out with 0s to match the longest
list.
info
Tells you the data type (yes pdls are typed, but you shouldn't have to worry about it here*) and dimensionality of the pdl, as seen in the
above example. I find it a big help for my sanity to keep track of the dimensionality of a pdl. As mentioned above, PDL::Stats uses 2D pdl
with observation x variable dimensionality.
*pdl uses double precision by default. If you are working with things like epoch time, then you should probably use pdl(long, @epoch) to
maintain the precision.
list
Come back to the perl reality from the PDL wonder land. list turns a pdl data object into a regular perl list. Caveat: list produces a flat
list. The dimensionality of the data object is lost.
Signature
This is not a function, but a concept. You will see something like this frequently in the pod:
stdv
Signature: (a(n); float+ [o]b())
The signature tells you what the function expects as input and what kind of output it produces. a(n) means it expects a 1D pdl with n
elements; [o] is for output, b() means its a scalar. So stdv will take your 1D list and give back a scalar. float+ you can ignore; but if
you insist, it means the output is at float or double precision. The name a or b or c is not important. What's important is the thing in
the parenthesis.
corr
Signature: (a(n); b(n); float+ [o]c())
Here the function corr takes two inputs, two 1D pdl with the same numbers of elements, and gives back a scalar.
t_test
Signature: (a(n); b(m); float+ [o]t(); [o]d())
Here the function t_test can take two 1D pdls of unequal size (n==m is certainly fine), and give back two scalars, tvalue and degrees of
freedom. Yes we accommodate ttests with unequal sample sizes.
assign
Signature: (data(o,v); centroid(c,v); byte [o]cluster(o,c))
Here is one of the most complicated signatures in the package. This is a function from Kmeans. assign takes data of observasion x variable
dimensions, and a centroid of cluster x variable dimensions, and returns an observation x cluster membership pdl (indicated by 1s and 0s).
Got the idea? Then we can see how PDL does its magic :)
Threading
Another concept. The first thing to know is that, threading is optional.
PDL threading means automatically repeating the operation on extra elements or dimensions fed to a function. For a function with a
signature like this
gsl_cdf_tdist_P
Signature: (double x(); double nu(); [o]out())
the signatures says that it takes two scalars as input, and returns a scalar as output. If you need to look up the pvalues for a list of
t's, with the same degrees of freedom 19,
my @t = ( 1.65, 1.96, 2.56 );
my $p = gsl_cdf_tdist_P( pdl(@t), 19 );
print $p . "
" . $p>info;
# here's what you will get
[0.94231136 0.96758551 0.99042586]
PDL: Double D [3]
The same function is repeated on each element in the list you provided. If you had different degrees of freedoms for the t's,
my @df = (199, 39, 19);
my $p = gsl_cdf_tdist_P( pdl(@t), pdl(@df) );
print $p . "
" . $p>info;
# here's what you will get
[0.94973979 0.97141553 0.99042586]
PDL: Double D [3]
The df's are automatically matched with the t's to give you the results.
An example of threading thru extra dimension(s):
stdv
Signature: (a(n); float+ [o]b())
if the input is of 2D, say you want to compute the stdv for each of the 3 variables,
my @a = ( [1,1,3,4], [0,1,2,3], [4,5,6,7] );
# pdl @a is pdl dim [4,3]
my $sd = stdv( pdl @a );
print $sd . "
" . $sd>info;
# this is what you will get
[ 1.2990381 1.118034 1.118034]
PDL: Double D [3]
Here the function was given an input with an extra dimension of size 3, so it repeates the stdv operation on the extra dimenion 3 times,
and gives back a 1D pdl of size 3.
Threading works for arbitrary number of dimensions, but it's best to refrain from higher dim pdls unless you have already decided to become
a PDL wiz / witch.
Not all PDL::Stats methods thread. As a rule of thumb, if a function has a signature attached to it, it threads.
perldl
Essentially a perl shell with "use PDL;" at start up. Comes with the PDL installation. Very handy to try out pdl operations, or just plain
perl. print is shortened to p to avoid injury from exessive typing. my goes out of scope at the end of (multi)line input, so mostly you
will have to drop the good practice of my here.
For more info
PDL::Impatient
AUTHOR
~~~~~~~~~~~~ ~~~~~ ~~~~~~~~ ~~~~~ ~~~ `` ><(((">
Copyright (C) 20092012 Maggie J. Xiong <maggiexyz users.sourceforge.net>
All rights reserved. There is no warranty. You are allowed to redistribute this software / documentation as described in the file COPYING
in the PDL distribution.
perl v5.14.2 20120604 Stats(3pm)