portelli/LatAnalyze
1
0
Fork 0
mirror of https://github.com/aportelli/LatAnalyze.git synced 2024-11-10 00:45:36 +00:00
Code Releases Activity

Merge branch 'release/3.3'

Browse Source
This commit is contained in:
Antonin Portelli 2017-11-16 19:33:05 +00:00
commit d5b743b985
20 changed files with 608 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -35,3 +35,7 @@ ci-scripts/local/*
.idea/*
CMakeLists.txt
cmake-build-debug/*
# VS Code Studio stuff
.vscode
*.code-workspace

22
Readme.md
View File

@ -55,6 +55,28 @@ in the `ci-scripts` directory where `<prefix>` is where you want LatAnalyze (and
For a more customised installation, one first needs to generate the build system by running `./bootstrap.sh` in the root directory. Then the library can be built and installed through the usual GNU mantra `./configure <options> && make && make install`. Use `./configure --help` to obtain a list of possible options for `./configure`. Because Eigen expressions rely a lot on inlining and compiler optimisations it is strongly recommended to set the `CXXFLAGS` variable to `-O3 -march=native -mtune=native`.
## History
#### v3.3
Additions:
* Sample plot CL utility.
* Infinity as a math constant.
* Option to dump bootstrap sequence while resampling.
* FFT through the GSL.
Changes:
* GSL integrator accepts infinite bounds.
* `latan-sample-combine` accepts mixes of `DSample` and `DMatSample`.
* More general `latan-sample-element` command.
#### v3.2.2
Additions:
* The math interpreter supports `inf` for infinity.
Changes:
* Vector version of `setUnidimData`.
Fixes:
* Variance matrix computation fix.
#### v3.2.1
Fix:
* Wrong argument number check in `latan-resample`

4
ci-scripts/install-hdf5.sh
View File

@ -1,6 +1,6 @@
#!/usr/bin/env bash
NAME='hdf5-1.8.16'
NAME='hdf5-1.10.1'
if (( $# != 1 )); then
echo "usage: `basename $0` <prefix> {osx|linux}" 1>&2
@ -11,7 +11,7 @@ PREFIX=$1
set -ex
INITDIR=`pwd`
cd local/build
wget http://www.hdfgroup.org/ftp/HDF5/releases/${NAME}/src/${NAME}.tar.gz
wget https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.10/${NAME}/src/${NAME}.tar.gz
tar -xzvf ${NAME}.tar.gz
mkdir ${NAME}/build
cd ${NAME}/build

2
configure.ac
View File

@ -2,7 +2,7 @@
# Initialization
AC_PREREQ([2.63])
AC_INIT([LatAnalyze],[3.2.1-dev],[antonin.portelli@me.com],[LatAnalyze])
AC_INIT([LatAnalyze],[3.3],[antonin.portelli@me.com],[LatAnalyze])
AC_CONFIG_AUX_DIR([.buildutils])
AC_CONFIG_SRCDIR([lib/Global.cpp])
AC_CONFIG_SRCDIR([utils/sample_read.cpp])

19
lib/Dataset.hpp
View File

@ -47,6 +47,8 @@ public:
// resampling
Sample<T> bootstrapMean(const Index nSample, const SeedType seed);
Sample<T> bootstrapMean(const Index nSample);
void dumpBootstrapSeq(std::ostream &out, const Index nSample,
const SeedType seed);
private:
// mean from pointer vector for resampling
void ptVectorMean(T &m, const std::vector<const T *> &v);
@ -114,6 +116,23 @@ Sample<T> Dataset<T>::bootstrapMean(const Index nSample)
return bootstrapMean(nSample, rd());
}
template <typename T>
void Dataset<T>::dumpBootstrapSeq(std::ostream &out, const Index nSample,
const SeedType seed)
{
std::mt19937 gen(seed);
std::uniform_int_distribution<Index> dis(0, this->size() - 1);
for (Index i = 0; i < nSample; ++i)
{
for (unsigned int j = 0; j < this->size(); ++j)
{
out << dis(gen) << " " << std::endl;
}
out << std::endl;
}
}
template <typename T>
void Dataset<T>::ptVectorMean(T &m, const std::vector<const T *> &v)
{

53
lib/FFT.hpp Normal file
View File

@ -0,0 +1,53 @@
/*
* FFT.hpp, part of LatAnalyze
*
* Copyright (C) 2013 - 2017 Antonin Portelli
*
* LatAnalyze is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LatAnalyze is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LatAnalyze. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef Latan_FFT_hpp_
#define Latan_FFT_hpp_
#include <LatAnalyze/Global.hpp>
BEGIN_LATAN_NAMESPACE
/******************************************************************************
* FFT abstract class *
******************************************************************************/
class FFT
{
public:
enum
{
Forward = 0,
Backward = 1
};
public:
// constructor
FFT(void) = default;
FFT(const Index size);
// destructor
virtual ~FFT(void) = default;
// size
virtual void resize(const Index size) = 0;
// FFT
virtual void operator()(CMat &x, const unsigned int dir = FFT::Forward) = 0;
};
END_LATAN_NAMESPACE
#endif // Latan_FFT_hpp_

89
lib/GslFFT.cpp Normal file
View File

@ -0,0 +1,89 @@
/*
* GslFFT.cpp, part of LatAnalyze
*
* Copyright (C) 2013 - 2017 Antonin Portelli
*
* LatAnalyze is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LatAnalyze is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LatAnalyze. If not, see <http://www.gnu.org/licenses/>.
*/
#include <LatAnalyze/GslFFT.hpp>
#include <LatAnalyze/includes.hpp>
using namespace std;
using namespace Latan;
/******************************************************************************
* GslFFT implementation *
******************************************************************************/
// constructor /////////////////////////////////////////////////////////////////
GslFFT::GslFFT(const Index size)
{
resize(size);
}
// destructor //////////////////////////////////////////////////////////////////
GslFFT::~GslFFT(void)
{
clear();
}
// size ////////////////////////////////////////////////////////////////////////
void GslFFT::resize(const Index size)
{
if (size_ != size)
{
size_ = size;
wavetable_ = gsl_fft_complex_wavetable_alloc(size_);
workspace_ = gsl_fft_complex_workspace_alloc(size_);
}
}
// fft /////////////////////////////////////////////////////////////////////////
void GslFFT::operator()(CMat &x, const unsigned int dir)
{
if (x.size() != size_)
{
LATAN_ERROR(Size, "wrong input vector size");
}
else
{
switch (dir)
{
case FFT::Forward:
gsl_fft_complex_forward((double *)x.data(), 1, size_,
wavetable_, workspace_);
break;
case FFT::Backward:
gsl_fft_complex_backward((double *)x.data(), 1, size_,
wavetable_, workspace_);
break;
default:
LATAN_ERROR(Argument, "invalid FT direction");
break;
}
}
}
// destroy GSL objects /////////////////////////////////////////////////////////
void GslFFT::clear(void)
{
if (!wavetable_)
{
gsl_fft_complex_wavetable_free(wavetable_);
}
if (!workspace_)
{
gsl_fft_complex_workspace_free(workspace_);
}
}

57
lib/GslFFT.hpp Normal file
View File

@ -0,0 +1,57 @@
/*
* GslFFT.hpp, part of LatAnalyze
*
* Copyright (C) 2013 - 2017 Antonin Portelli
*
* LatAnalyze is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LatAnalyze is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LatAnalyze. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef Latan_GslFFT_hpp_
#define Latan_GslFFT_hpp_
#include <LatAnalyze/Global.hpp>
#include <LatAnalyze/Mat.hpp>
#include <LatAnalyze/FFT.hpp>
#include <gsl/gsl_fft_complex.h>
BEGIN_LATAN_NAMESPACE
/******************************************************************************
* GSL FFT *
******************************************************************************/
class GslFFT: public FFT
{
public:
// constructors
GslFFT(void) = default;
GslFFT(const Index size);
// destructor
virtual ~GslFFT(void);
// size
void resize(const Index size);
// fft
virtual void operator()(CMat &x, const unsigned int dir = FFT::Forward);
private:
// destroy GSL objects
void clear(void);
private:
Index size_{0};
gsl_fft_complex_wavetable *wavetable_{nullptr};
gsl_fft_complex_workspace *workspace_{nullptr};
};
END_LATAN_NAMESPACE
#endif // Latan_GslFFT_hpp_

24
lib/GslQagsIntegrator.cpp
View File

@ -19,6 +19,7 @@
#include <LatAnalyze/GslQagsIntegrator.hpp>
#include <LatAnalyze/includes.hpp>
#include <LatAnalyze/Math.hpp>
using namespace std;
using namespace Latan;
@ -55,9 +56,26 @@ double GslQagsIntegrator::operator()(const DoubleFunction &f, const double xMin,
gslF.function = fWrap;
gslF.params = reinterpret_cast<void *>(&const_cast<DoubleFunction &>(f));
gsl_integration_qags(&gslF, xMin, xMax, 0.0, precision_, limit_, workspace_,
&result, &error_);
if ((xMin > -Math::inf) and (xMax < Math::inf))
{
gsl_integration_qags(&gslF, xMin, xMax, 0.0, precision_, limit_,
workspace_, &result, &error_);
}
else if (xMax < Math::inf)
{
gsl_integration_qagil(&gslF, xMax, 0.0, precision_, limit_,
workspace_, &result, &error_);
}
else if (xMin > -Math::inf)
{
gsl_integration_qagiu(&gslF, xMin, 0.0, precision_, limit_,
workspace_, &result, &error_);
}
else
{
gsl_integration_qagi(&gslF, 0.0, precision_, limit_,
workspace_, &result, &error_);
}
return result;
}

3
lib/Makefile.am
View File

@ -31,6 +31,7 @@ libLatAnalyze_la_SOURCES = \
FitInterface.cpp \
Function.cpp \
Global.cpp \
GslFFT.cpp \
GslHybridRootFinder.cpp\
GslMinimizer.cpp \
GslQagsIntegrator.cpp \
@ -59,10 +60,12 @@ libLatAnalyze_la_HEADERS = \
Dataset.hpp \
Derivative.hpp \
Exceptions.hpp \
FFT.hpp \
Function.hpp \
File.hpp \
FitInterface.hpp \
Global.hpp \
GslFFT.hpp \
GslHybridRootFinder.hpp\
GslMinimizer.hpp \
GslQagsIntegrator.hpp \

5
lib/Math.hpp
View File

@ -72,8 +72,9 @@ namespace MATH_NAMESPACE
DMat varToCorr(const DMat &var);
// Constants
const double pi = 3.1415926535897932384626433832795028841970;
const double e = 2.7182818284590452353602874713526624977572;
constexpr double pi = 3.1415926535897932384626433832795028841970;
constexpr double e = 2.7182818284590452353602874713526624977572;
constexpr double inf = std::numeric_limits<double>::infinity();
}

4
lib/MathInterpreter.cpp
View File

@ -689,8 +689,8 @@ void MathInterpreter::compile(RunContext &context)
{
if (root_)
{
context.addVariable("pi", Math::pi);
context.addVariable("inf", HUGE_VAL);
context.addVariable("pi", Math::pi);
context.addVariable("inf", Math::inf);
ADD_STDMATH_FUNCS(context);
root_->compile(program_, context);
for (unsigned int i = 0; i < program_.size(); ++i)

23
lib/TabFunction.cpp
View File

@ -29,18 +29,11 @@ using namespace Latan;
// constructors ////////////////////////////////////////////////////////////////
TabFunction::TabFunction(const DVec &x, const DVec &y,
const InterpType interpType)
: interpType_(interpType)
{
setData(x, y);
setInterpolationType(interpType);
}
//TabFunction::TabFunction(const XYStatData &data, const Index i, const Index j,
// const InterpType interpType)
//: interpType_(interpType)
//{
// setData(data, i, j);
//}
// access //////////////////////////////////////////////////////////////////////
void TabFunction::setData(const DVec &x, const DVec &y)
{
@ -54,10 +47,10 @@ void TabFunction::setData(const DVec &x, const DVec &y)
}
}
//void TabFunction::setData(const XYStatData &data, const Index i, const Index j)
//{
// setData(data.x(i), data.y(j));
//}
void TabFunction::setInterpolationType(const InterpType interpType)
{
interpType_ = interpType;
}
// function call ///////////////////////////////////////////////////////////////
double TabFunction::operator()(const double *arg) const
@ -154,12 +147,6 @@ DoubleFunction Latan::interpolate(const DVec &x, const DVec &y,
return TabFunction(x, y, interpType).makeFunction();
}
//DoubleFunction Latan::interpolate(const XYStatData &data, const Index i,
// const Index j, const InterpType interpType)
//{
// return TabFunction(data, i, j, interpType).makeFunction();
//}
map<double, double>::const_iterator TabFunction::nearest(const double x) const
{
map<double, double>::const_iterator ret;

7
lib/TabFunction.hpp
View File

@ -45,13 +45,11 @@ public:
TabFunction(void) = default;
TabFunction(const DVec &x, const DVec &y,
const InterpType interpType = InterpType::LINEAR);
//TabFunction(const XYStatData &data, const Index i = 0, const Index j = 0,
// const InterpType interpType = InterpType::LINEAR);
// destructor
virtual ~TabFunction(void) = default;
// access
void setData(const DVec &x, const DVec &y);
// void setData(const XYStatData &data, const Index i = 0, const Index j = 0);
void setInterpolationType(const InterpType interpType);
// function call
double operator()(const double *arg) const;
// factory
@ -65,9 +63,6 @@ private:
DoubleFunction interpolate(const DVec &x, const DVec &y,
const InterpType interpType = InterpType::LINEAR);
//DoubleFunction interpolate(const XYStatData &data, const Index i = 0,
// const Index j = 0,
// const InterpType interpType = InterpType::LINEAR);
END_LATAN_NAMESPACE

10
utils/Makefile.am
View File

@ -10,6 +10,8 @@ bin_PROGRAMS = \
latan-sample-combine \
latan-sample-element \
latan-sample-fake \
latan-sample-ft \
latan-sample-plot \
latan-sample-plot-corr\
latan-sample-read \
latan-resample
@ -26,10 +28,18 @@ latan_sample_fake_SOURCES = sample-fake.cpp
latan_sample_fake_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_fake_LDFLAGS = -L../lib/.libs -lLatAnalyze
latan_sample_ft_SOURCES = sample-ft.cpp
latan_sample_ft_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_ft_LDFLAGS = -L../lib/.libs -lLatAnalyze
latan_sample_plot_corr_SOURCES = sample-plot-corr.cpp
latan_sample_plot_corr_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_plot_corr_LDFLAGS = -L../lib/.libs -lLatAnalyze
latan_sample_plot_SOURCES = sample-plot.cpp
latan_sample_plot_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_plot_LDFLAGS = -L../lib/.libs -lLatAnalyze
latan_sample_read_SOURCES = sample-read.cpp
latan_sample_read_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_read_LDFLAGS = -L../lib/.libs -lLatAnalyze

14
utils/resample.cpp
View File

@ -39,7 +39,7 @@ int main(int argc, char *argv[])
{
// argument parsing ////////////////////////////////////////////////////////
OptParser opt;
bool parsed;
bool parsed, dumpBoot;
random_device rd;
SeedType seed = rd();
string manFileName, nameFileName, outDirName;
@ -56,6 +56,8 @@ int main(int argc, char *argv[])
"output directory", ".");
opt.addOption("f", "format" , OptParser::OptType::value, true,
"output file format", DEF_FMT);
opt.addOption("d", "dump-boot" , OptParser::OptType::trigger, true,
"dump bootstrap sequence");
opt.addOption("" , "help" , OptParser::OptType::trigger, true,
"show this help message and exit");
parsed = opt.parse(argc, argv);
@ -75,6 +77,7 @@ int main(int argc, char *argv[])
}
ext = opt.optionValue("f");
outDirName = opt.optionValue("o");
dumpBoot = opt.gotOption("d");
manFileName = opt.getArgs()[0];
nameFileName = opt.getArgs()[1];
@ -124,6 +127,15 @@ int main(int argc, char *argv[])
cout << '\r' << ProgressBar(i + 1, name.size());
data[name[i]].bin(binSize);
if ((i == 0) and dumpBoot)
{
ofstream file(outDirName + "/" + manFileName + ".bootseq");
file << "# bootstrap sequences" << endl;
file << "# manifest file: " << manFileName << endl;
file << "# bin size: " << binSize << endl;
data[name[i]].dumpBootstrapSeq(file, nSample, seed);
}
s = data[name[i]].bootstrapMean(nSample, seed);
Io::save<DMatSample>(s, outDirName + "/" + outFileName,
File::Mode::write, outFileName);

73
utils/sample-combine.cpp
View File

@ -25,14 +25,21 @@ using namespace std;
using namespace Latan;
template <typename T>
static void loadAndCheck(vector<T> &sample, const vector<string> &fileName)
static void loadAndCheck(vector<T> &sample __dumb,
const vector<string> &fileName __dumb)
{
const unsigned int n = sample.size();
abort();
}
template <>
void loadAndCheck(vector<DSample> &sample, const vector<string> &fileName)
{
const unsigned int n = static_cast<unsigned int>(sample.size());
Index nSample = 0;
for (unsigned int i = 0; i < n; ++i)
{
sample[i] = Io::load<T>(fileName[i]);
sample[i] = Io::load<DSample>(fileName[i]);
if (i == 0)
{
nSample = sample[i].size();
@ -46,6 +53,62 @@ static void loadAndCheck(vector<T> &sample, const vector<string> &fileName)
}
}
template <>
void loadAndCheck(vector<DMatSample> &sample, const vector<string> &fileName)
{
const unsigned int n = static_cast<unsigned int>(sample.size());
Index nSample = 0;
set<unsigned int> failed;
bool gotSize = false;
Index nRow = 0, nCol = 0;
for (unsigned int i = 0; i < n; ++i)
{
try
{
sample[i] = Io::load<DMatSample>(fileName[i]);
if (!gotSize)
{
nSample = sample[i].size();
nRow = sample[i][central].rows();
nCol = sample[i][central].cols();
gotSize = true;
}
}
catch (Exceptions::Definition)
{
failed.insert(i);
}
}
for (unsigned int i: failed)
{
DSample buf;
buf = Io::load<DSample>(fileName[i]);
sample[i].resize(nSample);
FOR_STAT_ARRAY(sample[i], s)
{
sample[i][s] = DMat::Constant(nRow, nCol, buf[s]);
}
}
for (unsigned int i = 0; i < n; ++i)
{
if (sample[i].size() != nSample)
{
cerr << "error: number of sample mismatch (between '";
cerr << fileName[0] << "' and '" << fileName[i] << "')" << endl;
abort();
}
if ((sample[i][central].rows() != nRow) and
(sample[i][central].cols() != nCol))
{
cerr << "error: matrix size mismatch (between '";
cerr << fileName[0] << "' and '" << fileName[i] << "')" << endl;
abort();
}
}
}
template <typename T>
static void combine(const string &outFileName __dumb,
const vector<T> &sample __dumb, const string &code __dumb)
@ -57,7 +120,7 @@ template <>
void combine(const string &outFileName, const vector<DSample> &sample,
const string &code)
{
const unsigned int n = sample.size();
const unsigned int n = static_cast<unsigned int>(sample.size());
DoubleFunction f = compile(code, n);
DSample result(sample[0]);
DVec buf(n);
@ -87,7 +150,7 @@ template <>
void combine(const string &outFileName, const vector<DMatSample> &sample,
const string &code)
{
const unsigned int n = sample.size();
const unsigned int n = static_cast<unsigned int>(sample.size());
DoubleFunction f = compile(code, n);
DVec buf(n);
DMatSample result(sample[0]);

116
utils/sample-element.cpp
View File

@ -1,39 +1,103 @@
#include <iostream>
#include <string>
/*
* sample-element.cpp, part of LatAnalyze 3
*
* Copyright (C) 2013 - 2016 Antonin Portelli, Matt Spraggs
*
* LatAnalyze 3 is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LatAnalyze 3 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LatAnalyze 3. If not, see <http://www.gnu.org/licenses/>.
*/
#include <LatCore/OptParser.hpp>
#include <LatAnalyze/Io.hpp>
#include <LatAnalyze/MatSample.hpp>
using namespace std;
using namespace Latan;
int main(int argc, char* argv[])
{
using namespace std;
using namespace Latan;
if (argc != 4 and argc != 5) {
cout << "Usage: " << argv[0] << " <input filename> <row> <column> ";
cout << "[output filename]" << endl;
return -1;
// argument parsing ////////////////////////////////////////////////////////
OptParser opt;
bool parsed;
string inFilename, outFilename;
Index r, c, nr, nc;
opt.addOption("r", "row", OptParser::OptType::value , false,
"row");
opt.addOption("c", "col", OptParser::OptType::value , false,
"column");
opt.addOption("" , "nrow", OptParser::OptType::value , true,
"number of rows (default: 1)", "1");
opt.addOption("" , "ncol", OptParser::OptType::value , true,
"number of columns (default: 1)", "1");
opt.addOption("o", "output", OptParser::OptType::value , true,
"output file name (default: result not saved)", "");
opt.addOption("" , "help" , OptParser::OptType::trigger, true,
"show this help message and exit");
parsed = opt.parse(argc, argv);
if (!parsed or (opt.getArgs().size() != 1) or opt.gotOption("help"))
{
cerr << "usage: " << argv[0];
cerr << " <options> <input file>" << endl;
cerr << endl << "Possible options:" << endl << opt << endl;
return EXIT_FAILURE;
}
string inFileName = argv[1];
auto row = strTo<Index>(argv[2]);
auto col = strTo<Index>(argv[3]);
string outFileName = (argc == 5) ? argv[4] : "";
auto inputData = Io::load<DMatSample>(inFileName);
cout << scientific;
cout << "central value:\n" << inputData[central](row, col) << endl;
cout << "standard deviation:\n";
cout << inputData.variance().cwiseSqrt()(row, col) << endl;
if (not outFileName.empty())
inFilename = opt.getArgs()[0];
outFilename = opt.optionValue("o");
r = opt.optionValue<Index>("r");
c = opt.optionValue<Index>("c");
nr = opt.optionValue<Index>("nrow");
nc = opt.optionValue<Index>("ncol");
// Data extraction /////////////////////////////////////////////////////////
auto inputData = Io::load<DMatSample>(inFilename);
if ((nr == 1) and (nc == 1))
{
DSample outputData(inputData.size());
FOR_STAT_ARRAY(inputData, s) {
outputData[s] = inputData[s](row, col);
FOR_STAT_ARRAY(inputData, s)
{
outputData[s] = inputData[s](r, c);
}
cout << scientific;
cout << "central value:\n" << outputData[central] << endl;
cout << "standard deviation:\n";
cout << sqrt(outputData.variance()) << endl;
if (not outFilename.empty())
{
Io::save(outputData, outFilename);
}
Io::save(outputData, outFileName);
}
else
{
DMatSample outputData(inputData.size(), nr, nc);
FOR_STAT_ARRAY(inputData, s)
{
outputData[s] = inputData[s].block(r, c, nr, nc);
}
cout << scientific;
cout << "central value:\n" << outputData[central] << endl;
cout << "standard deviation:\n";
cout << outputData.variance().cwiseSqrt() << endl;
if (not outFilename.empty())
{
Io::save(outputData, outFilename);
}
}
return EXIT_SUCCESS;
}

94
utils/sample-ft.cpp Normal file
View File

@ -0,0 +1,94 @@
/*
* sample-ft.cpp, part of LatAnalyze 3
*
* Copyright (C) 2013 - 2016 Antonin Portelli
*
* LatAnalyze 3 is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LatAnalyze 3 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LatAnalyze 3. If not, see <http://www.gnu.org/licenses/>.
*/
#include <LatCore/OptParser.hpp>
#include <LatAnalyze/GslFFT.hpp>
#include <LatAnalyze/Io.hpp>
using namespace std;
using namespace Latan;
int main(int argc, char *argv[])
{
// argument parsing ////////////////////////////////////////////////////////
OptParser opt;
bool parsed;
string inFilename, outFilename;
unsigned int dir = FFT::Forward;
opt.addOption("o", "output", OptParser::OptType::value , true,
"output file name (default: result not saved)", "");
opt.addOption("b", "backward", OptParser::OptType::trigger, true,
"backward Fourier transform (forward by default)");
opt.addOption("" , "help" , OptParser::OptType::trigger, true,
"show this help message and exit");
parsed = opt.parse(argc, argv);
if (!parsed or (opt.getArgs().size() != 1) or opt.gotOption("help"))
{
cerr << "usage: " << argv[0];
cerr << " <options> <input file>" << endl;
cerr << endl << "Possible options:" << endl << opt << endl;
return EXIT_FAILURE;
}
inFilename = opt.getArgs()[0];
outFilename = opt.optionValue("o");
if (opt.gotOption("b"))
{
dir = FFT::Backward;
}
// Fourier transform ///////////////////////////////////////////////////////
DMatSample in = Io::load<DMatSample>(inFilename);
Index nSample = in.size(), l = in[central].rows();
bool isInComplex = (in[central].cols() > 1);
CMatSample res(nSample, l, 1);
DMatSample out(nSample, l, 2);
GslFFT ft(l);
cout << "-- computing Fourier transform..." << endl;
FOR_STAT_ARRAY(in, s)
{
res[s].real() = in[s].col(0);
if (isInComplex)
{
res[s].imag() = in[s].col(1);
}
else
{
res[s].imag() = DVec::Constant(l, 0.);
}
ft(res[s], dir);
out[s].col(0) = res[s].real();
out[s].col(1) = res[s].imag();
}
// output /////////////////////////////////////////////////////////////////
cout << scientific;
cout << "central value:\n" << out[central];
cout << endl;
cout << "standard deviation:\n" << out.variance().cwiseSqrt();
cout << endl;
if (!outFilename.empty())
{
Io::save<DMatSample>(out, outFilename);
}
return EXIT_SUCCESS;
}

51
utils/sample-plot.cpp Normal file
View File

@ -0,0 +1,51 @@
/*
* sample-plot.cpp, part of LatAnalyze 3
*
* Copyright (C) 2013 - 2016 Antonin Portelli
*
* LatAnalyze 3 is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* LatAnalyze 3 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LatAnalyze 3. If not, see <http://www.gnu.org/licenses/>.
*/
#include <LatAnalyze/Io.hpp>
#include <LatAnalyze/Math.hpp>
#include <LatAnalyze/Plot.hpp>
using namespace std;
using namespace Latan;
using namespace Math;
int main(int argc, char *argv[])
{
string xFileName, yFileName;
if (argc != 3)
{
cerr << "usage: " << argv[0] << " <x sample> <y sample>" << endl;
return EXIT_FAILURE;
}
xFileName = argv[1];
yFileName = argv[2];
Plot p;
DMatSample x, y;
x = Io::load<DMatSample>(xFileName);
y = Io::load<DMatSample>(yFileName);
p << PlotData(x, y);
p.display();
return EXIT_SUCCESS;
}