int behindDue_Common(Task** tasks, float Cmax)
{
int i;
for (i = _nbTasks - 1; i >= 0; i--)
{
if(Cmax == tasks[i]->endingTime)
{
Cmax = tasks[i]->beginningTime;
tasks[i]->nbWorkersToAssign = minInt(tasks[i]->nbWorkersToAssign + 1, minInt(_nbWorkers + 1, tasks[i]->workersMax));
}
}
return _nbWorkers + 1;
}
void test_minInt(void) {
int actual = minInt(0, 0);
TEST_ASSERT_EQUAL(0, actual);
actual = minInt(0, 25000);
TEST_ASSERT_EQUAL(0, actual);
actual = minInt(25000, 0);
TEST_ASSERT_EQUAL(0, actual);
actual = minInt(-25000, 0);
TEST_ASSERT_EQUAL(-25000, actual);
actual = minInt(-25000, 100);
TEST_ASSERT_EQUAL(-25000, actual);
actual = minInt(-25000, 30000);
TEST_ASSERT_EQUAL(-25000, actual);
actual = minInt(-25000, 22000);
TEST_ASSERT_EQUAL(-25000, actual);
actual = minInt(10, 30000);
TEST_ASSERT_EQUAL(10, actual);
}
void OutlineElement::drawLine( WWindow * win, int & idx,
int width, int height )
//----------------------------------------------------------------
{
OutlineElement * elm;
WPoint start( width * _level + width / 2, height * (idx + 1) );
WPoint end( start );
WOrdinal maxY = height * win->getRows();
idx += 1;
if( _state == ESExpanded ) {
for( elm = _child; elm != NULL && idx < win->getRows() + 1;
elm = elm->visibleSib() ) {
end = WPoint( width * elm->_level,
height * idx + height / 2 );
if( end.y() < maxY ) {
win->drawLine( WPoint( start.x(), end.y() ), end, ColorBlack );
elm->drawLine( win, idx, width, height );
}
if( elm->_lastSib ) {
break;
}
}
end.x( start.x() );
end.y( minInt( end.y(), maxY ) );
if( start.y() < maxY ) {
win->drawLine( start, end, ColorBlack );
}
}
}
int CheckedFile::readNString( String & str )
//------------------------------------------
// read in a string in the form <uint_16>{<byte>}*
{
const int BufLen = 255;
char buffer[ BufLen + 1 ];
uint_16 strLen;
uint_16 amtRead = 0;
int maxRead;
str = ""; // clear string
read( &strLen, sizeof( uint_16 ) );
while( amtRead < strLen ) {
maxRead = minInt( BufLen, strLen - amtRead );
read( buffer, maxRead );
buffer[ maxRead ] = '\0';
str += buffer;
amtRead += maxRead;
}
return strLen;
}
int main(int argc, char **argv){
uint32_t datarows, datacolumns;
uint32_t indexrows, indexcolumns;
uint32_t prows, pcolumns;
uint32_t i, j, k, k1, k2;
//Check input arguments
if (argc != 4) {
fprintf(stderr,"USAGE: %s <PerplexResults.tsv> <index.tsv> <pressure.tsv>\n", argv[0]);
exit(1);
}
// Import data
double* const data = csvparseflat(argv[1],'\t', &datarows, &datacolumns);
double* const index = csvparseflat(argv[2],'\t', &indexrows, &indexcolumns);
double* const pressure = csvparseflat(argv[3],'\t', &prows, &pcolumns);
// printf("Data rows: %i, Data columns: %i\n",datarows,datacolumns);
// printf("Index rows: %i, Index columns: %i\n",indexrows,indexcolumns);
// printf("Pressure rows: %i, Pressure columns: %i\n",prows,pcolumns);
// Convert indices to unsigned intergers for faster comparision
uint32_t* restrict target = malloc(indexrows * sizeof(uint32_t));
uint32_t* restrict source = malloc(datarows * sizeof(uint32_t));
for (i=0; i<indexrows; i++){
target[i] = (uint32_t) round(index[i]);
}
for (j=0; j<datarows; j++){
source[j] = (uint32_t) round(data[0*datarows + j]);
}
uint32_t jmin, step;
// Find first line of real output
for (jmin=0; isnan(data[0*datarows+jmin]); jmin++){
}
// Find output step size
for (step=1; source[jmin+step]==source[jmin]; step++) {
}
// printf("jmin: %i\n",jmin);
// printf("Step size: %i\n",step);
// Make target variables and initialize with NANs
double* restrict Rho = malloc(indexrows * sizeof(double));
for (i=0; i<indexrows; i++) Rho[i]=NAN;
double* restrict Vp = malloc(indexrows * sizeof(double));
for (i=0; i<indexrows; i++) Vp[i]=NAN;
double* restrict VpVs = malloc(indexrows * sizeof(double));
for (i=0; i<indexrows; i++) VpVs[i]=NAN;
double* restrict RhoStdErr = malloc(indexrows * sizeof(double));
for (i=0; i<indexrows; i++) RhoStdErr[i]=NAN;
double* restrict VpStdErr = malloc(indexrows * sizeof(double));
for (i=0; i<indexrows; i++) VpStdErr[i]=NAN;
double* restrict VpVsStdErr = malloc(indexrows * sizeof(double));
for (i=0; i<indexrows; i++) VpVsStdErr[i]=NAN;
double r1, r2, rmin1, rmin2, p1, p2;
// pcg32_random_t rng;
// pcg32_srandom_r(&rng,time(NULL), clock());
for (i=0; i<indexrows; i++){
for (j=jmin; j<datarows; j += step){
if (source[j]==target[i]){
// Find best pressure match for first pressure
p1 = pressure[0*prows + i];
p2 = pressure[1*prows + i];
rmin1 = p1;
rmin2 = p2;
k1 = 0;
k2 = 0;
for (k=0; k<100; k++){
r1=fabs(p1 - data[1*datarows + j + k]);
r2=fabs(p2 - data[1*datarows + j + k]);
if (r1 < rmin1) {
rmin1 = r1;
k1 = k;
}
if (r2 < rmin2) {
rmin2 = r2;
k2 = k;
}
}
Offset_nanstderr(&data[3*datarows + j + minInt(k1,k2)], (uint32_t)abs(k2-k1), &Rho[i], &RhoStdErr[i]);
Offset_nanstderr(&data[4*datarows + j + minInt(k1,k2)], (uint32_t)abs(k2-k1), &Vp[i], &VpStdErr[i]);
Offset_nanstderr(&data[5*datarows + j + minInt(k1,k2)], (uint32_t)abs(k2-k1), &VpVs[i], &VpVsStdErr[i]);
// Save fitting results
// Rho[i] = data[3*datarows + j + kmin];// * (1 + pcg_gaussian_ziggurat(&rng, 0.005)); //Rho
// Vp[i] = data[4*datarows + j + kmin];// * (1 + pcg_gaussian_ziggurat(&rng, 0.005)); //Vp
// VpVs[i] = data[5*datarows + j + kmin];// * (1 + pcg_gaussian_ziggurat(&rng, 0.005)); //VpVs
// And move to the next index
break;
}
}
}
FILE *fp;
// Write results to file
fp = fopen("Rho.csv","w");
for (i=0; i<indexrows; i++) fprintf(fp, "%g\t%g\n", Rho[i], RhoStdErr[i]);
fclose(fp);
fp = fopen("Vp.csv","w");
for (i=0; i<indexrows; i++) fprintf(fp, "%g\t%g\n", Vp[i], VpStdErr[i]);
fclose(fp);
fp = fopen("VpVs.csv","w");
for (i=0; i<indexrows; i++) fprintf(fp, "%g\t%g\n", VpVs[i], VpStdErr[i]);
fclose(fp);
return 0;
}
/*
** Compare two blocks of text on lines iS1 through iE1-1 of the aFrom[]
** file and lines iS2 through iE2-1 of the aTo[] file. Locate a sequence
** of lines in these two blocks that are exactly the same. Return
** the bounds of the matching sequence.
**
** If there are two or more possible answers of the same length, the
** returned sequence should be the one closest to the center of the
** input range.
**
** Ideally, the common sequence should be the longest possible common
** sequence. However, an exact computation of LCS is O(N*N) which is
** way too slow for larger files. So this routine uses an O(N)
** heuristic approximation based on hashing that usually works about
** as well. But if the O(N) algorithm doesn't get a good solution
** and N is not too large, we fall back to an exact solution by
** calling optimalLCS().
*/
static void longestCommonSequence(
DContext *p, /* Two files being compared */
int iS1, int iE1, /* Range of lines in p->aFrom[] */
int iS2, int iE2, /* Range of lines in p->aTo[] */
int *piSX, int *piEX, /* Write p->aFrom[] common segment here */
int *piSY, int *piEY /* Write p->aTo[] common segment here */
){
int i, j, k; /* Loop counters */
int n; /* Loop limit */
DLine *pA, *pB; /* Pointers to lines */
int iSX, iSY, iEX, iEY; /* Current match */
int skew = 0; /* How lopsided is the match */
int dist = 0; /* Distance of match from center */
int mid; /* Center of the span */
int iSXb, iSYb, iEXb, iEYb; /* Best match so far */
int iSXp, iSYp, iEXp, iEYp; /* Previous match */
int64_t bestScore; /* Best score so far */
int64_t score; /* Score for current candidate LCS */
int span; /* combined width of the input sequences */
span = (iE1 - iS1) + (iE2 - iS2);
bestScore = -10000;
score = 0;
iSXb = iSXp = iS1;
iEXb = iEXp = iS1;
iSYb = iSYp = iS2;
iEYb = iEYp = iS2;
mid = (iE1 + iS1)/2;
for(i=iS1; i<iE1; i++){
int limit = 0;
j = p->aTo[p->aFrom[i].h % p->nTo].iHash;
while( j>0
&& (j-1<iS2 || j>=iE2 || !p->same_fn(&p->aFrom[i], &p->aTo[j-1]))
){
if( limit++ > 10 ){
j = 0;
break;
}
j = p->aTo[j-1].iNext;
}
if( j==0 ) continue;
if( i<iEXb && j>=iSYb && j<iEYb ) continue;
if( i<iEXp && j>=iSYp && j<iEYp ) continue;
iSX = i;
iSY = j-1;
pA = &p->aFrom[iSX-1];
pB = &p->aTo[iSY-1];
n = minInt(iSX-iS1, iSY-iS2);
for(k=0; k<n && p->same_fn(pA,pB); k++, pA--, pB--){}
iSX -= k;
iSY -= k;
iEX = i+1;
iEY = j;
pA = &p->aFrom[iEX];
pB = &p->aTo[iEY];
n = minInt(iE1-iEX, iE2-iEY);
for(k=0; k<n && p->same_fn(pA,pB); k++, pA++, pB++){}
iEX += k;
iEY += k;
skew = (iSX-iS1) - (iSY-iS2);
if( skew<0 ) skew = -skew;
dist = (iSX+iEX)/2 - mid;
if( dist<0 ) dist = -dist;
score = (iEX - iSX)*(int64_t)span - (skew + dist);
if( score>bestScore ){
bestScore = score;
iSXb = iSX;
iSYb = iSY;
iEXb = iEX;
iEYb = iEY;
}else if( iEX>iEXp ){
iSXp = iSX;
iSYp = iSY;
iEXp = iEX;
iEYp = iEY;
}
}
if( iSXb==iEXb && (iE1-iS1)*(iE2-iS2)<400 ){
/* If no common sequence is found using the hashing heuristic and
** the input is not too big, use the expensive exact solution */
optimalLCS(p, iS1, iE1, iS2, iE2, piSX, piEX, piSY, piEY);
}else{
*piSX = iSXb;
*piSY = iSYb;
*piEX = iEXb;
*piEY = iEYb;
}
}
unsigned int MO::selectPluralForm(int n)
{
auto index = onPluralExpression ? onPluralExpression(n) : MO::DEFAULT_PLURAL_EXPRESSION(n);
return maxInt(0, minInt(index, nplurals-1));
}
bool TreeNode::resolveChildWard( TreeRect & r )
//---------------------------------------------
{
bool vert = _parent->getDirection() == TreeVertical;
TreeCoord minSib = vert ? r.x() : r.y();
TreeCoord maxSib = 0;
TreeCoord childOff = childSep / 2;
TreeCoord maxChild = 0;
bool minSet = false;
int maxLevel;
int minLevel;
int i;
for( i = 0; i < getCount( FlatList ); i += 1 ) {
TreeNode * node = getNode( FlatList, i );
int tLevel = node->getLevel();
if( node->_flags.enabled > Hidden && tLevel >= 0 ) {
if( minSet ) {
maxLevel = maxInt( maxLevel, tLevel );
minLevel = minInt( minLevel, tLevel );
} else {
maxLevel = tLevel;
minLevel = tLevel;
minSet = true;
}
}
}
if( !minSet ) {
return false;
}
for( int level = minLevel; level <= maxLevel; level += 1 ) {
maxChild = 0;
for( i = 0; i < getCount( FlatList ); i += 1 ) {
TreeNode * node = getNode( FlatList, i );
if( node->getLevel() == level && node->_flags.enabled > Hidden ) {
vert ? node->_bounding.y( childOff )
: node->_bounding.x( childOff );
maxChild = maxCoord( maxChild, vert ? node->_bounding.h()
: node->_bounding.w() );
maxSib = maxCoord( maxSib, vert ? node->_descend.x() + node->_descend.w()
: node->_descend.y() + node->_descend.h() );
minSib = minCoord( minSib, vert ? node->_descend.x()
: node->_descend.y() );
}
}
childOff += maxChild + childSep;
}
if( vert ) {
r.x( minSib );
r.w( maxSib - r.x() );
r.h( childOff );
_descend.h( childOff );
} else {
r.w( childOff );
r.y( minSib );
r.h( maxSib - r.y() );
_descend.w( childOff );
}
return true;
}
/*
* caller free both sino and newSino
*
* This function prepares a new set of sinograms for the next recursive call.
* It DOES angularly downsample the sinograms.
*
*/
sinograms* newSinoForNextIter_forw(sinograms* sino,int newSinoSize,myFloat constShiftingFactor,myFloat* nu_i)
{
int P = sino->num;
sinograms* newSino;
int size = sino->size;
int newNumSino;
int m,n,k,p;
myFloat kk,pp;
myFloat sum;
myFloat angle;
myFloat temp1,temp2,temp3;
myFloat shiftingFactor;
myFloat radialShift;
myFloat totalShift;
myFloat temp;
int n2;
int lowerPBound,upperPBound,lowerKBound,upperKBound;
myFloat angularSupport;
myFloat radialSupport;
//preparing new sinograms
newSino = (sinograms*)malloc(1*sizeof(sinograms));
newSino->T = T;
newSino->size = newSinoSize;
newSino->num = ceilf((myFloat)P/2);
newNumSino = newSino->num;
(newSino->sino) = (myFloat**)malloc(newNumSino*sizeof(myFloat*));
(newSino->sine) = (myFloat*)malloc(newNumSino*sizeof(myFloat));
(newSino->cosine) = (myFloat*)malloc(newNumSino*sizeof(myFloat));
//done preparing spaces for new sinograms
angularSupport = ANGULAR_SUPPORT;
radialSupport = RADIAL_SUPPORT;
for(n=0;n<newNumSino;n++){
//for each new angle
n2 = 2*n;
(newSino->sino)[n] = (myFloat*)malloc(newSinoSize*sizeof(myFloat));
(newSino->sine)[n] = (sino->sine)[n2];
(newSino->cosine)[n] = (sino->cosine)[n2];
lowerPBound = maxInt(n2-(int)(angularSupport),0);
upperPBound = minInt(n2+ceilf(angularSupport),P-1);
for(m=0;m<newSinoSize;m++){
//for each new radial array index
sum = 0;
for(p=lowerPBound;p<=upperPBound;p++){
//for each old angle
temp1 = n2-p;
temp2 = ANGULAR_INTERP(temp1);
radialShift = m+nu_i[n2]-nu_i[p];
shiftingFactor = rintf(nu_i[p]) + constShiftingFactor;
lowerKBound = (minInt(maxInt(ceilf(radialShift-shiftingFactor-radialSupport),0),size-1));
upperKBound = (maxInt(minInt((int)(radialShift-shiftingFactor+radialSupport),size-1),0));
//this loop can be optimized more, but i didn't have time.
for(k=lowerKBound;k<=upperKBound;k++){
//for each old radial array index
temp3 = (sino->sino)[p][k];
kk = k + shiftingFactor;
temp = radialShift-kk;
temp1 = RADIAL_INTERP(temp);
sum += temp1 * temp2 * temp3;
}//end for k
}//end for p
(newSino->sino)[n][m] = sum;
}//end for m
}//end for n
return newSino;
}
/*
* direct_forw(the sinograms,the size of the image, tau's,output image)
*
* direct_forw corresponds EXACTLY to the direct_forw method.
*
*/
void direct_forw( sinograms* g , int size , myFloat* tau , image* ans )
{
int m; //x direct_forwion
int n; //y direct_forwion
myFloat* curRow;
myFloat middle = ( ( myFloat )( g->size ) ) / 2 - 0.5;
myFloat halfSize = 0.5 * size;
int numSino = g->num;
myFloat scale = M_PI/numSino; //scale output by PI/(# of projections) ; see derivation of inverse radon
int p;
int k;
int P = g->num;
int sinoSize;
myFloat i;
myFloat sum = 0;
myFloat* curSino;
myFloat temp;
myFloat realm;
myFloat realn;
myFloat scaledRealm;
myFloat scaledRealn;
myFloat lowerXLimit;
myFloat upperXLimit;
myFloat lowerYLimit;
myFloat upperYLimit;
myFloat spXSupport;
myFloat spYSupport;
myFloat intpSupport;
myFloat curr;
myFloat lowerKBound;
myFloat upperKBound;
int lowerKBound2;
int upperKBound2;
myFloat theta;
myFloat exactRadialPosition;
intpSupport = RADIAL_SUPPORT;
sinoSize = g->size;
//for each pixel in the image
for(n=0;n<size;n++){
curRow = (ans->pixel)[n];
for(m=0;m<size;m++){
//for each sinogram
sum = 0.0;
for(p=0;p<P;p++){
curSino = g->sino[p];
realm = m - halfSize + 0.5;
realn = n - halfSize + 0.5;
scaledRealm = realm * oneOverT;
scaledRealn = realn * oneOverT;
exactRadialPosition = scaledRealm*(g->cosine)[p] + scaledRealn*(g->sine)[p];
exactRadialPosition -= tau[p]-middle;
//exactRadialPosition is now in terms of array index! (although it's still a float)
//since spSupport is zero
lowerKBound = exactRadialPosition-intpSupport;
upperKBound = exactRadialPosition+intpSupport;
lowerKBound2 = maxInt((int)(lowerKBound-ERROR_TOLERANCE)+1,0);
upperKBound2 = minInt((int)(upperKBound),(g->size)-1);
//for nearest interpolator, this needs to be checked
if(upperKBound2<lowerKBound2){
upperKBound2 = lowerKBound2;
}
//for each entry in this sinogram
for(k=lowerKBound2;k<=upperKBound2;k++){
temp = weight_forw( exactRadialPosition , k );
curSino[k] += curRow[m] * temp * scale;
}//end for k
}//end for p
} //end for n
} //end for m
}
