portelli/LatAnalyze
1
0
Fork 0
mirror of https://github.com/aportelli/LatAnalyze.git synced 2025-04-05 09:35:54 +01:00
Code Releases Activity

Merge branch 'release/3.2'

Browse Source
This commit is contained in:
Antonin Portelli 2016-06-14 19:31:57 +01:00
commit a89ed85e43
18 changed files with 531 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
.travis.yml
View File

@ -7,6 +7,7 @@ notifications:
cache:
directories:
- ci-scripts/local
- ci-scripts/clang
matrix:
include:
@ -44,37 +45,43 @@ matrix:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.6
packages:
- clang-3.6
- g++-4.8
- libgsl0-dev
- flex
- bison
env: VERSION=-3.6
env: CLANG_LINK=http://llvm.org/releases/3.6.0/clang+llvm-3.6.0-x86_64-linux-gnu-ubuntu-14.04.tar.xz
- compiler: clang
addons:
apt:
sources:
- ubuntu-toolchain-r-test
- llvm-toolchain-precise-3.7
packages:
- clang-3.7
- g++-4.8
- libgsl0-dev
- flex
- bison
env: VERSION=-3.7
env: CLANG_LINK=http://llvm.org/releases/3.7.0/clang+llvm-3.7.0-x86_64-linux-gnu-ubuntu-14.04.tar.xz
before_install:
- export LATDIR=`pwd`
- cd ci-scripts
- if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]] && [ ! -e clang/bin ]; then wget $CLANG_LINK; tar -xf `basename $CLANG_LINK`; mkdir clang; mv clang+*/* clang/; fi
- if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]]; then export PATH="${LATDIR}/ci-scripts/clang/bin:${PATH}"; fi
- if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]]; then export LD_LIBRARY_PATH="${LATDIR}/ci-scripts/clang/lib:${LD_LIBRARY_PATH}"; fi
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; fi
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install gsl; fi
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install bison flex; export PATH="/usr/local/opt/flex/bin:/usr/local/opt/bison/bin:$PATH"; fi
- if [[ "$TRAVIS_OS_NAME" == "osx" ]] && [[ "$CC" == "gcc" ]]; then brew install gcc5; fi
install:
- export LATDIR=`pwd`
- export CC=$CC$VERSION
- export CXX=$CXX$VERSION
- cd ci-scripts
- echo $PATH
- which $CC
- $CC --version
- which $CXX
- $CXX --version
- ./install-deps.sh `pwd`/local
- cd ..
- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export LD_LIBRARY_PATH=${LATDIR}/ci-scripts/local/lib:$LD_LIBRARY_PATH; fi

2
Makefile.am
View File

@ -1,3 +1,3 @@
SUBDIRS = lib utils examples
SUBDIRS = lib utils physics examples
ACLOCAL_AMFLAGS = -I .buildutils/m4

12
Readme.md
View File

@ -55,11 +55,21 @@ 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.2 (needs LatCore 1.1)
Additions:
* 2-pt function fitter `latan-2pt-fit`
* Tool to extract one element of a matrix sample `latan-sample-element`
* Band plotting
Changes:
* Sample utilities renamed `latan-sample-*`
* Resample utility renamed `latan-resample`
#### v3.1.2
Fixes:
* HDF5 archive URL update in build scripts
#### v3.1.1
#### v3.1.1 (needs LatCore 1.0)
Fixes:
* Minuit precision fixed
* Minor fit interface fixes

5
configure.ac
View File

@ -2,7 +2,7 @@
# Initialization
AC_PREREQ([2.63])
AC_INIT([LatAnalyze],[3.1.1],[antonin.portelli@me.com],[LatAnalyze])
AC_INIT([LatAnalyze],[3.2],[antonin.portelli@me.com],[LatAnalyze])
AC_CONFIG_AUX_DIR([.buildutils])
AC_CONFIG_SRCDIR([lib/Global.cpp])
AC_CONFIG_SRCDIR([utils/sample_read.cpp])
@ -131,7 +131,8 @@ AC_SUBST([LIBS])
AC_SUBST([AM_CFLAGS])
AC_SUBST([AM_LDFLAGS])
AC_CONFIG_FILES([Makefile lib/Makefile utils/Makefile examples/Makefile])
AC_CONFIG_FILES([Makefile lib/Makefile utils/Makefile physics/Makefile
examples/Makefile])
AC_OUTPUT
echo "*********************************************"

14
lib/Plot.cpp
View File

@ -183,6 +183,20 @@ PlotHLine::PlotHLine(const double y)
setCommand(strFrom(y));
}
// PlotHBand constructor ///////////////////////////////////////////////////////
PlotBand::PlotBand(const double xMin, const double xMax, const double yMin,
const double yMax, const double opacity)
{
setCommand("'< printf \"%e %e\\n%e %e\\n%e %e\\n%e %e\\n%e %e\\n\" "
+ strFrom(xMin) + " " + strFrom(yMin) + " "
+ strFrom(xMax) + " " + strFrom(yMin) + " "
+ strFrom(xMax) + " " + strFrom(yMax) + " "
+ strFrom(xMin) + " " + strFrom(yMax) + " "
+ strFrom(xMin) + " " + strFrom(yMin)
+ "' u 1:2 w filledcurves closed fs solid " + strFrom(opacity)
+ " noborder");
}
// PlotFunction constructor ////////////////////////////////////////////////////
PlotFunction::PlotFunction(const DoubleFunction &function, const double xMin,
const double xMax, const unsigned int nPoint)

10
lib/Plot.hpp
View File

@ -106,6 +106,16 @@ public:
virtual ~PlotHLine(void) = default;
};
class PlotBand: public PlotObject
{
public:
// constructor
PlotBand(const double xMin, const double xMax, const double yMin,
const double yMax, const double opacity = 0.15);
// destructor
virtual ~PlotBand(void) = default;
};
class PlotFunction: public PlotObject
{
public:

4
lib/XYSampleData.cpp
View File

@ -98,7 +98,7 @@ void SampleFitResult::print(const bool printXsi, ostream &out) const
Index pMax = printXsi ? size() : nPar_;
DMat err = this->variance().cwiseSqrt();
sprintf(buf, "chi^2/dof= %.1f/%d= %.2f -- p-value= %.2e", getChi2(),
sprintf(buf, "chi^2/dof= %.1e/%d= %.2e -- p-value= %.2e", getChi2(),
static_cast<int>(getNDof()), getChi2PerDof(), getPValue());
out << buf << endl;
for (Index p = 0; p < pMax; ++p)
@ -277,12 +277,12 @@ SampleFitResult XYSampleData::fit(std::vector<Minimizer *> &minimizer,
if (s == central)
{
sampleResult = data_.fit(minimizer, initCopy, v);
initCopy = sampleResult.segment(0, initCopy.size());
}
else
{
sampleResult = data_.fit(*(minimizer.back()), initCopy, v);
}
initCopy = sampleResult.segment(0, initCopy.size());
result[s] = sampleResult;
result.chi2_[s] = sampleResult.getChi2();
for (unsigned int j = 0; j < v.size(); ++j)

2
lib/XYStatData.cpp
View File

@ -66,7 +66,7 @@ void FitResult::print(const bool printXsi, ostream &out) const
char buf[256];
Index pMax = printXsi ? size() : nPar_;
sprintf(buf, "chi^2/dof= %.1f/%d= %.2f -- p-value= %.2e", getChi2(),
sprintf(buf, "chi^2/dof= %.1e/%d= %.2e -- p-value= %.2e", getChi2(),
static_cast<int>(getNDof()), getChi2PerDof(), getPValue());
out << buf << endl;
for (Index p = 0; p < pMax; ++p)

332
physics/2pt-fit.cpp Normal file
View File

@ -0,0 +1,332 @@
#include <LatCore/OptParser.hpp>
#include <LatAnalyze/CompiledModel.hpp>
#include <LatAnalyze/Io.hpp>
#include <LatAnalyze/MatSample.hpp>
#include <LatAnalyze/Math.hpp>
#include <LatAnalyze/MinuitMinimizer.hpp>
#include <LatAnalyze/NloptMinimizer.hpp>
#include <LatAnalyze/Plot.hpp>
#include <LatAnalyze/XYSampleData.hpp>
using namespace std;
using namespace Latan;
int main(int argc, char *argv[])
{
// parse arguments /////////////////////////////////////////////////////////
OptParser opt;
bool parsed, doPlot, doHeatmap, doCorr, fold;
string corrFileName, model, outFileName, outFmt;
Index ti, tf, shift, nPar, thinning;
double svdTol;
Minimizer::Verbosity verbosity;
opt.addOption("" , "ti" , OptParser::OptType::value , false,
"initial fit time");
opt.addOption("" , "tf" , OptParser::OptType::value , false,
"final fit time");
opt.addOption("t" , "thinning", OptParser::OptType::value , true,
"thinning of the time interval", "1");
opt.addOption("s", "shift" , OptParser::OptType::value , true,
"time variable shift", "0");
opt.addOption("m", "model" , OptParser::OptType::value , true,
"fit model (exp|exp2|exp3|cosh|cosh2|cosh3|<interpreter code>)", "cosh");
opt.addOption("" , "nPar" , OptParser::OptType::value , true,
"number of model parameters for custom models "
"(-1 if irrelevant)", "-1");
opt.addOption("" , "svd" , OptParser::OptType::value , true,
"singular value elimination threshold", "0.");
opt.addOption("v", "verbosity", OptParser::OptType::value , true,
"minimizer verbosity level (0|1|2)", "0");
opt.addOption("o", "output", OptParser::OptType::value , true,
"output file", "");
opt.addOption("" , "uncorr" , OptParser::OptType::trigger, true,
"only do the uncorrelated fit");
opt.addOption("" , "fold" , OptParser::OptType::trigger, true,
"fold the correlator");
opt.addOption("p", "plot" , OptParser::OptType::trigger, true,
"show the fit plot");
opt.addOption("h", "heatmap" , OptParser::OptType::trigger, true,
"show the fit correlation heatmap");
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] << " <options> <correlator file>" << endl;
cerr << endl << "Possible options:" << endl << opt << endl;
return EXIT_FAILURE;
}
corrFileName = opt.getArgs().front();
ti = opt.optionValue<Index>("ti");
tf = opt.optionValue<Index>("tf");
thinning = opt.optionValue<Index>("t");
shift = opt.optionValue<Index>("s");
model = opt.optionValue("m");
nPar = opt.optionValue<Index>("nPar");
svdTol = opt.optionValue<double>("svd");
outFileName = opt.optionValue<string>("o");
doCorr = !opt.gotOption("uncorr");
fold = opt.gotOption("fold");
doPlot = opt.gotOption("p");
doHeatmap = opt.gotOption("h");
switch (opt.optionValue<unsigned int>("v"))
{
case 0:
verbosity = Minimizer::Verbosity::Silent;
break;
case 1:
verbosity = Minimizer::Verbosity::Normal;
break;
case 2:
verbosity = Minimizer::Verbosity::Debug;
break;
default:
cerr << "error: wrong verbosity level" << endl;
return EXIT_FAILURE;
}
// load correlator /////////////////////////////////////////////////////////
DMatSample tmp, corr;
Index nSample, nt;
tmp = Io::load<DMatSample>(corrFileName);
nSample = tmp.size();
nt = tmp[central].rows();
tmp = tmp.block(0, 0, nt, 1);
corr = tmp;
FOR_STAT_ARRAY(corr, s)
{
for (Index t = 0; t < nt; ++t)
{
corr[s]((t - shift + nt)%nt) = tmp[s](t);
}
}
if (fold)
{
tmp = corr;
FOR_STAT_ARRAY(corr, s)
{
for (Index t = 0; t < nt; ++t)
{
corr[s](t) = 0.5*(tmp[s](t) + tmp[s]((nt - t) % nt));
}
}
}
// make model //////////////////////////////////////////////////////////////
DoubleModel mod;
bool coshModel = false;
if ((model == "exp") or (model == "exp1"))
{
nPar = 2;
mod.setFunction([](const double *x, const double *p)
{
return p[1]*exp(-p[0]*x[0]);
}, 1, nPar);
}
else if (model == "exp2")
{
nPar = 4;
mod.setFunction([](const double *x, const double *p)
{
return p[1]*exp(-p[0]*x[0]) + p[3]*exp(-p[2]*x[0]);
}, 1, nPar);
}
else if (model == "exp3")
{
nPar = 6;
mod.setFunction([](const double *x, const double *p)
{
return p[1]*exp(-p[0]*x[0]) + p[3]*exp(-p[2]*x[0])
+ p[5]*exp(-p[4]*x[0]);
}, 1, nPar);
}
else if ((model == "cosh") or (model == "cosh1"))
{
coshModel = true;
nPar = 2;
mod.setFunction([nt](const double *x, const double *p)
{
return p[1]*(exp(-p[0]*x[0])+exp(-p[0]*(nt-x[0])));
}, 1, nPar);
}
else if (model == "cosh2")
{
coshModel = true;
nPar = 4;
mod.setFunction([nt](const double *x, const double *p)
{
return p[1]*(exp(-p[0]*x[0])+exp(-p[0]*(nt-x[0])))
+ p[3]*(exp(-p[2]*x[0])+exp(-p[2]*(nt-x[0])));
}, 1, nPar);
}
else if (model == "cosh3")
{
coshModel = true;
nPar = 6;
mod.setFunction([nt](const double *x, const double *p)
{
return p[1]*(exp(-p[0]*x[0])+exp(-p[0]*(nt-x[0])))
+ p[3]*(exp(-p[2]*x[0])+exp(-p[2]*(nt-x[0])))
+ p[5]*(exp(-p[2]*x[0])+exp(-p[4]*(nt-x[0])));
}, 1, nPar);
}
else
{
if (nPar > 0)
{
mod = compile(model, 1, nPar);
}
else
{
cerr << "error: please specify the number of model parameter"
" using the --nPar function" << endl;
return EXIT_FAILURE;
}
}
// fit /////////////////////////////////////////////////////////////////////
DMatSample tvec(nSample);
XYSampleData data(nSample);
SampleFitResult fit;
DVec init(nPar);
NloptMinimizer globMin(NloptMinimizer::Algorithm::GN_CRS2_LM);
MinuitMinimizer locMin;
vector<Minimizer *> unCorrMin{&globMin, &locMin};
FOR_STAT_ARRAY(tvec, s)
{
tvec[s] = DVec::LinSpaced(nt, 0, nt - 1);
}
data.addXDim(nt, "t/a", true);
data.addYDim("C(t)");
data.setUnidimData(tvec, corr);
for (Index p = 0; p < nPar; p += 2)
{
mod.parName().setName(p, "E_" + strFrom(p/2));
mod.parName().setName(p + 1, "Z_" + strFrom(p/2));
}
init(0) = log(data.y(nt/4, 0)[central]/data.y(nt/4 + 1, 0)[central]);
init(1) = data.y(nt/4, 0)[central]/(exp(-init(0)*nt/4));
for (Index p = 2; p < nPar; p += 2)
{
init(p) = 2*init(p - 2);
init(p + 1) = init(p - 1)/2.;
}
for (Index p = 0; p < nPar; p += 2)
{
globMin.setLowLimit(p, 0.);
globMin.setHighLimit(p, 10.*init(p));
globMin.setLowLimit(p + 1, -10.*init(p + 1));
globMin.setHighLimit(p + 1, 10.*init(p + 1));
locMin.setLowLimit(p, 0.);
}
globMin.setPrecision(0.001);
globMin.setMaxIteration(100000);
globMin.setVerbosity(verbosity);
locMin.setMaxIteration(1000000);
locMin.setVerbosity(verbosity);
for (Index t = 0; t < nt; ++t)
{
data.fitPoint((t >= ti) and (t <= tf)
and ((t - ti) % thinning == 0), t);
}
if (doCorr)
{
cout << "-- uncorrelated fit..." << endl;
}
cout << "using model '" << model << "'" << endl;
data.setSvdTolerance(svdTol);
data.assumeYYCorrelated(false, 0, 0);
fit = data.fit(unCorrMin, init, mod);
fit.print();
if (doCorr)
{
cout << "-- correlated fit..." << endl;
cout << "using model '" << model << "'" << endl;
init = fit[central];
data.assumeYYCorrelated(true, 0, 0);
fit = data.fit(locMin, init, mod);
fit.print();
}
// plots ///////////////////////////////////////////////////////////////////
if (doPlot)
{
Plot p;
DMatSample effMass(nSample);
DVec effMassT, fitErr;
Index maxT = (coshModel) ? (nt - 2) : (nt - 1);
double e0, e0Err;
p << PlotRange(Axis::x, 0, nt - 1);
p << LogScale(Axis::y);
p << Color("rgb 'blue'") << PlotPredBand(fit.getModel(_), 0, nt - 1);
p << Color("rgb 'blue'") << PlotFunction(fit.getModel(), 0, nt - 1);
p << Color("rgb 'red'") << PlotData(data.getData());
p.display();
effMass.resizeMat(maxT, 1);
effMassT.setLinSpaced(maxT, 1, maxT);
fitErr = fit.variance().cwiseSqrt();
e0 = fit[central](0);
e0Err = fitErr(0);
if (coshModel)
{
FOR_STAT_ARRAY(effMass, s)
{
for (Index t = 1; t < nt - 1; ++t)
{
effMass[s](t - 1) = acosh((corr[s](t-1) + corr[s](t+1))
/(2.*corr[s](t)));
}
}
}
else
{
FOR_STAT_ARRAY(effMass, s)
{
for (Index t = 1; t < nt; ++t)
{
effMass[s](t - 1) = log(corr[s](t-1)/corr[s](t));
}
}
}
p.reset();
p << PlotRange(Axis::x, 1, maxT);
p << PlotRange(Axis::y, e0 - 20.*e0Err, e0 + 20.*e0Err);
p << Color("rgb 'blue'") << PlotBand(0, maxT, e0 - e0Err, e0 + e0Err);
p << Color("rgb 'blue'") << PlotHLine(e0);
p << Color("rgb 'red'") << PlotData(effMassT, effMass);
p.display();
p.save("test");
}
if (doHeatmap)
{
Plot p;
Index n = data.getFitVarMat().rows();
DMat id = DMat::Identity(n, n);
p << PlotMatrix(Math::varToCorr(data.getFitVarMat()));
p << Caption("correlation matrix");
p.display();
if (svdTol > 0.)
{
p.reset();
p << PlotMatrix(id - data.getFitVarMat()*data.getFitVarMatPInv());
p << Caption("singular space projector");
p.display();
}
}
// output //////////////////////////////////////////////////////////////////
if (!outFileName.empty())
{
Io::save(fit, outFileName);
}
return EXIT_SUCCESS;
}

1
physics/LatAnalyze Symbolic link
View File

@ -0,0 +1 @@
../lib

15
physics/Makefile.am Normal file
View File

@ -0,0 +1,15 @@
if CXX_GNU
COM_CXXFLAGS = -Wall -W -pedantic -Wno-deprecated-declarations
else
if CXX_INTEL
COM_CXXFLAGS = -wd1682 -Wall
endif
endif
bin_PROGRAMS = latan-2pt-fit
latan_2pt_fit_SOURCES = 2pt-fit.cpp
latan_2pt_fit_CXXFLAGS = $(COM_CXXFLAGS)
latan_2pt_fit_LDFLAGS = -L../lib/.libs -lLatAnalyze
ACLOCAL_AMFLAGS = -I .buildutils/m4

29
utils/Makefile.am
View File

@ -7,25 +7,30 @@ endif
endif
bin_PROGRAMS = \
latan_make_fake_sample\
latan_sample_combine \
latan_sample_plot_corr\
latan_sample_read \
latan_resample
latan-sample-combine \
latan-sample-element \
latan-sample-fake \
latan-sample-plot-corr\
latan-sample-read \
latan-resample
latan_make_fake_sample_SOURCES = make_fake_sample.cpp
latan_make_fake_sample_CXXFLAGS = $(COM_CXXFLAGS)
latan_make_fake_sample_LDFLAGS = -L../lib/.libs -lLatAnalyze
latan_sample_combine_SOURCES = sample_combine.cpp
latan_sample_combine_SOURCES = sample-combine.cpp
latan_sample_combine_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_combine_LDFLAGS = -L../lib/.libs -lLatAnalyze
latan_sample_plot_corr_SOURCES = sample_plot_corr.cpp
latan_sample_element_SOURCES = sample-element.cpp
latan_sample_element_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_element_LDFLAGS = -L../lib/.libs -lLatAnalyze
latan_sample_fake_SOURCES = sample-fake.cpp
latan_sample_fake_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_fake_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_read_SOURCES = sample_read.cpp
latan_sample_read_SOURCES = sample-read.cpp
latan_sample_read_CXXFLAGS = $(COM_CXXFLAGS)
latan_sample_read_LDFLAGS = -L../lib/.libs -lLatAnalyze

90
utils/resample.cpp
View File

@ -17,74 +17,66 @@
* along with LatAnalyze 3. If not, see <http://www.gnu.org/licenses/>.
*/
#include <LatCore/OptParser.hpp>
#include <LatAnalyze/Dataset.hpp>
#include <LatAnalyze/Io.hpp>
#include <LatAnalyze/includes.hpp>
#ifndef DEF_NSAMPLE
#define DEF_NSAMPLE 100
#define DEF_NSAMPLE "100"
#endif
#ifdef HAVE_HDF5
#define DEF_FMT "h5"
#else
#define DEF_FMT "sample"
#endif
using namespace std;
using namespace Latan;
static void usage(const string &cmdName)
{
cerr << "usage: " << cmdName;
cerr << " [-n <nsample> -b <bin size> -r <seed> -o <output dir> -f {h5|sample}]";
cerr << " <data list> <name list>";
cerr << endl;
exit(EXIT_FAILURE);
}
int main(int argc, char *argv[])
{
// argument parsing ////////////////////////////////////////////////////////
int c;
OptParser opt;
bool parsed;
random_device rd;
SeedType seed = rd();
string manFileName, nameFileName, cmdName, outDirName = ".";
string ext = "h5";
Index binSize = 1, nSample = DEF_NSAMPLE;
string manFileName, nameFileName, outDirName;
string ext;
Index binSize, nSample;
opterr = 0;
cmdName = basename(argv[0]);
while ((c = getopt(argc, argv, "b:n:r:o:f:")) != -1)
opt.addOption("n", "nsample" , OptParser::OptType::value, true,
"number of samples", DEF_NSAMPLE);
opt.addOption("b", "bin" , OptParser::OptType::value, true,
"bin size", "1");
opt.addOption("r", "seed" , OptParser::OptType::value, true,
"random generator seed (default: random)");
opt.addOption("o", "output-dir", OptParser::OptType::value, true,
"output directory", ".");
opt.addOption("f", "format" , OptParser::OptType::value, true,
"output file format", DEF_FMT);
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"))
{
switch (c)
{
case 'b':
binSize = strTo<Index>(optarg);
break;
case 'n':
nSample = strTo<Index>(optarg);
break;
case 'o':
outDirName = optarg;
break;
case 'r':
seed = strTo<SeedType>(optarg);
break;
case 'f':
ext = optarg;
break;
case '?':
cerr << "error parsing option -" << char(optopt) << endl;
usage(cmdName);
break;
default:
usage(cmdName);
break;
}
cerr << "usage: " << argv[0];
cerr << " <datafile list> <name list> <options>" << endl;
cerr << endl << "Possible options:" << endl << opt << endl;
return EXIT_FAILURE;
}
if (argc - optind == 2)
nSample = opt.optionValue<Index>("n");
binSize = opt.optionValue<Index>("b");
if (opt.gotOption("r"))
{
manFileName = argv[optind];
nameFileName = argv[optind+1];
}
else
{
usage(cmdName);
seed = opt.optionValue<SeedType>("r");
}
ext = opt.optionValue("f");
outDirName = opt.optionValue("o");
manFileName = opt.getArgs()[0];
nameFileName = opt.getArgs()[1];
// parameter parsing ///////////////////////////////////////////////////////
vector<string> dataFileName, name;

73
utils/sample_combine.cpp → utils/sample-combine.cpp
View File

@ -17,28 +17,19 @@
* along with LatAnalyze 3. If not, see <http://www.gnu.org/licenses/>.
*/
#include <LatCore/OptParser.hpp>
#include <LatAnalyze/Io.hpp>
#include <LatAnalyze/CompiledFunction.hpp>
using namespace std;
using namespace Latan;
static void usage(const string &cmdName)
{
cerr << "usage: " << cmdName;
cerr << " [-o <output sample>]";
cerr << " <n> <function> <sample 1> ... <sample n>";
cerr << endl;
exit(EXIT_FAILURE);
}
template <typename T>
static void loadAndCheck(vector<T> &sample, const vector<string> &fileName)
{
const unsigned int n = sample.size();
Index nSample = 0;
cout << "-- loading data..." << endl;
for (unsigned int i = 0; i < n; ++i)
{
sample[i] = Io::load<T>(fileName[i]);
@ -137,49 +128,41 @@ void process(const string &outFileName, const vector<string> &fileName,
int main(int argc, char *argv[])
{
// argument parsing ////////////////////////////////////////////////////////
OptParser opt;
bool parsed;
string cmdName, outFileName = "", code;
vector<string> fileName;
int c;
unsigned int n = 0;
opterr = 0;
cmdName = basename(argv[0]);
while ((c = getopt(argc, argv, "o:")) != -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 (opt.getArgs().size() >= 1)
{
switch (c)
{
case 'o':
outFileName = optarg;
break;
case '?':
cerr << "error parsing option -" << char(optopt) << endl;
usage(cmdName);
break;
default:
usage(cmdName);
break;
}
}
if (argc - optind >= 1)
{
n = strTo<unsigned int>(argv[optind]);
if (argc - optind == static_cast<int>(n + 2))
{
fileName.resize(n);
code = argv[optind + 1];
for (unsigned int i = 0; i < n; ++i)
{
fileName[i] = argv[optind + 2 + i];
}
}
else
{
usage(cmdName);
}
n = strTo<unsigned int>(opt.getArgs()[0]);
}
else
{
usage(cmdName);
parsed = false;
}
if (!parsed or (opt.getArgs().size() != n + 2) or opt.gotOption("help"))
{
cerr << "usage: " << argv[0];
cerr << " <options> <n> <function> <sample 1> ... <sample n>" << endl;
cerr << endl << "Possible options:" << endl << opt << endl;
return EXIT_FAILURE;
}
if (opt.gotOption("o"))
{
outFileName = opt.optionValue("o");
}
code = opt.getArgs()[1];
for (unsigned int i = 0; i < n; ++i)
{
fileName.push_back(opt.getArgs()[2 + i]);
}
// process data ////////////////////////////////////////////////////////////

39
utils/sample-element.cpp Normal file
View File

@ -0,0 +1,39 @@
#include <iostream>
#include <string>
#include <LatAnalyze/Io.hpp>
#include <LatAnalyze/MatSample.hpp>
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;
}
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())
{
DSample outputData(inputData.size());
FOR_STAT_ARRAY(inputData, s) {
outputData[s] = inputData[s](row, col);
}
Io::save(outputData, outFileName);
}
}

0
utils/make_fake_sample.cpp → utils/sample-fake.cpp
View File

1
utils/sample_plot_corr.cpp → utils/sample-plot-corr.cpp
View File

@ -42,6 +42,7 @@ int main(int argc, char *argv[])
cout << "-- computing variance matrix from '" << fileName << "'..." << endl;
name = Io::getFirstName(fileName);
sample = Io::load<DMatSample>(fileName);
sample = sample.block(0, 0, sample[central].rows(), 1);
var = sample.varianceMatrix();
p << PlotMatrix(varToCorr(var));
p.display();

0
utils/sample_read.cpp → utils/sample-read.cpp
View File