#!/bin/bash
DATE=`date +%d%m%Y.%H%S`
cd `somedir`

echo "" > file.log
dirsan=/tmp
for i in $dirsan/*.san; do           #for all existing files in 'san' directory
   ni=${i//.san/}    #removes file termination .san (san wont accept it)
   rm $dirsan/agg/ $dirsan/cnd/ $dirsan/des/ $dirsan/dsc/ $dirsan/jit/ -rf
   rm $dirsan/*.vct -rf #remove previous peps stuff
   hora=`date +%H:%M:%S%t%d/%m` #saves current time, to mark progress
   echo "running $ni at $hora" >> file.log  #save to file.log what's running
   echo 4 2 100000 1 1 $ni 2 1 1 vector 0 2 | $dirsan/peps
      #the last line does 3 things: 
        #1. calls peps setting iterations to 100000 
        #2. compiling (1 1) and 
        #3. solving (2 1 1) then exiting (0 2)
      #we are assuming that the executable is in the dirsan directory
done

t=0
c=0
o=0
cut=10
term=62
dir=$base'models/8slaves/'
while [ $t -le $term ]; do
   path=$dir'term'$t
   for i in $path/*; do
      file=$path/'8slaves_'$t'_t'$o'.out'
      `rm $file -f`
      let o+=1
      while [ $c -le $cut ]; do
         `$base''split $i $c >> $file`
         let c+=1
      done
      c=0
   done
   o=0
   let t+=1
done

#!/bin/bash


if [ "$1" = "" ]; then
   echo "error. missing parameter n"
else
   echo "success"
fi

#!/bin/sh

if [ "$1" = "" ]; then
  echo "invalid command. options: get/getall/put"
else
if [ "$1" = "getall" ]; then
  echo "retrieving ALL from foo"
else
if [ "$1" = "get" ]; then
  echo "retrieving *.htm from foo"
else
if [ "$1" = "put" ]; then
  if [ "$2" = "" ]; then
    echo "choose a file."
  else
    echo "uploading $2 to foo"
  fi
fi
fi
fi
fi

#!/usr/bin/perl

use strict;
use warnings;

if (@ARGV != 1) { 
   print "missing FILE parameter. \nusage: perl file.pl FILE\n";
   exit;
}

open(INFILE, "<$file") or die("cannot open hash file named $file\n");
my(@lines) = <INFILE>;
close(INFILE);
foreach my $line (@lines) {
   $line =~ s/\n//g;
}

$line =~ s/^\s+//;  #trim at start
$line =~ s/\s+$//;  #trim at end
$line =~ s/\s+/ /g; #remove multiple spaces for single space

# removes spaces from beginning and end of strings
sub  trim { my $s = shift; $s =~ s/^\s+|\s+$//g; return $s };

# substitutes extra spaces in the middle of strings for single spaces
sub strip { my $s = shift; $s =~ s/ +/ /g; return $s };

#!/usr/bin/perl

my $path = $ARGV[0]."output/";
my @contents;
opendir MYDIR, $path;
@contents = grep !/^\.\.?$/,grep /.txt/, readdir MYDIR;
closedir MYDIR;
foreach my $file (@contents) {
   print "file=$file\n";
   system("tail -n 1 $path$file");
}

print >>END;
\\begin{table*}[!hbt]
\\begin{center}
END

#put this on the header
use Number::Format qw(:subs :vars);
$THOUSANDS_SEP   = '.';
$DECIMAL_POINT   = ',';
$INT_CURR_SYMBOL = 'DEM';


#use it like this:
$mem = format_number($mem, 2, 1);
$complex = format_number($complex);

open(OUTFILE, ">$name") or die("cannot open $name\n");
print OUTFILE >>END;
#!/bin/sh

set term postscript eps enhanced color
set xtics 2
plot[0:$termo][0:$lcut]   'bc_$model.txt' title "term x cut" with boxes 
END
close(OUTFILE);

#or

open(OUTFILE, ">$name") or die("cannot open $name\n");
print OUTFILE "this is some text to be printed\n";
close(OUTFILE);

$strut->{$lid} = {
   'gid'   =>   $gid,
   'aa'    =>   [@aa],
   'ja'    =>   [@ja],
   'ia'    =>   [@ia],
   'order' =>   $order,
   'nz'    =>   $nz,
};

#defining an array of hashes:
push @terms, $strut;

#iterating
foreach my $st (@terms) {
   foreach my $termo (keys %$strut) {
      print "gid=".($strut->{$termo}{'gid'})."\n";
      print "lid=$termo\n";
      print "order=".$strut->{$termo}{'order'}."\n";
      print "nz=".$strut->{$termo}{'nz'}."\n";
      print "id=".$strut->{$termo}{'id'}."\n";
   }
}

#finally, to print the whole structure, with arrays:
sub print_strut {
   my @lterms = @_;
   print "call to print...\n";
   foreach my $st (@lterms) {
      foreach my $termo (keys %$st) {
         print "term $termo [".($st->{$termo}{'gid'})."] nz=".$st->{$termo}{'nz'}."\n";
         my @aux=@{$st->{$termo}{'aa'}};
         print "aa: ";
         foreach my $a_ (@aux) {
            print "".$a_." ";
         }
         print "\n";
         my @aux=@{$st->{$termo}{'ja'}};
         print "ja: ";
         foreach my $a_ (@aux) {
            print "".$a_." ";
         }
         print "\n";
         my @aux=@{$st->{$termo}{'ia'}};
         print "ia: ";
         foreach my $a_ (@aux) {
            print "".$a_." ";
         }
         print "\n";
      }
      print "\n";
   }
}

print "digraph G {\n";
print "\tnode [shape = circle];\n";
for (my $i = 0; $i < $SIZE; $i++) {
   for (my $j = 0; $j < $SIZE; $j++) {
      if ($matrix[$i][$j] ne "") {
         my $label = "label$i$j";
         my $auxi = ($i+1) < 10 ? "0".($i+1) : ($i+1);
         my $auxj = ($j+1) < 10 ? "0".($j+1) : ($j+1);
         print "\tS".($auxi)." -> S".($auxj)." [ label = \"$label\" ]\n";
      }
   }
}
print "}\n";

#call: verify_changes(@arr1, @arr2);

#subrotine:
sub verify_changes {
   my @v1 = @{$_[0]};
   my @v2 = @{$_[1]};
   print "printing...\n";
   for (my $i = 0; $i < $size; $i++) {
      print "$v1[$i] ";
   }
   print "\n";
   for (my $i = 0; $i < $size; $i++) {
      print "$v2[$i] ";
   }
   print "\n";
}

(my $sec,my $min,my $hour,my $mday,my $mon,my $year,my $wday,my $yday,my $isdst)=localtime(time);
printf "%4d-%02d-%02d %02d:%02d:%02d\n",$year+1900,$mon+1,$mday,$hour,$min,$sec;
#or
my $date = sprintf("%02d/%02d/%4d %02d:%02d:%02d\n",$mday,$mon+1,$year+1900,$hour,$min,$sec);
print $date."\n";

if ($line =~ /(\s*)authors=\{(.*)\}/) {
   print "authors=$2\n";
}

#!/usr/bin/perl

use strict;
use warnings;

#this script will revert the .mdd final file in the same format peps works

if (@ARGV != 1) { 
   print "missing FILE parameter. \nusage: perl revert.pl FILE\nenter a .rep file with termination\n";
   exit;
}

my $rep_file = $ARGV[0];
open(INFILE, "<$rep_file") or die("cannot open $rep_file");
my(@lines) = <INFILE>;
close(INFILE);

my $name;
my $states;
my @entries;
my $cont = 0;
foreach my $line (@lines) {
   $line =~ s/\n//g;
   if ($line =~ /\(\s(.*)\s\)/) {  #for example ( 2 2 3 4 2 1 )
      $states = $1;
      (@entries) = split(" ", $states);
      @entries = reverse(@entries); #example of reverse
      foreach my $entry (@entries) {
         print "".((++$cont % @entries == 0) ? "$entry" : "$entry ");
      }
      #$cont = 0;
      print "\n";
   }
}

my $i = 10;
my $val = sprintf("%05d",$i);

deal(\@sizes,\@cuts,\@nzs,\@perms,$n_aut,$n_evt,$model);

...

sub deal {
   my ($sz,$ct,$nz,$pe,$auts,$evts,$model_) = @_;
   my @sizes_ = @$sz;
   my @cuts_ = @$ct;
   my @nzs_ = @$nz;
   my @perms_ = @$pe;
}

my %rosa = (
  'N66' => [80,0,0,0,1,1,70,100],
  'N23' => [1,70,80,100,30,3,2,1],
  'EQU' => [1,15,50,80,100,75,45,10],
  'S23' => [1,1,2,3,30,100,80,70],
  'S66' => [80,100,70,1,1,0,0,0]
);

...

foreach my $key (keys %rosa) {
   my @forces = @{$rosa{$key}};    #this is where you take the array reference
   print "$key\n";
   foreach my $f (@forces) {       #now, just use it
      print "$f ";
   }
   print "\n";
}

#!/usr/bin/perl

#implementado em 18/01/2010

use strict;
use warnings;

#converte um vetor em uma matriz
#util para percorrer um vetor e imprimir a linha da matriz, acessando os indices corretos

#colocar valores multiplos para fechar matrizes quadradas (nao testado)

if (@ARGV != 2) { 
   print "falta TAMANHO ou DIMENSAO. \nuso: perl vec2mat.pl TAMANHO DIMENSAO\n\tTAMANHO: tamanho total do vetor\n\tDIMENSAO: dimensao final da matriz\n";
   exit;
}

my $SIZE = $ARGV[0];  #tamanho do vetor
my $DIM = $ARGV[1];   #cria uma matriz DIMxDIM a partir do vetor de SIZE posicoes

#inicia um vetor qualquer com valores quaisquer
my @ARR = ();
for (my $i = 0; $i < $SIZE; $i++) {
   push @ARR, $i;
}

#calcula o tamanho da linha
my $linha = @ARR / $DIM;

my $c = 0;
my $val = 0;
my $aux = 0;
for(my $i = 0; $i < @ARR; $i++) {
   my $o = ($c++ % $DIM);
   $val = $aux + ($linha * $o);
   print "$ARR[$val] ";
   if (($i + 1) % $DIM == 0) {
      print "\n";
      $aux++;
   }
}

#!/usr/bin/perl

use strict;
use warnings;

if (@ARGV != 1) { 
   print "missing PATH parameter. \nusage: perl convert.pl PATH\n";
   exit;
}

my $path = $ARGV[0];

my @contents;
opendir MYDIR, $path;
@contents = grep !/^\.\.?$/,grep /.JPG/i, readdir MYDIR;
closedir MYDIR;
system("rm new -rf");
system("mkdir new");
foreach my $file (sort @contents) {
   my $fp = "$path/$file";
   my $aux = $file;
   $aux =~ s/\./;/;
   my $filename;
   my $term;
   ($filename,$term) = split(";",$aux);
   my $new_name = $filename."\_.".$term;
   print "[$aux] converting $file... to $new_name\n";
   system("convert -resize 1024x768 $file $new_name");
   system("mv $new_name ./new");
}

#!/usr/bin/perl

use strict;
use warnings;

use Time::Local;
use Cwd qw();

use Image::Resize;
#install this package: on command.exe type: cpan Image::Resize

#use: perl resize-photos.pl FOLDER
#this script will convert JPG images and put in a new folder, created according to current time (folder will be called "FOLDER-dd-mm-yyyy_hh-mm-ss")

if (@ARGV != 1) {
   print "missing OUTPUT-DIR parameter. \nusage: perl resize-photos.pl OUTPUT-DIR\n";
   exit;
}

my $path = $ARGV[0];

#current localtime
(my $sec,my $min,my $hour,my $mday,my $mon,my $year,my $wday,my $yday,my $isdst)=localtime(time);
my $date = sprintf("%02d-%02d-%4d_%02d-%02d-%02d",$mday,$mon+1,$year+1900,$hour,$min,$sec);

#create directory with the current date-time
my $dirname = $path."-".$date;
print "mkdir \"$dirname\"\n";
system("mkdir \"$dirname\"");

my @contents;
opendir MYDIR, $path;
@contents = grep !/^\.\.?$/,grep /.JPG/i, readdir MYDIR;
closedir MYDIR;
my $cont = 1;
my $size = @contents;
foreach my $file (@contents) {
   print "[".$cont."/".$size."] processing file=$file...\n";
   $cont++;
   my $image = Image::Resize->new($path."\\".$file);
   my $gd = $image->resize(2400, 2400);

   $file =~ s/.jpg//ig;
   my $new_file = $dirname."\\".$file."-new.jpg";
   open(DISPLAY, ">$new_file");
   binmode DISPLAY;
   print DISPLAY  $gd->jpeg();
   close(DISPLAY);
}
print "converted images in '$dirname' folder.\n";

#!/bin/bash

for i in *.[Mm][Pp][Gg]; do
   filename=${i//.MPG/}
   mencoder $i -ofps 25 -ovc xvid -oac mp3lame -lameopts abr:br=192 -srate 48000 -xvidencopts fixed_quant=4 -o $filename.avi
done

#!/bin/bash

for i in *.[Mm][Oo][Vv]; do
   filename=${i//.MOV/}

   mencoder $i -ovc lavc -lavcopts vcodec=mpeg4:vpass=1 -oac mp3lame -lameopts br=128:cbr:vol=0:mode=0 -o $filename.avi
   mencoder $i -ovc lavc -lavcopts vcodec=mpeg4:vpass=2 -oac mp3lame -lameopts br=128:cbr:vol=0:mode=0 -o $filename.avi
done

#order by keys
my %FILES;
foreach my $key (sort keys %FILES) {
   print "$key => $FILES{$key}\n";
}

#1. order by values
my %FILES;
my @keys = sort { $FILES{$b} cmp $FILES{$a} } keys %FILES;
foreach my $key (@keys) {
   print "$key => $FILES{$key}\n";
}

#2. order when the key is an IP address, e.g. 200.12.34.3 or 15.189.22.33
my %IP;
foreach my $key (sort {(pack'C*',split/\./,$a) cmp (pack'C*',split/\./,$b)} keys %IP) {
   print "IP = $key => $IP{$key}\n";
}

#3. numeric hashes
foreach my $key (sort { $processes{$b} <=> $processes{$a} } keys %processes) {
}

#!/usr/bin/perl

use strict;
use warnings;

permute(["x", "a", "b", "c"], []);

sub permute {
    my @items = @{ $_[0] };
    my @perms = @{ $_[1] };
    unless (@items) {
        verify(@perms);
    } else {
        my(@newitems,@newperms,$i);
        foreach $i (0 .. $#items) {
            @newitems = @items;
            @newperms = @perms;
            unshift(@newperms, splice(@newitems, $i, 1));
            permute([@newitems], [@newperms]);
        }
    }
}


sub verify {
    my @list = @_;
    print "@list\n";
}

#!/usr/bin/perl

use strict;
use warnings;

open(INFILE, "<$file") or die("cannot open file named $file\n");
print "creating dat file with *hot* vector positions named '$hname'...\n";
while () {
   if ($_ =~ /vec\[(\d*)\] = (\d*)/) {
      #do something
   }
}

close(INFILE);

#!/usr/bin/perl

use strict;
use warnings;

if (@ARGV != 1) { 
   print "missing FILE parameter. \nusage: perl create_gnuplot.pl FILE\n";
   exit;
}

my $file = $ARGV[0];
if (!($file =~ /.log$/)) {
   print "file extension MUST be .log. exiting.\n";
   exit;
}

print "opening file named '$file'...\n";

my $base = $file;
$base =~ s/.log$//;

#create a gnuplot
my $gname = "$base.plot";
print "creating new gnuplot file named '$gname'\n";
open(OUTFILE, ">$gname") or die("cannot open $gname\n");
print OUTFILE "set terminal postscript enhanced color\n";
print OUTFILE "set output \"$base.eps\"\n";

#print OUTFILE "set logscale y\n";
print OUTFILE "set key right top\n";
print OUTFILE "set ylabel \"\# of vector access\"\n";
print OUTFILE "set xlabel \"Index\"\n";

print OUTFILE "set style line 1 lt 5 lc rgb \"#0000FF\" lw 1\n";
print OUTFILE "plot \\\n";
print OUTFILE " \"$base.hot\" using 1:2 ls 1 with impulses title \"Accesses\"\n";
close(OUTFILE);

system("gnuplot $base.plot");
system("evince $base.eps");

#!/usr/bin/perl

use strict;
use warnings;

if (@ARGV != 1) {
  print "missing parameter DATA_DIR\nusage: perl iterate.pl DATA_DIR\n";
  exit;
}

my $path = "./".$ARGV[0];
print "reading directory $path ...\n";

my @dirs;
opendir DIR, $path;
@dirs = grep !/^\.\.?$/,grep /test/, readdir DIR;
closedir DIR;

foreach my $dir (sort @dirs) {
  print "directory read $dir\n";
  my @files;
  opendir FILE, $path.$dir;
  @files = grep !/^\.\.?$/,, readdir FILE;
  closedir FILE;
  foreach my $file (sort @files) {
  print "\tfile read $dir/$file\n";
  }  
}

if ($timestamp =~ /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}),(\d{3})$/) {
    $Y = $1; $M = $2; $D = $3; $H = $4; $MI = $5; $S = $6; $CCC = $7;
    print "format: d=$D m=$M y=$Y h=$H mi=$MI s=$S ccc=$CCC\n";
}

...
   compute(\%statespace, \%mc);


sub compute {
   my %statespace = %{ $_[0] };
   my %mc = %{ $_[1] };

   #...   
}

# checks if number is an integer greater than zero
sub isInteger { 
   my $d = shift;
   return 1 if ($d =~ /^(\d+)$/);
   return 0;
}

# validates integer or float numbers: i.e. 35 or 87.53
sub isIntegerOrFloat {
   my $p = shift;
   return 1 if ($p =~ /^\d+(\.\d+)?(\s*)$/gi);
   return 0;
}

use Time::Local;
use Cwd qw();

# checks if an interval of dates are correct, i.e., end is after start
# Parameters: first is the start time
#             second is the stop time
sub isValidDateInterval {
   my $d1_ = shift;
   my $d2_ = shift;
   
   my($yy1,$mm1,$dd1,$h1,$m1,$s1) = (0,0,0,0,0,0);
   $d1_ =~ m/^(\')(\d{4})\s(\d{2})\s(\d{2})\s(\d{2}):(\d{2}):(\d{2})(\')$/g;
   $yy1=$2; $mm1=$3; $dd1=$4; $h1=$5; $m1=$6; $s1=$7;
   #print "date1: $dd1/$mm1/$yy1 $h1:$m1:$s1\n";
   my $seconds1 = timelocal($s1,$m1,$h1,$dd1,$mm1-1,$yy1);
   #print "seconds1=$seconds1\n";
   
   my($yy2,$mm2,$dd2,$h2,$m2,$s2) = (0,0,0,0,0,0);
   $d2_ =~ m/^(\')(\d{4})\s(\d{2})\s(\d{2})\s(\d{2}):(\d{2}):(\d{2})(\')$/g;
   $yy2=$2; $mm2=$3; $dd2=$4; $h2=$5; $m2=$6; $s2=$7;
   #print "date2: $dd2/$mm2/$yy2 $h2:$m2:$s2\n";
   my $seconds2 = timelocal($s2,$m2,$h2,$dd2,$mm2-1,$yy2);
   #print "seconds2=$seconds2\n";

   #print "diff=".($seconds2-$seconds1)."\n";
   return 1 if ($seconds2-$seconds1>0);
   return 0;
}

use File::Copy;
move("mc-$target_year.txt", "output/mc-$target_year.txt") or die "Move mc-$target_year.txt -> output/mc-$target_year.txt failed: $!";

#!/usr/bin/perl

use strict;
use warnings;

use XML::LibXML;

if (@ARGV != 1) { 
   print "missing FILE parameter. \nusage: perl test.pl FILE\n";
   exit;
}

my $file = $ARGV[0];

my $dom = XML::LibXML->load_xml(location => $file);
my $parser = XML::LibXML->new();
my $tree = $parser->parse_file($file);
my $root = $tree->getDocumentElement;

foreach my $id ($root->findnodes('//AMC/PROBABILITES_SEQUENCES/SEQUENCE')) {
   my $prob =  $id->findvalue('@PROBABILITE');
   print "Probability: $prob\n";
   foreach my $trans ($id->findnodes('./BRANCHE/TRANSITION')) {
      my $objet =  $trans->findvalue('@OBJET');
      my $realization = $trans->findvalue('@TRANS');
      print "\tObject: $objet\n";
      print "\tRealization: $realization\n";
   }
}

XML test file:

<AMC>
 <PROBABILITES_SEQUENCES>
  <SEQUENCE TRONQUEE="CIBLE" PROBABILITE="0.22983">
   <BRANCHE DATE_FIN_MOY="2595.97313362042">
    <TRANSITION OBJET="acquire" REGLE="success_undetected" TRANS="real"/>
   </BRANCHE>
   <BRANCHE DATE_FIN_MOY="2595.97313362042">
    <TRANSITION OBJET="data" REGLE="real_nd" TRANS="no_realization"/>
    <TRANSITION OBJET="abs" REGLE="real_nd" TRANS="nd_real"/>
    <TRANSITION OBJET="muscular" REGLE="real_nd" TRANS="no_realization"/>
   </BRANCHE>
  </SEQUENCE>
  <SEQUENCE TRONQUEE="CIBLE" PROBABILITE="0.10047">
   <BRANCHE DATE_FIN_MOY="2588.08094838842">
    <TRANSITION OBJET="balance" REGLE="success_undetected" TRANS="real"/>
   </BRANCHE>
   <BRANCHE DATE_FIN_MOY="2588.08094838842">
    <TRANSITION OBJET="data" REGLE="real_nd" TRANS="nd_real"/>
    <TRANSITION OBJET="abs" REGLE="real_nd" TRANS="nd_real"/>
    <TRANSITION OBJET="muscular" REGLE="real_nd" TRANS="no_realization"/>
   </BRANCHE>
  </SEQUENCE>
 </PROBABILITES_SEQUENCES>
</AMC>

#!/usr/bin/perl

use strict;
use warnings;

#incredible permutation algorithm! See Knuth.
my %parameters = (
   "123.456"     => "1;2;10",
   "123.457"     => "2;8",
   "123.458"     => "3;12",
   "123.459"     => "5;10",
);

# start of permutation algorithm for creating all the possible scenarios from the parameters (above)
my $tam = keys %parameters;

my @scenarios;
my $cont = 0;
my @keys;
foreach my $key (keys %parameters) {
   my @arr = split(";", $parameters{$key});
   $scenarios[$cont] = @arr; #gets the size of the variations
   $keys[$cont] = $key;
   $cont++;
}

my @pgs;
#initialisation
for (my $i=0;$i<$tam;$i++) { $pgs[$i] = 0; }
my @vv;
$vv[0] = $scenarios[0];
for (my $i=1;$i<$tam;$i++) { $vv[$i] = $scenarios[$i] - 1; }
#algorithm 'per se'
$pgs[$tam-1] = -1;
my $a = $tam - 1;
my $nz;
$cont = 0;
my @idx_scenarios = ();
while ($pgs[0] != $vv[0]) {
   if ($pgs[$a] < $vv[$a]) {
       $pgs[$a] = $pgs[$a] + 1;
       $a = $tam - 1;
       if ($pgs[0] != $vv[0]) {
           my $str = "";
           for (my $i = 0; $i < $tam; $i++) {
               $str .= "$pgs[$i]";
               $str .= $i==$tam-1?"":";";
           }
           #print "".($cont++).": $str\n";
           push @idx_scenarios, $str;
       }
   } else {
       $a--;
       #restart from a+1 till the end with zeroes
       for (my $i = $a + 1; $i < $tam; $i++) {
           $nz = ($pgs[$i] != -1) ? 0 : -1;
           $pgs[$i] = $nz;
       }
   }
}

foreach (my $i=0; $i < @keys; $i++) {
   print "Key: $keys[$i] Size: $scenarios[$i]\n";
}
print "\nIndices: \n";
print "A total of ".(@idx_scenarios)." scenarios was created:\n";
$cont = 1;
foreach my $elem (@idx_scenarios) {
   print "[".($cont++)."]: $elem\n";
}

#accessing values
print "\nScenarios: ";
$cont = 0;
print "\n";
for (my $i=0; $i < @idx_scenarios; $i++) { 
   $cont++;
   my @aux = split(";", $idx_scenarios[$i]);
   print "[".$cont."] ";
   for (my $j=0; $j < @aux; $j++) {
      my @elem = split(";",$parameters{$keys[$j]});
      print "$keys[$j]=$elem[$aux[$j]]";
      print ($j==@aux-1?"":", ");
   }
   print "\n";
}

require './bdmp-routines.pl';

1;

q1
n9
-2 2 0 0 0 0 0 0 0
0 -6 1 5 0 0 0 0 0
0 0 -10 0 10 0 0 0 0
0 0 0 -6 6 0 0 0 0
5 0 0 0 -13 3 5 0 0
0 0 0 0 0 -5 0 5 0
0 0 0 0 0 0 -4 4 0
0 0 0 5 0 0 0 -7 2
0 0 0 0 5 0 0 0 -5

#include <vector>
#include <list>
#include <iostream>
#include <iomanip>
#include <fstream>

#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <time.h>
#include <assert.h>


using namespace std;

//for minimum and maximum float value
#include <float.h>

std::vector<int> removeequals(int *y, int size) {
   std::list<int> l;
   for (int i = 0; i < size; i++) {
      l.push_back(y[i]);
   }
   l.sort();
   l.unique();
   std::vector<int> v(l.begin(), l.end());
   return v;
}

int main(char argc, char** argv) {
    
   if (argc != 1) {
      printf("Usage: ./list\n\n");
      //printf("FILE file name to be open\nmodel - model to be used\nruns - number of executions\n");
      exit(0);
   }
   int *y = (int*)malloc(sizeof(int)*10);
   y[0] = 15;
   y[1] = 11;
   y[2] = 11;
   y[3] = 12;
   y[4] = 11;
   y[5] = 14;
   y[6] = 11;
   y[7] = 14;
   y[8] = 12;
   y[9] = 11;

   std::vector<int> newv = removeequals(y, 10);
   for (int i = 0; i < newv.size(); i++) {
      int value = (int) newv[i];
      cout << "value["<<i<<"]=" << value << endl;
   }
   return 0;
}

string StringUtils::removechar(const char r, const string& in) {
   string out = in;
   while (out.find(r) != string::npos) {
      string::size_type pos = out.find(r);
      out.erase(pos,1);
   }
   return out;
}

string lcase(const string& in) {
   string out = in;
   std::transform(out.begin(), out.end(), out.begin(), ::tolower);
   return out;
}

string ucase(const string& in) {
   string out = in;
   std::transform(out.begin(), out.end(), out.begin(), ::toupper);
   return out;
}

n:=2;
l:=1;
r:=3;
p:=5;
t:=4;

with(linalg):
Q := array(sparse,1..96,1..96):
read `mobile2agents.maple`:
b := array(sparse,1..96):
for i to 96 do
    Q[i,96] := 1.0
od:
b[96] := 1:
QT := transpose(Q):
P := linsolve(QT,b);

n:=2;
l:=1;
r:=3;
p:=5;
t:=4;

with(linalg):
Q := array(sparse,1..96,1..96):
read `mobile2agents.maple`:
b := array(sparse,1..96):
for i to 96 do
    Q[i,96] := 1.0
od:
b[96] := 1:
QT := transpose(Q):
P := linsolve(QT,b);

#author: Ricardo M. Czekster
#created: 01/27/2010

clear;

#infinitesimal generator definition
#every line must sums to zero (diagonal has the negative sum of the line)
Q = [-109.3154, 100, 0, 0, 0, 9.1854, 0, 0, 0.13, 0, 0;
200, -205.13, 5, 0, 0, 0, 0, 0, 0, 0, 0.13;
0, 0.0004, -135.0004, 8, 0, 0, 127, 0, 0, 0, 0;
0, 0, 41.58, -58.58, 17, 0, 0, 0, 0, 0, 0;
0, 0, 0, 1.69, -3.04, 1.35, 0, 0, 0, 0, 0;
87, 0, 0, 0, 0.18, -87.18, 0, 0, 0, 0, 0;
0, 0, 14, 0, 0, 0, -17.5, 3.5, 0, 0, 0;
0, 0, 0, 0, 0, 0, 4.2336, -104.4436, 100, 0.21, 0;
100, 0, 0, 0, 0, 0, 0, 419.58, -519.58, 0, 0;
0, 0, 0, 0, 0, 0, 0, 2.77, 0, -10.57, 7.8;
0, 0.013, 0, 0, 0, 0, 0, 0, 0, 30.24, -30.253];

#just saves original matrix before manipulation (uncomment here if needed)
#O = Q;

#last column set to one
for i=1:11
  Q(i,11) = 1;
endfor

b = [0; 0; 0; 0; 0; 0; 0; 0; 0; 0; 1];

#transpose matrix Q
QT = Q';

#linear solution (results in vector P)
P = QT \ b;

#probability output (times 100)
#P *= 100;

#create a file with .m extension

1;

start = 1;
lmax = 100;

X_t = zeros(1,lmax);

#create a file named out.txt with n and X as values from start to lmax
filename = "out.txt";
fid = fopen (filename, "w+");
fprintf(fid,"#n X\n");

i = 1;
for n=start:lmax

   fprintf(fid,"%d %f\n",n,X_t(i));

   i = i + 1;
endfor
fclose(fid);

\usepackage{rotating}

...

\begin{tabular}{|r|r|}\hline
\begin{sideways}Paper\end{sideways} &\begin{sideways}Static\end{sideways} \\
\hline
HAR1994j & Journal \\
SWRT1996c & Conference \\
\hline
\end{tabular}

AnnArbor
Antibes
Bergen
Berkeley
Berlin
Boadilla
CambridgeUS
Copenhagen
Darmstadt
Dresden
Frankfurt
Goettingen
Hannover
Ilmenau
JuanLesPins
Luebeck
Madrid
Malmoe
Marburg
Montpellier
PaloAlto
Pittsburgh
Rochester
Singapore
Stuttgart
Szeged
Warsaw

#
# Makefile of XXXX XXXX
# Changed by xxxx@xxx.xxxxx.xx
#

CPP=g++
INCLUDE_DIR = ./include
BIN_DIR = .
OBJ_DIR = .
LIB_DIR = ./lib

# The options of compilation (debug or optimization)
CPPFLAGS= -I/usr/local/include -Wno-non-virtual-dtor -Wno-deprecated -O3 -I$(INCLUDE_DIR)

# The options of linkage
LDFLAGS= -L$(LIB_DIR) -lyourlib

SOURCES := $(patsubst %.cpp,%.o,$(wildcard *.cpp))
OBJECTS=$(SOURCES:.cpp=.o)
EXECUTABLE=hello

compile: $(SOURCES) $(EXECUTABLE)
	
$(EXECUTABLE): $(OBJECTS)
	$(CPP) $(LDFLAGS) $(OBJECTS) -o $@

.cpp.o:
	$(CPP) $(CPPFLAGS) -c $< -o $@

all: compile

clean:
	rm -f *.o hello

for i in *.wav; do lame --preset standard $i `basename $i .wav`.mp3; done

psbook IN OUT
psnup -pa4 -2 IN OUT

gs -dBATCH -dNOPAUSE -q -sDEVICE=pdfwrite -sOutputFile=output.pdf file1.pdf file2.pdf 

iconv --from-code=ISO-8859-1 --to-code=UTF-8 ./file.txt > out.txt

Atendimento no Caixa.Queue.NumberInQueue.*\s*\.\d*

set key {  left | right | top | bottom | outside | below }

plot "ad.txt" using 1:2 axes x1y2 ls 1 with boxes title "Experimento 2 - 9"

plot \
 "ad.txt" using 1:($3-$2) with boxes title "Experimento [3 - 2]", \
 "" using 1:2 with lines title "Experimento 2"

arquivo "ad.txt" (observe que ele contém 3 colunas, ou seja, $1, $2 e $3):
1 10 2
2 15 5
3 21 10
4 15 8
5 11 10
6 9 3
...

set term postscript eps color
set output "ad.eps"

set logscale xy
set xrange[9.5:16.5]
set key right bottom
set grid

set style line 1 lt 1 lc rgb "red" lw 3
set style line 2 lt 2 lc rgb "blue" lw 1
set style line 3 lt 3 lc rgb "yellow" lw 3
set style line 4 lt 4 lc rgb "#aabbcc" lw 1
set style line 5 lt 5 lc rgb "grey" lw 1

plot \
 "ad.txt" using 1:2 ls 1 with lines title "Experimento 1", \
 "" using 1:3 ls 2 with lines title "Experimento 2", \
 "" using 1:4 ls 3 with lines title "Experimento 3", \
 "" using 1:5 ls 4 with lines title "Experimento 4", \
 "" using 1:6 ls 5 with lines title "Experimento 5"

set term postscript eps color
set output "results.eps"

set multiplot layout 1, 2 title "Resultados do Modelo Mestre-Escravo"

######################################################################
set title "Tempo (s) - Escala loglog"

set logscale xy
set xrange[4.5:10.5]
set key left top

plot \
 "slaves.txt" using 1:2 with lines title "Exp. 1", \
 "" using 1:3 with lines title "Experimento 2", \
 "" using 1:4 with lines title "Experimento 3", \
 "" using 1:5 with lines title "Experimento 4", \
 "" using 1:6 with lines title "Experimento 5"

######################################################################
set title "Memoria (Kb) - Escala loglog"

set logscale xy
set xrange[4.5:10.5]
set key left top

plot \
 "slaves.txt" using 1:11 ls 1 with lines title "Exp. 1", \
 "" using 1:12 ls 3 with lines title "Exp. 3", \
 "" using 1:13 ls 5 with lines title "Exp. 5", \
 "" using 1:14 ls 6 with lines title "Exp. 6", \
 "" using 1:15 ls 7 with lines title "Exp. 7", \
 "" using 1:16 ls 8 with lines title "Exp. 8"

set terminal gif animate delay 1
set output "floripa_certo.gif"

#set view 60,60
set view 60,45
#set view 0,180
#set nosurface
#set contour base
#set dgrid3d
set surface
set pm3d
set cntrparam levels auto 30
splot "floripa_certo_1.dat" matrix with lines
splot "floripa_certo_501.dat" matrix with lines 
splot "floripa_certo_1001.dat" matrix with lines 

set terminal postscript
set output "data.ps"
unset key
NX=1; NY=3
DX=0.01; DY=0.01; SX=0.85; SY=0.25
set bmargin DX; set tmargin DX; set lmargin DY; set rmargin DY
## set the margin of each side of a plot as small as possible
## to connect each plot without space
set size SX*NX+DX*1.5,SY*NY+DY*1.8
set multiplot
## First Figure-bottom
set size SX,SY
set xrange [0:140]
set yrange [-0.9:0.9]
set ytic -0.6,0.3,0.6 ### from -0.6 to 0.6 with 0.3 interval
set origin DX,DY;
plot sin(x)
###Second Figure-middle
set origin DX,DY+SY;
unset xtics
plot sin(x**2)
##- Third Figure-top
set origin DX,DY+SY*2
plot cos(x)
unset multiplot

#used for the transpose function
library(data.table)

#remove all objects defined earlier
rm(list=ls(all=TRUE))
#remove all plots in the environment
graphics.off()

#set working directory
setwd("C:\\Users\\stout\\Desktop\\Rscripts")
outputfile = "output-longstudy.txt"
#read .csv file
data <- read.table(outputfile, header=FALSE, sep=";")
#count entries
maxf = max(count.fields(outputfile, sep = ';'))
#read to variable, adding "V#" into each column
data <- read.table(outputfile, header = FALSE, sep = ";",  
           col.names = paste0("V",seq_len(maxf)), fill = TRUE)

#save first column with the path names
pathnames <- data[,1]
#remove first column
data$V1 <- NULL
#transpose the data, because each column corresponds to a probab. over time
t_data <- transpose(data)
#---------------------------------------------

#summary of one column (named V4)
summary(t_data$V4)
#summary of all data
summary(data)

graphics.off()
#selecting only observations in column 'V5' higher than 0.001
high_prob <- data[data$V5 > 0.001, ]
#plotting a boxplot on that variable
boxplot(high_prob)

#plotting two simple lines on column 'V5'
plot(t_data$V5,type = "l", lty = 1, col="red")
lines(t_data$V2,type = "l", lty = 1, col="blue")

##############
graphics.off()
#plotting MULTIPLE data series using matplot (use of cbind function)
matplot(cbind(t_data1,t_data2), type = c("l"),main="Ensemble of attack paths",cex.main=1.5,
        pch=1,col = 2:32,xlim=c(1,36), xaxs="i", yaxs="i",
        ylim=c(0,0.011),ylab="Path probability",xlab="Time (in hours)",axes=F)
box()
axis(1, seq(0,36,1),las=1, cex.axis=0.75, font=1)
#use in conjunction with ylim (above) --> 0.011
axis(2, seq(0,0.011,0.01),cex.axis=0.85, las=2)