Free convtools 0.08 software for linux

Audio::ConvTools is a API to convert audio files from/to mp3 ogg and wav.

SYNOPSIS

use Audio::ConvTools;
use Audio::ConvTools qw/:DEFAULT :Tmp :Log/;

$status = ogg2mp3(file.ogg);
$status = ogg2wav(file.ogg);
$status = ogg2wav(in.ogg, out.wav);
$status = mp32ogg(file.mp3);
$status = mp32wav(file.mp3);
$status = mp32wav(in.mp3, out.wav);
$status = wav2ogg(file.wav);
$status = wav2ogg(in.wav, out.ogg);
$status = wav2mp3(file.wav);
$status = wav2mp3(in.wav, out.mp3);

Audio::ConvTools::logMsg(This is a log message);
Audio::ConvTools::errMsg(This is an error message);

$tmp = Audio::ConvTools::getTmpFile(.wav);
Audio::ConvTools::destroyTmpFile($tmp);

QtOIDUA is a graphical user interface for OIDUA for Linux and Mac OS X written in C++ using Qt. It is completely free and open source, and is licensed under the GNU GPL.
QtOIDUA supports all the features of OIDUA and makes it easy to create fields, add directories, choose colors, and set options. QtOIDUA also allows you to save list configuration files, so you can easily recreate any previously created list.
OIDUA is an Audiolist clone by Sylvester Johansson and Mattias Paivarinta. Its purpose is to generate lists of audio files based on their location in your directory tree.
Enhancements:
- Added options that allow the user to specify whether they want a new file, the previously opened file, or a specific file to be loaded on startup.
- Fixed a bug that caused options to be enabled/disabled improperly when the output.db option was checked while OIDUA was downgraded to a version that didnt support it.
- Slightly resized the icons image so it better fits in both Linux and OS X.
- Icon now displayed in Linux if supported by the users window manager.
- No longer necessary to manually copy the icon into the application bundle and edit the Info.plist file when compiling in OS X.
- Added logo to the About window.
- Various code changes and cleanups.

AI::DecisionTree is Perl module for automatically Learns Decision Trees.

SYNOPSIS

use AI::DecisionTree;
my $dtree = new AI::DecisionTree;

# A set of training data for deciding whether to play tennis
$dtree->add_instance
(attributes => {outlook => sunny,
temperature => hot,
humidity => high},
result => no);

$dtree->add_instance
(attributes => {outlook => overcast,
temperature => hot,
humidity => normal},
result => yes);

... repeat for several more instances, then:
$dtree->train;

# Find results for unseen instances
my $result = $dtree->get_result
(attributes => {outlook => sunny,
temperature => hot,
humidity => normal});

The AI::DecisionTree module automatically creates so-called "decision trees" to explain a set of training data. A decision tree is a kind of categorizer that use a flowchart-like process for categorizing new instances. For instance, a learned decision tree might look like the following, which classifies for the concept "play tennis":

OUTLOOK
/ |
/ |
/ |
sunny/ overcast rainy
/ |
HUMIDITY | WIND
/ *no* /
/ /
high/ normal /
/ strong/ weak
*no* *yes* /
*no* *yes*

(This example, and the inspiration for the AI::DecisionTree module, come directly from Tom Mitchells excellent book "Machine Learning", available from McGraw Hill.)

A decision tree like this one can be learned from training data, and then applied to previously unseen data to obtain results that are consistent with the training data.

The usual goal of a decision tree is to somehow encapsulate the training data in the smallest possible tree. This is motivated by an "Occams Razor" philosophy, in which the simplest possible explanation for a set of phenomena should be preferred over other explanations. Also, small trees will make decisions faster than large trees, and they are much easier for a human to look at and understand. One of the biggest reasons for using a decision tree instead of many other machine learning techniques is that a decision tree is a much more scrutable decision maker than, say, a neural network.

The current implementation of this module uses an extremely simple method for creating the decision tree based on the training instances. It uses an Information Gain metric (based on expected reduction in entropy) to select the "most informative" attribute at each node in the tree. This is essentially the ID3 algorithm, developed by J. R. Quinlan in 1986. The idea is that the attribute with the highest Information Gain will (probably) be the best attribute to split the tree on at each point if were interested in making small trees.

The Inline::CPP2XS Perl module is deprecated. Please install the latest version of InlineX::CPP2XS.

SYNOPSIS

use Inline::CPP2XS qw(cpp2xs);

my $module_name = MY::XS_MOD;
my $package_name = MY::XS_MOD;

# $build_dir is an optional third arg
my $build_dir = /some/where/else;

# $config_opts is an optional fourth arg (hash reference)
my $config_opts = {AUTOWRAP => 1,
AUTO_INCLUDE => my_header.h,
TYPEMAPS => [my_typemap],
INC => -Imy/includes/dir,
};

# Create /some/where/else/XS_MOD.xs from ./src/XS_MOD.cpp
# Will also create the typemap file /some/where/else/CPP.map
# if that file is going to be needed to build the module:
cpp2xs($module_name, $package_name, $build_dir);

# Or create XS_MOD.xs (and CPP.map, if needed) in the cwd:
cpp2xs($module_name, $package_name);

The optional fourth arg (a reference to a hash) is to enable the writing of XS files using Inline::CPPs autowrap capability. It currently only accommodates 4 hash keys - AUTOWRAP, INC, AUTO_INCLUDE, and TYPEMAPS - though other keys may be added in in the future to accommodate additional functionality.

# Create XS_MOD.xs in the cwd, using the AUTOWRAP feature:
cpp2xs($module_name, $package_name, ., $config_opts);

Dont feed an actual Inline::CPP script to this module - it wont be able to parse it. It is capable of parsing correctly only that CPP code that is suitable for inclusion in an Inline::CPP script.

For example, here is a simple Inline::CPP script:

use warnings;
use Inline CPP => Config =>
BUILD_NOISY => 1,
CLEAN_AFTER_BUILD => 0;
use Inline CPP =><<less