Free dive software for linux

Dive Into Python is a free Python tutorial, written by Mark Pilgrim.

Dive Into Python book lives at http://diveintopython.org/. If youre reading it somewhere else, you may not have the latest version.

Permission is granted to copy, distribute, and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in Appendix G, GNU Free Documentation License.

The example programs in this book are free software; you can redistribute and/or modify them under the terms of the Python license as published by the Python Software Foundation. A copy of the license is included in Appendix H, Python license.

Data::Diver is a simple, ad-hoc access to elements of deeply nested structures.

SUMMARY

Data::Diver provides the Dive() and DiveVal() functions for ad-hoc access to elements of deeply nested data structures, and the DiveRef(), DiveError(), DiveClear(), and DiveDie() support functions.

SYNOPSIS

use Data::Diver qw( Dive DiveRef DiveError );

my $root= {
top => [
{ first => 1 },
{ second => {
key => [
0, 1, 2, {
three => {
exists => yes,
},
},
],
},
},
],
};

# Sets $value to yes
# ( $root->{top}[1]{second}{key}[3]{three}{exists} ):
my $value= Dive( $root, qw( top 1 second key 3 three exists ) );

# Sets $value to undef() because "missing" doesnt exist:
$value= Dive( $root, qw( top 1 second key 3 three missing ) );

# Sets $value to undef() because
# $root->{top}[1]{second}{key}[4] is off the end of the array:
$value= Dive( $root, qw( top 1 second key 4 ... ) );

# Sets $value to undef() because
# $root->{top}[1]{second}{key}[-5] would be a fatal error:
$value= Dive( $root, qw( top 1 second key -5 ... ) );

# Sets $ref to $root->{top}[9]{new}{sub} (which grows
# @{ $root->{top} } and autovifies two anonymous hashes):
my $ref= DiveRef( $root, qw( top 9 new sub ) );

# die()s because "other" isnt a valid number:
$ref= DiveRef( $root, qw( top other ... ) );

# Does: $root->{num}{1}{2}= 3;
# (Autovivifies hashes despite the numeric keys.)
DiveVal( $root, ( qw( num 1 2 ) ) ) = 3;
# Same thing:
${ DiveRef( $root, num, 1, 2 ) } = 3;

# Retrieves above value, $value= 3:
$value= DiveVal( $root, num, 1, 2 );
# Same thing:
$value= ${ DiveRef( $root, ( qw( num 1 2 ) ) ) };

# Tries to do $root->{top}{1} and dies
# because $root->{top} is an array reference:
DiveRef( $root, top, 1 );

# To only autovivify at the last step:
$ref= DiveRef(
Dive( $root, qw( top 1 second key 3 three ) ),
missing );
if( $ref ) {
$$ref= me too
} else {
my( $nestedRef, $svKey, $errDesc )= DiveError();
die "Couldnt dereference $nestedRef via $$svKey: $errDescn";
}

PDL::Indexing Perl module contains a tutorial on how to index piddles.

This manpage should serve as a first tutorial on the indexing and threading features of PDL.

This manpage is still in alpha development and not yet complete. "Meta" comments that point out deficiencies/omissions of this document will be surrounded by square brackets ([]), e.g. [ Hopefully I will be able to remove this paragraph at some time in the future ]. Furthermore, it is possible that there are errors in the code examples. Please report any errors to Christian Soeller (c.soeller@auckland.ac.nz).

Still to be done are (please bear with us and/or ask on the mailing list, see PDL::FAQ):

document perl level threading
threadids
update and correct description of slice
new functions in slice.pd (affine, lag, splitdim)
reworking of paragraph on explicit threading

Indexing and threading with PDL

A lot of the flexibility and power of PDL relies on the indexing and looping features of the perl extension. Indexing allows access to the data of a pdl object in a very flexible way. Threading provides efficient implicit looping functionality (since the loops are implemented as optimized C code).

Pdl objects (later often called "pdls") are perl objects that represent multidimensional arrays and operations on those. In contrast to simple perl @x style lists the array data is compactly stored in a single block of memory thus taking up a lot less memory and enabling use of fast C code to implement operations (e.g. addition, etc) on pdls.

pdls can have children

Central to many of the indexing capabilities of PDL are the relation of "parent" and "child" between pdls. Many of the indexing commands create a new pdl from an existing pdl. The new pdl is the "child" and the old one is the "parent". The data of the new pdl is defined by a transformation that specifies how to generate (compute) its data from the parents data. The relation between the child pdl and its parent are often bidirectional, meaning that changes in the childs data are propagated back to the parent. (Note: You see, we are aiming in our terminology already towards the new dataflow features. The kind of dataflow that is used by the indexing commands (about which you will learn in a minute) is always in operation, not only when you have explicitly switched on dataflow in your pdl by saying $a->doflow. For further information about data flow check the dataflow manpage.)

Another way to interpret the pdls created by our indexing commands is to view them as a kind of intelligent pointer that points back to some portion or all of its parents data. Therefore, it is not surprising that the parents data (or a portion of it) changes when manipulated through this "pointer". After these introductory remarks that hopefully prepared you for what is coming (rather than confuse you too much) we are going to dive right in and start with a description of the indexing commands and some typical examples how they might be used in PDL programs. We will further illustrate the pointer/dataflow analogies in the context of some of the examples later on.

There are two different implementations of this ``smart pointer relationship: the first one, which is a little slower but works for any transformation is simply to do the transformation forwards and backwards as necessary. The other is to consider the child piddle a ``virtual piddle, which only stores a pointer to the parent and access information so that routines which use the child piddle actually directly access the data in the parent. If the virtual piddle is given to a routine which cannot use it, PDL transparently physicalizes the virtual piddle before letting the routine use it.

Currently (1.94_01) all transformations which are ``affine, i.e. the indices of the data item in the parent piddle are determined by a linear transformation (+ constant) from the indices of the child piddle result in virtual piddles. All other indexing routines (e.g. ->index(...)) result in physical piddles. All routines compiled by PP can accept affine piddles (except those routines that pass pointers to external library functions).

Note that whether something is affine or not does not affect the semantics of what you do in any way: both

$a->index(...) .= 5;
$a->slice(...) .= 5;

change the data in $a. The affinity does, however, have a significant impact on memory usage and performance.

Devel::GDB::Reflect is a reflection API for GDB/C++.

SYNOPSIS

use Devel::GDB;
use Devel::GDB::Reflect;

my $gdb = new Devel::GDB( -file => $foo );
my $reflector = new Devel::GDB::Reflect( $gdb );

print $gdb->get( "b foo.c:123" );
$gdb->print( "myVariable" );

Devel::GDB::Reflect provides a reflection API for GDB/C++, which can be used to recursively print the contents of STL data structures (vector, set, map, etc.) within a GDB session. It is not limited to STL, however; you can write your own delegates for printing custom container types.

The module implements the functionality used by the gdb++ script, which serves as a wrapper around GDB. You should probably familiarize yourself with the basic functionality of this script first, before diving into the gory details presented here.

Global Variables

The following global variables control the behavior of the "print" method.

$Devel::GDB::Reflect::INDENT

The number of spaces to indent at each level of recursion. Defaults to 4.

$Devel::GDB::Reflect::MAX_DEPTH

The maximum recursion depth. Defaults to 5.

$Devel::GDB::Reflect::MAX_WIDTH

The maximum number of elements to show from a given container. Defaults to 10.

Danger from the deep (aka dangerdeep) is a Free / Open Source World War II german submarine simulation.
It is currently available for Linux/i386 and Windows, but since it uses SDL/OpenGL it should be portable to other operating systems or platforms. (If anyone whishes to port it, please contact us.)
This game is planned as tactical simulation and will be as realistic as our time and knowledge of physics allows. Its current state is ALPHA, but it is playable.
If anyone wants to contribute in development, youre welcome, just email the dangerdeep-devel mailing list. Contributing binary packages for various Linux distributions would also be much appreciated.
To get help with the game you should visit our public forum.
The game has support for multiple languages but currently only English, Italian and German are implemented. It is written in C++ with the use of the STL.
Danger from the Deep is released under the GNU General Public License. The project is hosted on SourceForge, a great supporter of the Open Source community.
Main features:
- simple main menu
- user interface (some items missing)
- basic world simulation, night and day
- realistic water and cloud simulation
- one type of destroyer, one battleship, one aircraft carrier, three subs, eight civilian ship types
- steering, firing, diving, periscope use
- free look engine for testing, periscope, UZO (aiming binoculars), bridge view
- console for logging purposes
- basic physics (acceleration, steering, firing)
- basic destroyer AI (follow, throw depth charges)
- simple vehicle preview
- mission parsing via text files, you can create your own custom missions
- tonnage recording
- log book

GalaxyMage is a free, open-source tactical/strategic RPG for Windows, Linux, and Macintosh.

The tipical RPG game system is a type of role-playing game where turn-based battles are fought on a 3D map. Examples of commercial tactical RPGs include Final Fantasy Tactics, Vandal Hearts, and Disgaea: Hour of Darkness.

Our goal is to make GalaxyMage a game that is relatively simple to pick up and play -- you can dive right in without getting bogged down in the details of the battle mechanics -- but to also allow for a lot of character development and customization.

We also intend to create a unique, advanced AI system that allows enemy units to work together as a team and employ a wide variety of strategies. And eventually, we plan on adding networked multiplayer support.

HPCToolkit is an open-source suite of multi-platform tools for profile-based performance analysis of applications. The figure provides an overview of the toolkit components and their relationships.
Main features:
- hpcrun: a tool for profiling executions of unmodified application binaries using statistical sampling of hardware performance counters.
- hpcprof & xprof: tools for interpeting sample-based execution profiles and relating them back to program source lines.
- bloop: a tool for analyzing application binaries to recover program structure; namely, to identify where loops are present and what program source lines they contain.
- hpcview: a tool for correlating program structure information, multiple sample-based performance profiles, and program source code to produce a performance database.
- hpcviewer: a java-based GUI for exploring databases consisting of performance information correlated with program source.
A program called hpcview is at the toolkits center. It takes performance profiles, program structure information, and, under the direction of a configuration file, correlates it with application source code to produce a browsable performance database.
hpcview also enables the user to define expressions to compute derived metrics as functions other metrics already defined (e.g. measured metrics read from data files or previously-computed derived metrics).
Performance databases are explored using our Java-based hpcviewer user interface that enables one to explore an applications performance data in a top-down fashion and enables one to easily navigate back and forth between performance data and source code.
The user interface presents performance data in a hierarchical display. At any time, you are looking at some program context (program, file, procedure, loop, or line). Also displayed is the data for both the parent and the children of the current context. Up and down arrows on the lines of the display are used to walk the hierarchy.
In order to speed up top-down analysis, the interface also provides `flatten and `un-flatten buttons. Their icons hint at their function. `Flatten modifies the hierarchy by eliding non-leaf children of the current node and replacing them with the grandchildren.
Unflatten reverses this. Since the tables are sorted, the flatten operation makes short work of diving into the program from the top to identify the most important files, procedures, loops and statements.
Performance data manipulated by hpcview can come from any source, as long as the profile data can be translated or saved directly to a standard, profile-like input format. To date, the principal sources of input data for hpcview have been hardware performance counter profiles.
Such profiles are generated by setting up a hardware counter to monitor events of interest (e.g., primary cache misses), to generate a trap when the counter overflows, and then to histogram the program counter values at which these traps occur. For Linux, we developed the hpcrun tool to collect profiles by sampling hardware performance counters.
This tool uses UTKs PAPI library for access to hardware performance counters. A second tool, hpcprof is used to map profiles collected using hpcrun back to program source lines. hpcprof is based on code from Curt Janssens cprof/vprof profiler. On operating systems other than Linux, we use vendor-supplied tools to collect profile data. On MIPS+Irix platforms, we use SGIs ssrun tool to collect profiles. On Alpha+Tru64, we use either with Compaqs uprofile or DCPI utilities for this purpose.
hpcview and hpcviewer can be used to view profile-like data of any type, not just data sampled from hardware performance counters. To analyze one program that contained many register spills, we built a perl script to examine assembly code generated by the SGI compilers for MIPS+Irix and create profiles that map register spills back to source code lines.
To facilitate automation, the programs in HPCToolkit are intended to be run using scripts and configuration files. Once these are set up, rerunning the program to collect new data, and all of the steps that go into generating a browsable dataset can be completely automated. The scripts automate the collection of data and conversion of profile data into a common, XML-based format.
Other performance tools (e.g. SGIs ssrun) report performance data at the line, procedure, and program level. However, since much of the time in scientific programs is spent in loops; having data at the loop level as well is critical to facilitate performance tuning.
For this reason, HPCToolkit includes a binary analyzer bloop that extracts loop nesting structure from application binaries and uses symbol table line map information to map this structure back to the source programs level. Because bloop works on binaries, this process is independent of the language used (though in practice it can be somewhat compiler dependent).
The loop nesting structure information produced by bloop enables hpcview to associate performance data with each loop in a program without incurring any additional overhead for data collection during program execution.
Supported platforms: Pentium+Linux, Opteron+Linux, Athlon+Linux, Itanium+Linux, Alpha+Tru64 and MIPS+Irix.
HPCToolkit is open-source software released with a BSD-like license.