void tst1() {
std::cerr << singleton(10) << "\n";
std::cerr << all() << "\n";
std::cerr << l(-10) << "\n";
std::cerr << r(10) << "\n";
std::cerr << l(-10, true) << "\n";
std::cerr << r(10, true) << "\n";
std::cerr << b(2, 10) << "\n";
std::cerr << wd(b(-5, 5, true, false, 1, 2) * b(-5, 5, false, true, 3, 4)) << "\n";
std::cerr << wd(l(2, false, 1) / b(2, 6, false, false, 2, 3)) << "\n";
std::cerr << wd(expt(b(-2, 3, true, false, 1, 2), 2)) << "\n";
std::cerr << wd(expt(b(-4, 3, true, false, 1, 2), 2)) << "\n";
std::cerr << wd(expt(b(2, 4, true, false, 1, 2), 2)) << "\n";
std::cerr << wd(expt(b(0, 3, true, false, 1, 2), 2)) << "\n";
std::cerr << wd(expt(b(-4, -2, true, false, 1, 2), 2)) << "\n";
std::cerr << b(2, 10, false, false, 1, 2) << " * " << l(10, false, 3).inv() << " = " << wd(b(2, 10, false, false, 1, 2) / l(10, false, 3)) << "\n";
std::cerr << b(-2, -1, false, true) << " * " << b(-3,0) << " = "; std::cerr.flush();
std::cerr << (b(-2, -1, false, true) * b(-3,0)) << "\n";
std::cerr << b(1, 2, true, false) << " * " << b(0,3) << " = "; std::cerr.flush();
std::cerr << (b(1, 2, true, false) * b(0,3)) << "\n";
std::cerr << b(1, 2, true, true) << " * " << b(-3,0) << " = "; std::cerr.flush();
std::cerr << (b(1, 2, true, true) * b(-3,0)) << "\n";
std::cerr << b(10,20) << " / " << b(0,1,true,false) << " = "; std::cerr.flush();
std::cerr << (b(10,20)/b(0,1,true,false)) << "\n";
std::cerr << (b(10,20)/b(0,2,true,false)) << "\n";
}
void QxrdSimpleServerThread::run()
{
{
QxrdExperimentPtr expt(m_Experiment);
if (expt && qcepDebug(DEBUG_THREADS)) {
expt->printMessage("Starting Simple Server Thread");
}
QxrdSimpleServerPtr server(new QxrdSimpleServer(m_Saver, m_Experiment, m_Name));
if (server) {
m_Mutex.lock();
// server->moveToThread(g_Application->thread());
m_Server = server;
m_Mutex.unlock();
}
}
int rc = -1;
rc = exec();
{
QxrdExperimentPtr expt(m_Experiment);
if (expt && qcepDebug(DEBUG_THREADS)) {
expt->printMessage(tr("Simple Server Thread Terminated with rc %1").arg(rc));
}
}
}
static double nicenum(double x, int round)
{
int exp; /* exponent of x */
double f; /* fractional part of x */
double nf; /* nice, rounded fraction */
double sign = (x >= 0) ? 1.0 : -1.0;
double ax = x / sign; /* Absolute value of x*/
exp = floor(log10(ax));
f = ax/expt(10., exp); /* between 1 and 10 */
if (round)
{
if (f<1.5)
nf = 1.;
else if (f<3.)
nf = 2.;
else if (f<7.)
nf = 5.;
else
nf = 10.;
}
else
{
if (f<=1.)
nf = 1.;
else if (f<=2.)
nf = 2.;
else if (f<=5.)
nf = 5.;
else
nf = 10.;
}
return sign*nf*expt(10., exp);
}
int main(int argc, char *argv[]) {
printf("%d\n", expt(2, 10));
printf("%d\n", expt(2, 11));
printf("%d\n", expt(7, 3));
printf("%d\n", expt(7, 0));
printf("%d\n", expt(3, 6));
return 0;
}
void evidence_expt()
{
printf("Tests for expt\n");
printf("Expecting 1024: %ld\n", expt(2,10)); /* 1024 */
printf("Expecting 134217728: %ld\n", expt(8,9)); /* 134217728 */
printf("Expecting 96059601: %ld\n", expt(99,4)); /* 96059601 */
printf("Expecting 184528125: %ld\n", expt(45,5)); /* 184528125 */
}
QcepIntegratedDataPtr QxrdIntegrator::performIntegration(QcepIntegratedDataPtr integ, QcepDoubleImageDataPtr dimg, QcepMaskDataPtr mask)
{
if (qcepDebug(DEBUG_INTEGRATOR)) {
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
expt->printMessage(tr("QxrdIntegrator::performIntegration(\"%1\")")
.arg(dimg->get_FileName()));
}
}
QThread::currentThread()->setObjectName("performIntegration");
QxrdIntegratorCachePtr cache = m_IntegratorCache;
if (cache == NULL ||
dimg->get_Width() != cache->get_NCols() ||
dimg->get_Height() != cache->get_NRows()) {
cache = QxrdIntegratorCachePtr(
new QxrdIntegratorCache(m_Experiment, sharedFromThis(), m_CenterFinder));
m_IntegratorCache = cache;
}
return cache->performIntegration(integ, dimg, mask, true);
}
QcepDoubleImageDataPtr QxrdCenterFinder::newData()
{
int wd, ht;
if (m_Data) {
wd = m_Data->get_Width();
ht = m_Data->get_Height();
} else {
wd = 2048;
ht = 2048;
}
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
QxrdDataProcessorPtr proc(expt->dataProcessor());
if (proc) {
QcepDoubleImageDataPtr res = proc->takeNextFreeImage(wd,ht);
return res;
}
}
return QcepDoubleImageDataPtr();
}
/* A^pという行列のべき乗計算 */
Matrix2x2 expt(Matrix2x2 A, ll p) {
if (p == 0) {
Matrix2x2 I;
I.a = 1; I.b = 0; I.c = 0; I.d = 1;
return I;
}
if (p == 1) {
return A;
} else if (p % 2) {
Matrix2x2 T = expt(A, p-1);
return mult(A, T);
} else {
Matrix2x2 T = expt(A, p/2);
return mult(T, T);
}
}
int main(int argc, char** argv)
{
CppUnit::TestSuite suite;
ExpTest expt("ExpTest");
ProgTest progt("ProgTest");
ProcTest proct("ProcTest");
RtlTest rtlt("RtlTest");
ParserTest parsert("ParserTest");
TypeTest typet("TypeTest");
expt.registerTests(&suite);
progt.registerTests(&suite);
proct.registerTests(&suite);
rtlt.registerTests(&suite);
parsert.registerTests(&suite);
typet.registerTests(&suite);
CppUnit::TextTestResult res;
suite.run( &res );
std::cout << res << std::endl;
return 0;
}
QcepIntegratedDataPtr QxrdIntegrator::slicePolygon(QcepIntegratedDataPtr integ, QcepDoubleImageDataPtr image, QVector<QPointF> poly, double /*width*/)
{
QThread::currentThread()->setObjectName("slicePolygon");
if (integ && image) {
double length = 0;
if (poly.size() >= 2) {
QPointF p0 = poly[0];
for (int i=1; i<poly.size(); i++) {
QPointF p1 = poly[i];
double dx = p1.x() - p0.x();
double dy = p1.y() - p0.y();
length += sqrt(dx*dx + dy*dy);
p0=p1;
}
p0 = poly[0];
double r = 0;
double r0 = 0;
// QVector<double> xs,ys;
integ -> resize(0);
for (int i=1; i<poly.size(); i++) {
QPointF p1 = poly[i];
double dx = p1.x() - p0.x();
double dy = p1.y() - p0.y();
double len = sqrt(dx*dx + dy*dy);
if (len > 0) {
for (; r<len; r+=1) {
double x = p0.x() + r*dx/len;
double y = p0.y() + r*dy/len;
integ -> append(r+r0, image->value((int) x, (int) y));
}
}
p0 = p1;
r0 += len;
r -= len;
}
//
// emit newIntegrationAvailable(image->get_Title(),xs,ys);
}
} else {
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
expt->printMessage("QxrdIntegrator::slicePolygon failed");
}
}
return integ;
}
QxrdDataProcessorWPtr QxrdIntegrator::dataProcessor() const
{
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
return expt->dataProcessor();
} else {
return QxrdDataProcessorWPtr();
}
}
void QxrdIntegrator::onIntegrationParametersChanged()
{
if (qcepDebug(DEBUG_INTEGRATOR)) {
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
expt->printMessage("Integration parameters changed");
}
}
m_IntegratorCache = QxrdIntegratorCachePtr();
}
void QxrdScriptEditWidget::executeSelectedText()
{
QString sel = textCursor().selectedText();
if (sel.length() == 0) {
sel = this->toPlainText();
}
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
expt->executeCommand(sel);
}
}
BOOLEAN rabin_miller(unsigned long int number, short witness) {
int i, k;
int q = number - 1;
int result;
BOOLEAN prime = FALSE;
/* Shift q right and increment k while q is even
At the end k and q will be such that number - 1 = q*(2^k)
*/
for (k = 0; !(q & 1); k++, q >>= 1) ;
for (i = 0, result = expt(witness, q, number);
i < k && !prime;
i++, result = expt(result, 2, number)) {
prime = (result == number - 1) || (result == 1 && i == 0);
}
/* Return true if witness considers the number prime */
return prime;
}
void QxrdIntegrator::saveAccumulator(QString resPath, QString &fileName, QString filter)
{
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
QcepDatasetModelPtr ds = expt->dataset();
if (ds) {
QcepDoubleImageDataPtr data = ds->image(resPath);
if (data) {
data -> saveData(fileName, filter);
}
}
}
}
QxrdDetectorThread::~QxrdDetectorThread()
{
if (qcepDebug(DEBUG_APP)) {
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
expt->printMessage("QxrdDetectorThread::~QxrdDetectorThread");
}
}
shutdown();
if (qcepDebug(DEBUG_CONSTRUCTORS)) {
printf("QxrdDetectorThread::~QxrdDetectorThread(%p)\n", this);
}
}
void QxrdIntegrator::prepareAccumulator(QString resPath, int nImages)
{
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
QcepDatasetModelPtr ds = expt->dataset();
if (ds) {
QcepDoubleImageDataPtr data = ds->image(resPath);
if (!data) {
data = ds->newImage(resPath);
}
}
}
}
QcepIntegratedDataPtr QxrdIntegrator::sliceLine(QcepIntegratedDataPtr integ, QcepDoubleImageDataPtr image, double x0, double y0, double x1, double y1, double width)
{
try {
QVector<QPointF> poly;
poly.append(QPointF(x0,y0));
poly.append(QPointF(x1,y1));
return slicePolygon(integ, image, poly, width);
}
catch (...) {
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
expt->printMessage("QxrdIntegrator::sliceLine failed");
}
}
return QcepIntegratedDataPtr();
}
void QxrdIntegrator::appendIntegration(QString resPath, QcepDoubleImageDataPtr dimg, QcepMaskDataPtr mask)
{
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
QcepDatasetModelPtr ds = expt->dataset();
if (ds) {
QcepDoubleImageDataPtr data = ds->image(resPath);
if (!data) {
data = ds->newImage(resPath);
}
if (data) {
appendIntegration(data, dimg, mask);
}
}
}
}
void QxrdIntegrator::clearAccumulator(QString resPath)
{
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
QcepDatasetModelPtr ds = expt->dataset();
if (ds) {
QcepDoubleImageDataPtr data = ds->image(resPath);
if (!data) {
data = ds->newImage(resPath);
}
if (data) {
data->resize(0, 0);
}
}
}
}
void QxrdIntegrator::appendIntegration(QString resPath, QcepIntegratedDataPtr integ)
{
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
QcepDatasetModelPtr ds = expt->dataset();
if (ds) {
QcepDoubleImageDataPtr data = ds->image(resPath);
if (!data) {
data = ds->newImage(resPath);
}
if (data) {
appendIntegration(data, integ);
} else {
printMessage(tr("Unable to accumulate integrated data into %1").arg(resPath));
}
}
}
}
void QxrdDetectorThread::run()
{
QxrdDetectorPtr p;
{
QxrdExperimentPtr expt(m_Experiment);
if (expt && qcepDebug(DEBUG_THREADS)) {
expt->printMessage("Starting Detector Thread");
}
if (qcepDebug(DEBUG_THREADS)) {
printf("Starting Detector Thread\n");
}
if (expt) {
switch(expt->get_DetectorType()) {
case SimulatedDetector:
setObjectName("simulatedDetector");
p = QxrdDetectorPtr(new QxrdDetectorSimulated(m_Experiment, m_Acquisition));
break;
#ifdef HAVE_PERKIN_ELMER
case PerkinElmerDetector:
setObjectName("perkinElmerDetector");
p = QxrdDetectorPtr(new QxrdDetectorPerkinElmer(m_Experiment, m_Acquisition));
break;
#endif
#ifdef HAVE_PILATUS
case PilatusDetector:
setObjectName("pilatusDetector");
p = QxrdDetectorPtr(new QxrdDetectorPilatus(m_Experiment, m_Acquisition));
break;
#endif
#ifdef HAVE_AREADETECTOR
case EpicsAreaDetector:
setObjectName("epicsAreaDetector");
p = QxrdDetectorPtr(new QxrdDetectorEpicsArea(m_Experiment, m_Acquisition));
break;
#endif
case FileWatcherDetector:
setObjectName("fileWatcherDetector");
p = QxrdDetectorPtr(new QxrdDetectorFileWatcher(m_Experiment, m_Acquisition));
break;
}
}
}
if (p == NULL) {
p = QxrdDetectorPtr(new QxrdDetectorSimulated(m_Experiment, m_Acquisition));
}
int rc = -1;
if (p) {
p -> initialize();
m_Mutex.lock();
m_Detector = p;
m_Mutex.unlock();
rc = exec();
}
{
QxrdExperimentPtr expt(m_Experiment);
if (expt && qcepDebug(DEBUG_THREADS)) {
expt->printMessage(tr("Detector Thread Terminated with rc %1").arg(rc));
}
if (qcepDebug(DEBUG_THREADS)) {
printf("Detector Thread Terminated with rc %d\n", rc);
}
}
}
//
// Find a root of a complex polynomial by Laguerre iteration.
//
// The polynomial is Poly
// The order is Maxpow
//
// The precision: Digit
cln::cl_N HighPrecisionComplexPolynom::Lasolv(cln::cl_N* Poly, int Maxpow, cln::cl_N root, int itemax) {
int pow, ite;
root = complex(ZERO,ZERO);
cln::cl_F angl, small = As(cln::cl_F)(expt(cln::cl_float(0.1,clnDIGIT),DIGIT/2));
cln::cl_N dif1[Maxpow], dif2[Maxpow-1];
cln::cl_N val0, val, val1, val2, denp, denm, las1, las2, sqrv;
// cln::cl_N root;
for(pow = 0; pow < Maxpow; pow++)
dif1[pow] = (pow+1)*Poly[pow+1];
for(pow = 0; pow < Maxpow-1; pow++)
dif2[pow] = (pow+1)*dif1[pow+1];
// The maximal allowed number of iterations is set here;
// this can be chosen larger, but 100 usually suffices
// root = As(cln::cl_N)(complex(ZERO,ZERO));
val0 = EvalPoly(Poly,Maxpow,root);
// Iteration
for(ite = 0; ite < itemax; ite++)
{
val = val0;
val1 = EvalPoly(dif1,Maxpow-1,root);
val2 = EvalPoly(dif2,Maxpow-2,root);
sqrv = (Maxpow-1)*((Maxpow-1)*val1*val1-Maxpow*val0*val2);
angl = HALF*cln::cl_float(phase(sqrv),clnDIGIT);
sqrv = sqrt(abs(sqrv))*complex(cos(angl),sin(angl));
denp = val1+sqrv;
denm = val1-sqrv;
if(denp == complex(ZERO,ZERO))
root = root-Maxpow*val0/denm;
else
{ if(denm == complex(ZERO,ZERO))
root = root-Maxpow*val0/denp;
else
{ las1 = -Maxpow*val0/denp;
las2 = -Maxpow*val0/denm;
if(realpart(las1*conjugate(las1)) <
realpart(las2*conjugate(las2)))
root = root+las1;
else
root = root+las2; } }
// Look whether the root is good enough
val0 = EvalPoly(Poly,Maxpow,root);
if(abs(val0) == ZERO || (abs(val0) < small) && abs(val0/val) > 0.7) {
if(LogLevel>4) {
printf("Laguerre iterations: %d\n", ite);
printf("root = %f +i* %f\n", double_approx(realpart(root)), double_approx(imagpart(root)));
printf("value at root: %f +i* %f\n", double_approx(realpart(val0)), double_approx(imagpart(val0)));
}
break;
}
}
if(ite >= itemax) {
printf("Laguerre iteration did not converge\n");
exit(5);
}
return root;
}
void QxrdHistogramDialog::recalculateHistogram()
{
QxrdHistogramDialogSettingsPtr set(m_HistogramDialogSettings);
if (set && m_Image) {
QxrdExperimentPtr expt(m_Experiment);
if (expt) {
QTime tic;
tic.start();
QRectF rect = set->get_HistogramRect();
int nsum = m_Image->get_SummedExposures();
if (nsum < 1) {
nsum = 1;
}
QxrdAcquisitionPtr acq(expt->acquisition());
double satlev = 60000;
if (acq) {
satlev = acq->get_OverflowLevel();
}
double min = 0, max = satlev*nsum;
const int nbins=1000;
QcepDoubleVector x0(nbins), h0(nbins), h1(nbins);
for (int i=0; i<nbins; i++) {
// double x = min+i*(max-min)/1000.0;
x0[i] = i*100.0/(double)nbins;
h0[i] = 0;
h1[i] = 0;
}
int width = m_Image->get_Width();
int height= m_Image->get_Height();
double *data = m_Image->data();
for (int i=0; i<width; i++) {
for (int j=0; j<height; j++) {
double v = *data++;
int n;
if (v<min) {
n=0;
} else if (v>max) {
n=nbins-1;
} else {
n=(nbins-1)*(v-min)/(max-min);
}
if (n<0) {
n=0;
}
if (n>=nbins) {
n=nbins-1;
}
h0[n]++;
if (rect.contains(i,j)) {
h1[n]++;
}
}
}
m_HistogramPlot->detachItems();
QwtPlotPiecewiseCurve *pc0 = new QwtPlotPiecewiseCurve(m_HistogramPlot, "Entire Image");
pc0->setSamples(x0, h0);
pc0->setPen(QPen(Qt::red));
pc0->attach(m_HistogramPlot);
QwtPlotPiecewiseCurve *pc1 = new QwtPlotPiecewiseCurve(m_HistogramPlot,
tr("[%1,%2]-[%3,%4]")
.arg(rect.left()).arg(rect.bottom())
.arg(rect.right()).arg(rect.top()));
pc1->setSamples(x0, h1);
pc1->setPen(QPen(Qt::darkRed));
pc1->attach(m_HistogramPlot);
m_HistogramPlot->replot();
if (qcepDebug(DEBUG_HISTOGRAM)) {
expt -> printMessage(tr("Histogram of data took %1 msec").arg(tic.elapsed()));
}
}
}
}
