/*** AdjustLines - change all information relevant to deletion/insertion of
* lines in a file.
*
* Purpose:
* When we are deleting or inserting lines, there is some updating that we
* need to do to retain some consistency in the user's view of the screen.
* The updating consists of:
*
* Adjusting all window instances of this window to prevent "jumping".
* We enumerate all window instances. If the top of the window is
* above or inside the deleted/inserted range, do nothing. If the top of
* the window is below the inserted/deleted range, we modify the cursor
* and window position to prevent the window from moving on the text
* being viewed.
*
* Ditto for all flip positions
*
* Input:
* pFile file that is being modified
* lin beginning line of modification
* clin number of lines being inserted (> 0) or deleted (< 0)
*
* Output:
*
*************************************************************************/
void
AdjustLines (
PFILE pFile,
LINE lin,
LINE clin
) {
int iWin;
REGISTER PINS pInsTmp;
/* walk all instances looking for one whose pFile matches
*/
for (iWin = 0; iWin < cWin; iWin++) {
for (pInsTmp = WININST(WinList + iWin); pInsTmp != NULL; pInsTmp = pInsTmp->pNext) {
if (pInsTmp != pInsCur && pInsTmp->pFile == pFile) {
/* adjust current position if necessary
*/
if (YWIN(pInsTmp) >= lin) {
YWIN(pInsTmp) = lmax ((LINE)0, YWIN(pInsTmp) + clin);
YCUR(pInsTmp) = lmax ((LINE)0, YCUR(pInsTmp) + clin);
}
/* adjust flip position if necessary
*/
if (YOLDWIN(pInsTmp) >= lin) {
YOLDWIN(pInsTmp) = lmax ((LINE)0, YOLDWIN(pInsTmp) + clin);
YOLDCUR(pInsTmp) = lmax ((LINE)0, YOLDCUR(pInsTmp) + clin);
}
}
}
}
}
void Speed::fix(AIHTTPTimeoutPolicy* policy)
{
bool changed = false;
if (policy->mLowSpeedTime > ABS_max_low_speed_time)
{
policy->mLowSpeedTime = ABS_max_low_speed_time;
changed = true;
}
else if (policy->mLowSpeedTime != 0 && policy->mLowSpeedTime < min())
{
policy->mLowSpeedTime = min();
changed = true;
}
if (changed)
{
// Transaction limits depend on Speed time.
Transaction::fix(policy);
}
if (policy->mLowSpeedTime > max(policy))
{
policy->mLowSpeedTime = max(policy);
}
if (policy->mLowSpeedLimit > lmax())
{
policy->mLowSpeedLimit = lmax();
}
else if (policy->mLowSpeedLimit != 0 && policy->mLowSpeedLimit < lmin())
{
policy->mLowSpeedLimit = lmin();
}
}
/*
* tunable_mbinit() has to be run before init_maxsockets() thus
* the SYSINIT order below is SI_ORDER_MIDDLE while init_maxsockets()
* runs at SI_ORDER_ANY.
*
* NB: This has to be done before VM init.
*/
static void
tunable_mbinit(void *dummy)
{
TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
if (nmbclusters == 0)
nmbclusters = maxmbufmem / MCLBYTES / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbop", &nmbjumbop);
if (nmbjumbop == 0)
nmbjumbop = maxmbufmem / MJUMPAGESIZE / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo9", &nmbjumbo9);
if (nmbjumbo9 == 0)
nmbjumbo9 = maxmbufmem / MJUM9BYTES / 6;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo16", &nmbjumbo16);
if (nmbjumbo16 == 0)
nmbjumbo16 = maxmbufmem / MJUM16BYTES / 6;
/*
* We need at least as many mbufs as we have clusters of
* the various types added together.
*/
TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
if (nmbufs < nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16)
nmbufs = lmax(maxmbufmem / MSIZE / 5,
nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16);
}
void Map::getMinMaxCoordinates(ExactModelCoordinate& min, ExactModelCoordinate& max) {
if (m_layers.empty()) {
return;
}
std::list<Layer*>::iterator it = m_layers.begin();
Layer* layer = *it;
for (; it != m_layers.end(); ++it) {
ModelCoordinate newMin, newMax;
(*it)->getMinMaxCoordinates(newMin, newMax, layer);
if (newMin.x < min.x) {
min.x = newMin.x;
}
if (newMax.x > max.x) {
max.x = newMax.x;
}
if (newMin.y < min.y) {
min.y = newMin.y;
}
if (newMax.y > max.y) {
max.y = newMax.y;
}
}
Location lmin(layer);
Location lmax(layer);
lmin.setExactLayerCoordinates(min);
lmax.setExactLayerCoordinates(max);
min = lmin.getMapCoordinates();
max = lmax.getMapCoordinates();
}
int trap(int A[], int n) {
if (n < 2) return 0;
vector<int> lmax(n, 0);
vector<int> rmax(n, 0);
int maxV = A[0];
lmax[0] = A[0];
for (int i = 1; i < n; i++)
{
maxV = std::max(maxV, A[i - 1]);
lmax[i] = maxV;
}
maxV = A[n - 1];
rmax[n - 1] = A[n - 1];
for (int i = n - 2; i >= 0; i--)
{
maxV = std::max(maxV, A[i + 1]);
rmax[i] = maxV;
}
int total = 0;
for (int i = 0; i < n; i++)
{
int diff = std::min(lmax[i], rmax[i]) - A[i];
if (diff > 0)
total += diff;
}
return total;
}
eqveqv(int nvarno, int ovarno, ftnint delta)
#endif
{
register struct Equivblock *neweqv, *oldeqv;
register Namep np;
struct Eqvchain *q, *q1;
neweqv = eqvclass + nvarno;
oldeqv = eqvclass + ovarno;
neweqv->eqvbottom = lmin(neweqv->eqvbottom, oldeqv->eqvbottom - delta);
neweqv->eqvtop = lmax(neweqv->eqvtop, oldeqv->eqvtop - delta);
oldeqv->eqvbottom = oldeqv->eqvtop = 0;
for(q = oldeqv->equivs ; q ; q = q1)
{
q1 = q->eqvnextp;
if( (np = q->eqvitem.eqvname) && np->vardesc.varno==ovarno)
{
q->eqvnextp = neweqv->equivs;
neweqv->equivs = q;
q->eqvoffset += delta;
np->vardesc.varno = nvarno;
np->voffset -= delta;
}
else free( (charptr) q);
}
oldeqv->equivs = NULL;
}
int maxProfit(vector<int>& prices) {
int n = prices.size();
if(n <= 1)
return 0;
vector<int> lmax(n,0);
vector<int> rmax(n,0);
int minb = prices[0];
lmax[0] = 0;
for(int i=1; i<n; i++)
{
minb = min(minb, prices[i]);
lmax[i] = max(lmax[i-1], prices[i]-minb);
}
rmax[n-1] = 0;
int maxs = prices[n-1];
for(int j=n-2; j>=0; --j)
{
maxs = max(maxs, prices[j]);
rmax[j] = max(rmax[j+1], maxs-prices[j]);
}
maxs = 0;
for(int k=0; k<n; ++k)
{
maxs = max(maxs, lmax[k]+rmax[k]);
}
return maxs;
}
/*** redraw - Mark a range of lines in file dirty
*
* Marks a range of lines in a file as needing to be updated. Each window that
* they occur in is marked.
*
* Input:
* pFile = File handle containing dirty lines
* linFirst, linLast = Range of lines to mark
*
* Output:
* Returns nothing
*
*************************************************************************/
void
redraw (
PFILE pFile,
LINE linFirst,
LINE linLast
) {
LINE linFirstUpd, linLastUpd;
REGISTER PINS pInsTmp;
int iWinTmp;
REGISTER struct windowType *pWinTmp;
if (linFirst > linLast) {
linFirstUpd = linLast;
linLast = linFirst;
linFirst = linFirstUpd;
}
for (iWinTmp = 0, pWinTmp = WinList; iWinTmp < cWin; iWinTmp++, pWinTmp++) {
if (pWinTmp->pInstance) {
if (pFile == pWinTmp->pInstance->pFile) {
pInsTmp = pWinTmp->pInstance;
linFirstUpd = WINYPOS(pWinTmp) + lmax (0L, linFirst-YWIN(pInsTmp)-1);
linLastUpd = WINYPOS(pWinTmp) + lmin ((long) (WINYSIZE(pWinTmp) - 1), linLast - YWIN(pInsTmp));
while (linFirstUpd <= linLastUpd) {
SETFLAG (fChange[linFirstUpd++],FMODIFY);
}
}
}
}
SETFLAG (fDisplay, RTEXT);
}
/*
* tunable_mbinit() has to be run before any mbuf allocations are done.
*/
static void
tunable_mbinit(void *dummy)
{
#ifndef __rtems__
quad_t realmem;
/*
* The default limit for all mbuf related memory is 1/2 of all
* available kernel memory (physical or kmem).
* At most it can be 3/4 of available kernel memory.
*/
realmem = qmin((quad_t)physmem * PAGE_SIZE,
vm_map_max(kmem_map) - vm_map_min(kmem_map));
maxmbufmem = realmem / 2;
TUNABLE_QUAD_FETCH("kern.ipc.maxmbufmem", &maxmbufmem);
if (maxmbufmem > realmem / 4 * 3)
maxmbufmem = realmem / 4 * 3;
#else /* __rtems__ */
maxmbufmem = rtems_bsd_get_allocator_domain_size(
RTEMS_BSD_ALLOCATOR_DOMAIN_MBUF);
#endif /* __rtems__ */
TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
if (nmbclusters == 0)
nmbclusters = maxmbufmem / MCLBYTES / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbop", &nmbjumbop);
if (nmbjumbop == 0)
nmbjumbop = maxmbufmem / MJUMPAGESIZE / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo9", &nmbjumbo9);
if (nmbjumbo9 == 0)
nmbjumbo9 = maxmbufmem / MJUM9BYTES / 6;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo16", &nmbjumbo16);
if (nmbjumbo16 == 0)
nmbjumbo16 = maxmbufmem / MJUM16BYTES / 6;
/*
* We need at least as many mbufs as we have clusters of
* the various types added together.
*/
TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
if (nmbufs < nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16)
nmbufs = lmax(maxmbufmem / MSIZE / 5,
nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16);
}
/*** UpdateIf - Move the cursor position if a particlar file is displayed
*
* Used to update the view on windows which are not necessarily the current
* window. Examples: tying together the compile error log with the current
* view on the source code.
*
* Input:
* pFileChg = pointer to the file whose display is to be updated.
* yNew = New cursor line position.
* fTop = cursor line should be positionned at top/bottom of the window
*
* Output:
* Returns TRUE if on-screen and updated.
*
*************************************************************************/
flagType
UpdateIf (
PFILE pFileChg,
LINE linNew,
flagType fTop
) {
PINS pInsCur;
PWND pWndFound = NULL;
flagType fFound = FALSE;
/*
* If this is the top file, we don't want to do anything
*/
if (pFileChg == pFileHead) {
return FALSE;
}
/*
* Walk the window list, and check to see if the top instance (file
* currently in view) is the one we care about. If so, update its cursor
* and window position.
*/
while (pWndFound = IsVispFile (pFileChg, pWndFound)) {
if (pWndFound != pWinCur) {
pInsCur = WININST(pWndFound);
YCUR(pInsCur) = linNew;
XCUR(pInsCur) = 0;
YWIN(pInsCur) = fTop ?
YCUR(pInsCur) :
lmax (0L, YCUR(pInsCur) - (WINYSIZE(pWndFound)-1));
XWIN(pInsCur) = 0;
fFound = TRUE;
}
}
/*
* If any visible instances of the file were discovered above, redraw the
* entire file, such that all windows will be updated, regardless of view.
*/
if (fFound) {
redraw (pFileChg, 0L, pFileChg->cLines);
}
return fFound;
}
static int
round_freq(struct eventtimer *et, int freq)
{
uint64_t div;
if (et->et_frequency != 0) {
div = lmax((et->et_frequency + freq / 2) / freq, 1);
if (et->et_flags & ET_FLAGS_POW2DIV)
div = 1 << (flsl(div + div / 2) - 1);
freq = (et->et_frequency + div / 2) / div;
}
if (et->et_min_period.sec > 0)
freq = 0;
else if (et->et_min_period.frac != 0)
freq = min(freq, BT2FREQ(&et->et_min_period));
if (et->et_max_period.sec == 0 && et->et_max_period.frac != 0)
freq = max(freq, BT2FREQ(&et->et_max_period));
return (freq);
}
/*
* tunable_mbinit() has to be run before any mbuf allocations are done.
*/
static void
tunable_mbinit(void *dummy)
{
quad_t realmem, maxmbufmem;
/*
* The default limit for all mbuf related memory is 1/2 of all
* available kernel memory (physical or kmem).
* At most it can be 3/4 of available kernel memory.
*/
realmem = qmin((quad_t)physmem * PAGE_SIZE,
vm_map_max(kernel_map) - vm_map_min(kernel_map));
maxmbufmem = realmem / 2;
TUNABLE_QUAD_FETCH("kern.maxmbufmem", &maxmbufmem);
if (maxmbufmem > realmem / 4 * 3)
maxmbufmem = realmem / 4 * 3;
TUNABLE_INT_FETCH("kern.ipc.nmbclusters", &nmbclusters);
if (nmbclusters == 0)
nmbclusters = maxmbufmem / MCLBYTES / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbop", &nmbjumbop);
if (nmbjumbop == 0)
nmbjumbop = maxmbufmem / MJUMPAGESIZE / 4;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo9", &nmbjumbo9);
if (nmbjumbo9 == 0)
nmbjumbo9 = maxmbufmem / MJUM9BYTES / 6;
TUNABLE_INT_FETCH("kern.ipc.nmbjumbo16", &nmbjumbo16);
if (nmbjumbo16 == 0)
nmbjumbo16 = maxmbufmem / MJUM16BYTES / 6;
/*
* We need at least as many mbufs as we have clusters of
* the various types added together.
*/
TUNABLE_INT_FETCH("kern.ipc.nmbufs", &nmbufs);
if (nmbufs < nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16)
nmbufs = lmax(maxmbufmem / MSIZE / 5,
nmbclusters + nmbjumbop + nmbjumbo9 + nmbjumbo16);
}
int main()
{
int i, Lmax,total_pecas;
ptr_no ultima_linha; /*Vai receber a linha acima da jogada realizada */
inicia_pecas_inteiras(); /*Iniciar a matriz de contagem*/
scanf("%d\n",&total_pecas); /*Ler total de pecas */
for(i = 0; i < total_pecas; i++) /*Ciclo leitura, colocacao, avaliacao */
{
ultima_linha = ler(); /*le uma peca e coloca-a, devolve a linha em que foi colocada */
pontuacao += pontua(ultima_linha); /*Actualiza a pontuacao do jogo */
}
Lmax = lmax(top); /*Calcula o lmax do tabuleiro apontado por top */
imprimir_tabuleiro(top,Lmax,pontuacao); /*Imprimir o tabuleiro top no standard output*/
printf("\n"); /*linha apos o tabuleiro */
conta_pecas(top); /*Conta o numero de pecas inteiras no tabuleiro*/
printf("%d\n",numero_pecas_inteiras); /*Imprimir o numero total de pecas inteiras*/
imprimir_contagem(); /*Imprimir a contagem de pecas inteiras no final*/
printf("\n"); /*linha apos as pecas inteiras */
imprElim();
return 0;
}
/* called at end of declarations section to process chains
created by EQUIVALENCE statements
*/
void
doequiv(Void)
{
register int i;
int inequiv; /* True if one namep occurs in
several EQUIV declarations */
int comno; /* Index into Extsym table of the last
COMMON block seen (implicitly assuming
that only one will be given) */
int ovarno;
ftnint comoffset; /* Index into the COMMON block */
ftnint offset; /* Offset from array base */
ftnint leng;
register struct Equivblock *equivdecl;
register struct Eqvchain *q;
struct Primblock *primp;
register Namep np;
int k, k1, ns, pref, t;
chainp cp;
extern int type_pref[];
char *s;
for(i = 0 ; i < nequiv ; ++i)
{
/* Handle each equivalence declaration */
equivdecl = &eqvclass[i];
equivdecl->eqvbottom = equivdecl->eqvtop = 0;
comno = -1;
for(q = equivdecl->equivs ; q ; q = q->eqvnextp)
{
offset = 0;
if (!(primp = q->eqvitem.eqvlhs))
continue;
vardcl(np = primp->namep);
if(primp->argsp || primp->fcharp)
{
expptr offp;
/* Pad ones onto the end of an array declaration when needed */
if(np->vdim!=NULL && np->vdim->ndim>1 &&
nsubs(primp->argsp)==1 )
{
if(! ftn66flag)
warni
("1-dim subscript in EQUIVALENCE, %d-dim declared",
np -> vdim -> ndim);
cp = NULL;
ns = np->vdim->ndim;
while(--ns > 0)
cp = mkchain((char *)ICON(1), cp);
primp->argsp->listp->nextp = cp;
}
offp = suboffset(primp);
if(ISICON(offp))
offset = offp->constblock.Const.ci;
else {
dclerr
("nonconstant subscript in equivalence ",
np);
np = NULL;
}
frexpr(offp);
}
/* Free up the primblock, since we now have a hash table (Namep) entry */
frexpr((expptr)primp);
if(np && (leng = iarrlen(np))<0)
{
dclerr("adjustable in equivalence", np);
np = NULL;
}
if(np) switch(np->vstg)
{
case STGUNKNOWN:
case STGBSS:
case STGEQUIV:
break;
case STGCOMMON:
/* The code assumes that all COMMON references in a given EQUIVALENCE will
be to the same COMMON block, and will all be consistent */
comno = np->vardesc.varno;
comoffset = np->voffset + offset;
break;
default:
dclerr("bad storage class in equivalence", np);
np = NULL;
break;
}
if(np)
{
q->eqvoffset = offset;
/* eqvbottom gets the largest difference between the array base address
and the address specified in the EQUIV declaration */
equivdecl->eqvbottom =
lmin(equivdecl->eqvbottom, -offset);
/* eqvtop gets the largest difference between the end of the array and
the address given in the EQUIVALENCE */
equivdecl->eqvtop =
lmax(equivdecl->eqvtop, leng-offset);
}
q->eqvitem.eqvname = np;
}
/* Now all equivalenced variables are in the hash table with the proper
offset, and eqvtop and eqvbottom are set. */
if(comno >= 0)
/* Get rid of all STGEQUIVS, they will be mapped onto STGCOMMON variables
*/
eqvcommon(equivdecl, comno, comoffset);
else for(q = equivdecl->equivs ; q ; q = q->eqvnextp)
{
if(np = q->eqvitem.eqvname)
{
inequiv = NO;
if(np->vstg==STGEQUIV)
if( (ovarno = np->vardesc.varno) == i)
{
/* Can't EQUIV different elements of the same array */
if(np->voffset + q->eqvoffset != 0)
dclerr
("inconsistent equivalence", np);
}
else {
offset = np->voffset;
inequiv = YES;
}
np->vstg = STGEQUIV;
np->vardesc.varno = i;
np->voffset = - q->eqvoffset;
if(inequiv)
/* Combine 2 equivalence declarations */
eqveqv(i, ovarno, q->eqvoffset + offset);
}
}
}
/* Now each equivalence declaration is distinct (all connections have been
merged in eqveqv()), and some may be empty. */
for(i = 0 ; i < nequiv ; ++i)
{
equivdecl = & eqvclass[i];
if(equivdecl->eqvbottom!=0 || equivdecl->eqvtop!=0) {
/* a live chain */
k = TYCHAR;
pref = 1;
for(q = equivdecl->equivs ; q; q = q->eqvnextp)
if ((np = q->eqvitem.eqvname)
&& !np->veqvadjust) {
np->veqvadjust = 1;
np->voffset -= equivdecl->eqvbottom;
t = typealign[k1 = np->vtype];
if (pref < type_pref[k1]) {
k = k1;
pref = type_pref[k1];
}
if(np->voffset % t != 0) {
dclerr("bad alignment forced by equivalence", np);
--nerr; /* don't give bad return code for this */
}
}
equivdecl->eqvtype = k;
}
freqchain(equivdecl);
}
}
/* Subroutine */ int zung2r_(integer *m, integer *n, integer *k,
doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
work, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3;
doublecomplex z__1;
/* Local variables */
integer i__, j, l;
extern /* Subroutine */ int zscal_(integer *, doublecomplex *,
doublecomplex *, integer *), zlarf_(char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, doublecomplex *), xerbla_(char *, integer *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZUNG2R generates an m by n complex matrix Q with orthonormal columns, */
/* which is defined as the first n columns of a product of k elementary */
/* reflectors of order m */
/* Q = H(1) H(2) . . . H(k) */
/* as returned by ZGEQRF. */
/* Arguments */
/* ========= */
/* M (input) INTEGER */
/* The number of rows of the matrix Q. M >= 0. */
/* N (input) INTEGER */
/* The number of columns of the matrix Q. M >= N >= 0. */
/* K (input) INTEGER */
/* The number of elementary reflectors whose product defines the */
/* matrix Q. N >= K >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA,N) */
/* On entry, the i-th column must contain the vector which */
/* defines the elementary reflector H(i), for i = 1,2,...,k, as */
/* returned by ZGEQRF in the first k columns of its array */
/* argument A. */
/* On exit, the m by n matrix Q. */
/* LDA (input) INTEGER */
/* The first dimension of the array A. LDA >= lmax(1,M). */
/* TAU (input) COMPLEX*16 array, dimension (K) */
/* TAU(i) must contain the scalar factor of the elementary */
/* reflector H(i), as returned by ZGEQRF. */
/* WORK (workspace) COMPLEX*16 array, dimension (N) */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument has an illegal value */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
--work;
/* Function Body */
*info = 0;
if (*m < 0) {
*info = -1;
} else if (*n < 0 || *n > *m) {
*info = -2;
} else if (*k < 0 || *k > *n) {
*info = -3;
} else if (*lda < lmax(1,*m)) {
*info = -5;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZUNG2R", &i__1);
return 0;
}
/* Quick return if possible */
if (*n <= 0) {
return 0;
}
/* Initialise columns k+1:n to columns of the unit matrix */
i__1 = *n;
for (j = *k + 1; j <= i__1; ++j) {
i__2 = *m;
for (l = 1; l <= i__2; ++l) {
i__3 = l + j * a_dim1;
a[i__3].r = 0., a[i__3].i = 0.;
/* L10: */
}
i__2 = j + j * a_dim1;
a[i__2].r = 1., a[i__2].i = 0.;
/* L20: */
}
for (i__ = *k; i__ >= 1; --i__) {
/* Apply H(i) to A(i:m,i:n) from the left */
if (i__ < *n) {
i__1 = i__ + i__ * a_dim1;
a[i__1].r = 1., a[i__1].i = 0.;
i__1 = *m - i__ + 1;
i__2 = *n - i__;
zlarf_("Left", &i__1, &i__2, &a[i__ + i__ * a_dim1], &c__1, &tau[
i__], &a[i__ + (i__ + 1) * a_dim1], lda, &work[1]);
}
if (i__ < *m) {
i__1 = *m - i__;
i__2 = i__;
z__1.r = -tau[i__2].r, z__1.i = -tau[i__2].i;
zscal_(&i__1, &z__1, &a[i__ + 1 + i__ * a_dim1], &c__1);
}
i__1 = i__ + i__ * a_dim1;
i__2 = i__;
z__1.r = 1. - tau[i__2].r, z__1.i = 0. - tau[i__2].i;
a[i__1].r = z__1.r, a[i__1].i = z__1.i;
/* Set A(1:i-1,i) to zero */
i__1 = i__ - 1;
for (l = 1; l <= i__1; ++l) {
i__2 = l + i__ * a_dim1;
a[i__2].r = 0., a[i__2].i = 0.;
/* L30: */
}
/* L40: */
}
return 0;
/* End of ZUNG2R */
} /* zung2r_ */
/* Subroutine */ int dtrtrs_(char *uplo, char *trans, char *diag, integer *n,
integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *
ldb, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1;
/* Local variables */
extern logical lsame_(char *, char *);
extern /* Subroutine */ int dtrsm_(char *, char *, char *, char *,
integer *, integer *, doublereal *, doublereal *, integer *,
doublereal *, integer *), xerbla_(
char *, integer *);
logical nounit;
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DTRTRS solves a triangular system of the form */
/* A * X = B or A**T * X = B, */
/* where A is a triangular matrix of order N, and B is an N-by-NRHS */
/* matrix. A check is made to verify that A is nonsingular. */
/* Arguments */
/* ========= */
/* UPLO (input) CHARACTER*1 */
/* = 'U': A is upper triangular; */
/* = 'L': A is lower triangular. */
/* TRANS (input) CHARACTER*1 */
/* Specifies the form of the system of equations: */
/* = 'N': A * X = B (No transpose) */
/* = 'T': A**T * X = B (Transpose) */
/* = 'C': A**H * X = B (Conjugate transpose = Transpose) */
/* DIAG (input) CHARACTER*1 */
/* = 'N': A is non-unit triangular; */
/* = 'U': A is unit triangular. */
/* N (input) INTEGER */
/* The order of the matrix A. N >= 0. */
/* NRHS (input) INTEGER */
/* The number of right hand sides, i.e., the number of columns */
/* of the matrix B. NRHS >= 0. */
/* A (input) DOUBLE PRECISION array, dimension (LDA,N) */
/* The triangular matrix A. If UPLO = 'U', the leading N-by-N */
/* upper triangular part of the array A contains the upper */
/* triangular matrix, and the strictly lower triangular part of */
/* A is not referenced. If UPLO = 'L', the leading N-by-N lower */
/* triangular part of the array A contains the lower triangular */
/* matrix, and the strictly upper triangular part of A is not */
/* referenced. If DIAG = 'U', the diagonal elements of A are */
/* also not referenced and are assumed to be 1. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= lmax(1,N). */
/* B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS) */
/* On entry, the right hand side matrix B. */
/* On exit, if INFO = 0, the solution matrix X. */
/* LDB (input) INTEGER */
/* The leading dimension of the array B. LDB >= lmax(1,N). */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value */
/* > 0: if INFO = i, the i-th diagonal element of A is zero, */
/* indicating that the matrix is singular and the solutions */
/* X have not been computed. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
/* Function Body */
*info = 0;
nounit = lsame_(diag, "N");
if (! lsame_(uplo, "U") && ! lsame_(uplo, "L")) {
*info = -1;
} else if (! lsame_(trans, "N") && ! lsame_(trans,
"T") && ! lsame_(trans, "C")) {
*info = -2;
} else if (! nounit && ! lsame_(diag, "U")) {
*info = -3;
} else if (*n < 0) {
*info = -4;
} else if (*nrhs < 0) {
*info = -5;
} else if (*lda < lmax(1,*n)) {
*info = -7;
} else if (*ldb < lmax(1,*n)) {
*info = -9;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DTRTRS", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Check for singularity. */
if (nounit) {
i__1 = *n;
for (*info = 1; *info <= i__1; ++(*info)) {
if (a[*info + *info * a_dim1] == 0.) {
return 0;
}
/* L10: */
}
}
*info = 0;
/* Solve A * x = b or A' * x = b. */
dtrsm_("Left", uplo, trans, diag, n, nrhs, &c_b12, &a[a_offset], lda, &b[
b_offset], ldb);
return 0;
/* End of DTRTRS */
} /* dtrtrs_ */
Rect Rect::unionRect(const Rect & r) const
{
return Rect(lmin(m_iLeft, r.m_iLeft), lmax(m_iTop, r.m_iTop), lmax(m_iRight, r.m_iRight), lmin(m_iBottom, r.m_iBottom));
}
/* collect EndRun sentence from tty */
int
endruninput(int c, struct tty *tp)
{
struct endrun *np = (struct endrun *)tp->t_sc;
struct timespec ts;
int64_t gap;
long tmin, tmax;
if (np->sync == SYNC_EOL) {
nanotime(&ts);
np->pos = 0;
np->sync = SYNC_SCAN;
np->cbuf[np->pos++] = c; /* TFOM char */
gap = (ts.tv_sec * 1000000000LL + ts.tv_nsec) -
(np->lts.tv_sec * 1000000000LL + np->lts.tv_nsec);
np->lts.tv_sec = ts.tv_sec;
np->lts.tv_nsec = ts.tv_nsec;
if (gap <= np->gap)
goto nogap;
np->ts.tv_sec = ts.tv_sec;
np->ts.tv_nsec = ts.tv_nsec;
np->gap = gap;
/*
* If a tty timestamp is available, make sure its value is
* reasonable by comparing against the timestamp just taken.
* If they differ by more than 2 seconds, assume no PPS signal
* is present, note the fact, and keep using the timestamp
* value. When this happens, the sensor state is set to
* CRITICAL later when the EndRun sentence is decoded.
*/
if (tp->t_flags & (TS_TSTAMPDCDSET | TS_TSTAMPDCDCLR |
TS_TSTAMPCTSSET | TS_TSTAMPCTSCLR)) {
tmax = lmax(np->ts.tv_sec, tp->t_tv.tv_sec);
tmin = lmin(np->ts.tv_sec, tp->t_tv.tv_sec);
if (tmax - tmin > 1)
np->no_pps = 1;
else {
np->ts.tv_sec = tp->t_tv.tv_sec;
np->ts.tv_nsec = tp->t_tv.tv_usec *
1000L;
np->no_pps = 0;
}
}
} else if (c == '\n') {
if (np->pos == ENDRUNLEN - 1) {
/* don't copy '\n' into cbuf */
np->cbuf[np->pos] = '\0';
endrun_scan(np, tp);
}
np->sync = SYNC_EOL;
} else {
if (np->pos < ENDRUNLEN - 1)
np->cbuf[np->pos++] = c;
}
nogap:
/* pass data to termios */
return linesw[TTYDISC].l_rint(c, tp);
}
/* Subroutine */ int zungbr_(char *vect, integer *m, integer *n, integer *k,
doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
work, integer *lwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3;
/* Local variables */
integer i__, j, nb, mn;
extern logical lsame_(char *, char *);
integer iinfo;
logical wantq;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
integer lwkopt;
logical lquery;
extern /* Subroutine */ int zunglq_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *), zungqr_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, integer *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZUNGBR generates one of the complex unitary matrices Q or P**H */
/* determined by ZGEBRD when reducing a complex matrix A to bidiagonal */
/* form: A = Q * B * P**H. Q and P**H are defined as products of */
/* elementary reflectors H(i) or G(i) respectively. */
/* If VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q */
/* is of order M: */
/* if m >= k, Q = H(1) H(2) . . . H(k) and ZUNGBR returns the first n */
/* columns of Q, where m >= n >= k; */
/* if m < k, Q = H(1) H(2) . . . H(m-1) and ZUNGBR returns Q as an */
/* M-by-M matrix. */
/* If VECT = 'P', A is assumed to have been a K-by-N matrix, and P**H */
/* is of order N: */
/* if k < n, P**H = G(k) . . . G(2) G(1) and ZUNGBR returns the first m */
/* rows of P**H, where n >= m >= k; */
/* if k >= n, P**H = G(n-1) . . . G(2) G(1) and ZUNGBR returns P**H as */
/* an N-by-N matrix. */
/* Arguments */
/* ========= */
/* VECT (input) CHARACTER*1 */
/* Specifies whether the matrix Q or the matrix P**H is */
/* required, as defined in the transformation applied by ZGEBRD: */
/* = 'Q': generate Q; */
/* = 'P': generate P**H. */
/* M (input) INTEGER */
/* The number of rows of the matrix Q or P**H to be returned. */
/* M >= 0. */
/* N (input) INTEGER */
/* The number of columns of the matrix Q or P**H to be returned. */
/* N >= 0. */
/* If VECT = 'Q', M >= N >= lmin(M,K); */
/* if VECT = 'P', N >= M >= lmin(N,K). */
/* K (input) INTEGER */
/* If VECT = 'Q', the number of columns in the original M-by-K */
/* matrix reduced by ZGEBRD. */
/* If VECT = 'P', the number of rows in the original K-by-N */
/* matrix reduced by ZGEBRD. */
/* K >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA,N) */
/* On entry, the vectors which define the elementary reflectors, */
/* as returned by ZGEBRD. */
/* On exit, the M-by-N matrix Q or P**H. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= M. */
/* TAU (input) COMPLEX*16 array, dimension */
/* (min(M,K)) if VECT = 'Q' */
/* (min(N,K)) if VECT = 'P' */
/* TAU(i) must contain the scalar factor of the elementary */
/* reflector H(i) or G(i), which determines Q or P**H, as */
/* returned by ZGEBRD in its array argument TAUQ or TAUP. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= lmax(1,min(M,N)). */
/* For optimum performance LWORK >= lmin(M,N)*NB, where NB */
/* is the optimal blocksize. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument had an illegal value */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
--work;
/* Function Body */
*info = 0;
wantq = lsame_(vect, "Q");
mn = lmin(*m,*n);
lquery = *lwork == -1;
if (! wantq && ! lsame_(vect, "P")) {
*info = -1;
} else if (*m < 0) {
*info = -2;
} else if (*n < 0 || wantq && (*n > *m || *n < lmin(*m,*k)) || ! wantq && (
*m > *n || *m < lmin(*n,*k))) {
*info = -3;
} else if (*k < 0) {
*info = -4;
} else if (*lda < lmax(1,*m)) {
*info = -6;
} else if (*lwork < lmax(1,mn) && ! lquery) {
*info = -9;
}
if (*info == 0) {
if (wantq) {
nb = ilaenv_(&c__1, "ZUNGQR", " ", m, n, k, &c_n1);
} else {
nb = ilaenv_(&c__1, "ZUNGLQ", " ", m, n, k, &c_n1);
}
lwkopt = lmax(1,mn) * nb;
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZUNGBR", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*m == 0 || *n == 0) {
work[1].r = 1., work[1].i = 0.;
return 0;
}
if (wantq) {
/* Form Q, determined by a call to ZGEBRD to reduce an m-by-k */
/* matrix */
if (*m >= *k) {
/* If m >= k, assume m >= n >= k */
zungqr_(m, n, k, &a[a_offset], lda, &tau[1], &work[1], lwork, &
iinfo);
} else {
/* If m < k, assume m = n */
/* Shift the vectors which define the elementary reflectors one */
/* column to the right, and set the first row and column of Q */
/* to those of the unit matrix */
for (j = *m; j >= 2; --j) {
i__1 = j * a_dim1 + 1;
a[i__1].r = 0., a[i__1].i = 0.;
i__1 = *m;
for (i__ = j + 1; i__ <= i__1; ++i__) {
i__2 = i__ + j * a_dim1;
i__3 = i__ + (j - 1) * a_dim1;
a[i__2].r = a[i__3].r, a[i__2].i = a[i__3].i;
/* L10: */
}
/* L20: */
}
i__1 = a_dim1 + 1;
a[i__1].r = 1., a[i__1].i = 0.;
i__1 = *m;
for (i__ = 2; i__ <= i__1; ++i__) {
i__2 = i__ + a_dim1;
a[i__2].r = 0., a[i__2].i = 0.;
/* L30: */
}
if (*m > 1) {
/* Form Q(2:m,2:m) */
i__1 = *m - 1;
i__2 = *m - 1;
i__3 = *m - 1;
zungqr_(&i__1, &i__2, &i__3, &a[(a_dim1 << 1) + 2], lda, &tau[
1], &work[1], lwork, &iinfo);
}
}
} else {
/* Form P', determined by a call to ZGEBRD to reduce a k-by-n */
/* matrix */
if (*k < *n) {
/* If k < n, assume k <= m <= n */
zunglq_(m, n, k, &a[a_offset], lda, &tau[1], &work[1], lwork, &
iinfo);
} else {
/* If k >= n, assume m = n */
/* Shift the vectors which define the elementary reflectors one */
/* row downward, and set the first row and column of P' to */
/* those of the unit matrix */
i__1 = a_dim1 + 1;
a[i__1].r = 1., a[i__1].i = 0.;
i__1 = *n;
for (i__ = 2; i__ <= i__1; ++i__) {
i__2 = i__ + a_dim1;
a[i__2].r = 0., a[i__2].i = 0.;
/* L40: */
}
i__1 = *n;
for (j = 2; j <= i__1; ++j) {
for (i__ = j - 1; i__ >= 2; --i__) {
i__2 = i__ + j * a_dim1;
i__3 = i__ - 1 + j * a_dim1;
a[i__2].r = a[i__3].r, a[i__2].i = a[i__3].i;
/* L50: */
}
i__2 = j * a_dim1 + 1;
a[i__2].r = 0., a[i__2].i = 0.;
/* L60: */
}
if (*n > 1) {
/* Form P'(2:n,2:n) */
i__1 = *n - 1;
i__2 = *n - 1;
i__3 = *n - 1;
zunglq_(&i__1, &i__2, &i__3, &a[(a_dim1 << 1) + 2], lda, &tau[
1], &work[1], lwork, &iinfo);
}
}
}
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
return 0;
/* End of ZUNGBR */
} /* zungbr_ */
void compute(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], const int atria_preprocessing_given, METRIC dummy)
{
long bins = 32;
double start_dist = 0;
double maximal_search_radius = 0;
double scale_factor = 1;
long opt_flag = 0; // 0 => eucl.norm, upper triangle matrix, 1 => max.norm, utm, 2 => eucl,full matrix, 3 => max.,full matrix
long Nref_min;
long Nref_max;
/* handle matrix I/O */
#ifdef C_STYLE_POINT_SET
const long N = mxGetN(prhs[0]);
const long dim = mxGetM(prhs[0]);
#else // this is the default
const long N = mxGetM(prhs[0]);
const long dim = mxGetN(prhs[0]);
#endif
const double* p = (double *)mxGetPr(prhs[0]);
const long Npairs = (long) *((double *)mxGetPr(prhs[1])); // number of pairs
if (mxGetM(prhs[1])*mxGetN(prhs[1]) == 3) {
Nref_min = (long) ((double *)mxGetPr(prhs[1]))[1];
Nref_max = (long) ((double *)mxGetPr(prhs[1]))[2];
} else {
Nref_min = 1;
Nref_max = N;
}
const double relative_range = (double) *((double *)mxGetPr(prhs[2]));
const long past = (long) *((double *)mxGetPr(prhs[3]));
if (nrhs > 4) bins = (long) *((double *)mxGetPr(prhs[4]));
if (nrhs > 5) opt_flag = (long) *((double *)mxGetPr(prhs[5]));
if (N < 1) {
mexErrMsgTxt("Data set must consist of at least two points (row vectors)");
return;
}
if (dim < 1) {
mexErrMsgTxt("Data points must be at least of dimension one");
return;
}
if (relative_range <= 0) {
mexErrMsgTxt("Relative range must be greater zero");
return;
}
if (bins < 2) {
mexErrMsgTxt("Number of bins should be two");
return;
}
if (Npairs < 1) {
mexErrMsgTxt("Number of pairs must be positive");
return;
}
if ((opt_flag < 0) || (opt_flag > 7)) {
mexErrMsgTxt("Flag must be out of 0..7");
return;
}
if (Nref_min < 1) Nref_min = 1;
if (Nref_max > N) Nref_max = N;
point_set<METRIC> points(N,dim, p);
ATRIA< point_set<METRIC> >* searcher = 0;
#ifdef MATLAB_MEX_FILE
if (atria_preprocessing_given) {
searcher = new ATRIA< point_set<METRIC> >(points, prhs[-1]); // this constructor used the data from the preprocessing
if (searcher->geterr()) {
delete searcher;
searcher = 0;
}
}
#endif
if (searcher == 0) {
searcher = new ATRIA< point_set<METRIC> >(points);
}
if (searcher->geterr()) {
mexErrMsgTxt("Error preparing searcher");
return;
}
if (mxGetM(prhs[2])*mxGetN(prhs[2]) == 2) {
start_dist = (double) ((double *)mxGetPr(prhs[2]))[0];
maximal_search_radius = (double) ((double *)mxGetPr(prhs[2]))[1];
if (start_dist <= 0) {
mexErrMsgTxt("Starting radius is zero or negativ");
return;
}
if (maximal_search_radius <= start_dist) {
mexErrMsgTxt("Maximal search radius must be greater than starting radius");
return;
}
}
else {
maximal_search_radius = relative_range * searcher->data_set_radius(); // compute the maximal search radius using information about attractor size
// try to determine an estimate for the minimum inter-point distance in the data set, but greater zero
for (long n=0; n < 128; n++) {
const long actual = (long) (((double)rand() * (double) (N-2))/(double)RAND_MAX);
vector<neighbor> v;
searcher->search_k_neighbors(v, 1, points.point_begin(actual), actual, actual); // search the nearest neighbor
if (v.size() > 0) {
if (start_dist == 0) start_dist = v[0].dist();
if (v[0].dist() > 0) {
if (v[0].dist() < start_dist) start_dist = v[0].dist();
}
}
}
if (start_dist <= 0) { // first try to search again for a minimum inter-point distance greater zero
for (long n=0; n < 512; n++) {
const long actual = (long) (((double)rand() * (double) (N-2))/(double)RAND_MAX);
vector<neighbor> v;
searcher->search_k_neighbors(v, 1, points.point_begin(actual), actual, actual); // search the nearest neighbor
if (v.size() > 0) {
if (start_dist == 0) start_dist = v[0].dist();
if (v[0].dist() > 0) {
if (v[0].dist() < start_dist) start_dist = v[0].dist();
}
}
}
}
if (start_dist <= 0) { // give up if we cannot find an interpoint distance greater zero
mexErrMsgTxt("Cannot find an interpoint distance greater zero, maybe ill-conditioned data set given");
return;
}
if (maximal_search_radius <= start_dist) {
mexErrMsgTxt("Maximal search radius must be greater than starting radius");
return;
}
}
scale_factor = pow(maximal_search_radius/start_dist, 1.0/(bins-1));
if (be_verbose) {
//mexPrintf("Number of reference points : %d\n", R);
mexPrintf("Number of data set points : %d\n", N);
mexPrintf("Number of pairs to find : %d\n", Npairs);
mexPrintf("Miniumum number of reference points : %d\n", Nref_min);
mexPrintf("Maximum number of reference points : %d\n", Nref_max);
mexPrintf("Upper bound for attractor size : %f\n", 2 * searcher->data_set_radius());
mexPrintf("Number of partitions used : %d\n", bins);
mexPrintf("Time window to exclude from search : %d\n", past);
mexPrintf("Minimal length scale : %f\n", start_dist);
mexPrintf("Starting at maximal length scale : %f\n", maximal_search_radius);
}
plhs[0] = mxCreateDoubleMatrix(bins, 1, mxREAL);
double* corrsums = (double *) mxGetPr(plhs[0]);
long* const ref = new long[N]; // needed to create random reference indices
long* const total_pairs = new long[bins]; // number of total pairs is not equal for all bins
long* const pairs_found = new long[bins]; // number of pairs found within distance dist
double* dists;
if (nlhs > 1) {
plhs[1] = mxCreateDoubleMatrix(bins, 1, mxREAL);
dists = (double *) mxGetPr(plhs[1]);
} else
dists = new double[bins];
double x = start_dist;
// initialize vectors
// pairs_found[i] counts the number of points/distances (real) smaller than dists[i]
for (long bin=0; bin < bins; bin++) {
pairs_found[bin] = 0;
total_pairs[bin] = 0;
dists[bin] = x;
x *= scale_factor;
}
for (long r=0; r < N; r++) ref[r] = r;
long R = 0; // number of reference points actually used
long bin = bins-1; // the current highest bin (and length scale) that needs to be filled over Npairs
while(((R < Nref_min) || (pairs_found[bin] < Npairs)) && (R < Nref_max)) {
vector<neighbor> v;
long first, last; // all points with indices i so that first <= i <= last are excluded(!) from search
long pairs = 0;
const long actual = random_permutation(ref, N, R++); // choose random index from 0...N-1, without reoccurences
if (opt_flag & (long)2) {
first = actual-past;
last = actual+past;
if (past >= 0)
pairs = lmax(0,first) + lmax(N-1-last,0);
else
pairs = N;
} else {
if (past >= 0)
first = actual-past;
else
first = actual;
last = N;
pairs = lmin(first,last); // don't search points from [actual-past .. N-1]
}
if (pairs <= 0) {
continue;
}
searcher->search_range(v, dists[bin], points.point_begin(actual), first, last);
if (v.size() > 0) {
for (vector<neighbor>::iterator i = v.begin(); i < v.end(); i++) { // v is unsorted (!!!)
const double d = (*i).dist();
for (long n = bin; n >= 0; n--) {
if (d > dists[n])
break;
pairs_found[n]++;
}
}
}
for (long n = 0; n <= bin; n++) {
total_pairs[n] += pairs;
}
// see if we can reduce length scale
int bins_changed = 0;
while((pairs_found[bin] >= Npairs) && (bin > 0) && (R >= Nref_min)) {
bin--;
bins_changed = 1;
}
if (be_verbose) {
if (bins_changed) {
mexPrintf("Reference points used so far : %d\n", R);
mexPrintf("Switching to length scale : %f\n", dists[bin]);
}
}
}
if (be_verbose) {
mexPrintf("Number of reference points used : %d\n", R);
}
for (long bin=0; bin < bins; bin++) {
corrsums[bin] = ((double) pairs_found[bin]) / ((double) total_pairs[bin]);
}
if (nlhs > 2) {
plhs[2] = mxCreateDoubleMatrix(bins, 1, mxREAL);
double* const y = mxGetPr(plhs[2]);
for (long b=0; b < bins; b++)
y[b] = (double) pairs_found[b];
}
if (nlhs > 3) {
plhs[3] = mxCreateDoubleMatrix(bins, 1, mxREAL);
double* const y = mxGetPr(plhs[3]);
for (long b=0; b < bins; b++)
y[b] = (double) total_pairs[b];
}
if (nlhs > 4) {
plhs[4] = mxCreateDoubleMatrix(R, 1, mxREAL);
double* const y = mxGetPr(plhs[4]);
for (long r=0; r < R; r++)
y[r] = (double) ref[r]+1; // C to Matlab means
}
delete[] total_pairs;
delete[] pairs_found;
delete[] ref;
if (!(nlhs > 1)) delete[] dists;
delete searcher;
}
/* collect MSTS sentence from tty */
int
mstsinput(int c, struct tty *tp)
{
struct msts *np = (struct msts *)tp->t_sc;
struct timespec ts;
int64_t gap;
long tmin, tmax;
switch (c) {
case 2: /* ASCII <STX> */
nanotime(&ts);
np->pos = np->sync = 0;
gap = (ts.tv_sec * 1000000000LL + ts.tv_nsec) -
(np->lts.tv_sec * 1000000000LL + np->lts.tv_nsec);
np->lts.tv_sec = ts.tv_sec;
np->lts.tv_nsec = ts.tv_nsec;
if (gap <= np->gap)
break;
np->ts.tv_sec = ts.tv_sec;
np->ts.tv_nsec = ts.tv_nsec;
np->gap = gap;
/*
* If a tty timestamp is available, make sure its value is
* reasonable by comparing against the timestamp just taken.
* If they differ by more than 2 seconds, assume no PPS signal
* is present, note the fact, and keep using the timestamp
* value. When this happens, the sensor state is set to
* CRITICAL later when the MSTS sentence is decoded.
*/
if (tp->t_flags & (TS_TSTAMPDCDSET | TS_TSTAMPDCDCLR |
TS_TSTAMPCTSSET | TS_TSTAMPCTSCLR)) {
tmax = lmax(np->ts.tv_sec, tp->t_tv.tv_sec);
tmin = lmin(np->ts.tv_sec, tp->t_tv.tv_sec);
if (tmax - tmin > 1)
np->no_pps = 1;
else {
np->ts.tv_sec = tp->t_tv.tv_sec;
np->ts.tv_nsec = tp->t_tv.tv_usec *
1000L;
np->no_pps = 0;
}
}
break;
case 3: /* ASCII <ETX> */
if (!np->sync) {
np->cbuf[np->pos] = '\0';
msts_scan(np, tp);
np->sync = 1;
}
break;
default:
if (!np->sync && np->pos < (MSTSMAX - 1))
np->cbuf[np->pos++] = c;
break;
}
/* pass data to termios */
return linesw[TTYDISC].l_rint(c, tp);
}
/* Subroutine */ int zungqr_(integer *m, integer *n, integer *k,
doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
work, integer *lwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
/* Local variables */
integer i__, j, l, ib, nb, ki, kk, nx, iws, nbmin, iinfo;
extern /* Subroutine */ int zung2r_(integer *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *), xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
extern /* Subroutine */ int zlarfb_(char *, char *, char *, char *,
integer *, integer *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *);
integer ldwork;
extern /* Subroutine */ int zlarft_(char *, char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *);
integer lwkopt;
logical lquery;
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* ZUNGQR generates an M-by-N complex matrix Q with orthonormal columns, */
/* which is defined as the first N columns of a product of K elementary */
/* reflectors of order M */
/* Q = H(1) H(2) . . . H(k) */
/* as returned by ZGEQRF. */
/* Arguments */
/* ========= */
/* M (input) INTEGER */
/* The number of rows of the matrix Q. M >= 0. */
/* N (input) INTEGER */
/* The number of columns of the matrix Q. M >= N >= 0. */
/* K (input) INTEGER */
/* The number of elementary reflectors whose product defines the */
/* matrix Q. N >= K >= 0. */
/* A (input/output) COMPLEX*16 array, dimension (LDA,N) */
/* On entry, the i-th column must contain the vector which */
/* defines the elementary reflector H(i), for i = 1,2,...,k, as */
/* returned by ZGEQRF in the first k columns of its array */
/* argument A. */
/* On exit, the M-by-N matrix Q. */
/* LDA (input) INTEGER */
/* The first dimension of the array A. LDA >= lmax(1,M). */
/* TAU (input) COMPLEX*16 array, dimension (K) */
/* TAU(i) must contain the scalar factor of the elementary */
/* reflector H(i), as returned by ZGEQRF. */
/* WORK (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. LWORK >= lmax(1,N). */
/* For optimum performance LWORK >= N*NB, where NB is the */
/* optimal blocksize. */
/* If LWORK = -1, then a workspace query is assumed; the routine */
/* only calculates the optimal size of the WORK array, returns */
/* this value as the first entry of the WORK array, and no error */
/* message related to LWORK is issued by XERBLA. */
/* INFO (output) INTEGER */
/* = 0: successful exit */
/* < 0: if INFO = -i, the i-th argument has an illegal value */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
--work;
/* Function Body */
*info = 0;
nb = ilaenv_(&c__1, "ZUNGQR", " ", m, n, k, &c_n1);
lwkopt = lmax(1,*n) * nb;
work[1].r = (doublereal) lwkopt, work[1].i = 0.;
lquery = *lwork == -1;
if (*m < 0) {
*info = -1;
} else if (*n < 0 || *n > *m) {
*info = -2;
} else if (*k < 0 || *k > *n) {
*info = -3;
} else if (*lda < lmax(1,*m)) {
*info = -5;
} else if (*lwork < lmax(1,*n) && ! lquery) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZUNGQR", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n <= 0) {
work[1].r = 1., work[1].i = 0.;
return 0;
}
nbmin = 2;
nx = 0;
iws = *n;
if (nb > 1 && nb < *k) {
/* Determine when to cross over from blocked to unblocked code. */
/* Computing MAX */
i__1 = 0, i__2 = ilaenv_(&c__3, "ZUNGQR", " ", m, n, k, &c_n1);
nx = lmax(i__1,i__2);
if (nx < *k) {
/* Determine if workspace is large enough for blocked code. */
ldwork = *n;
iws = ldwork * nb;
if (*lwork < iws) {
/* Not enough workspace to use optimal NB: reduce NB and */
/* determine the minimum value of NB. */
nb = *lwork / ldwork;
/* Computing MAX */
i__1 = 2, i__2 = ilaenv_(&c__2, "ZUNGQR", " ", m, n, k, &c_n1);
nbmin = lmax(i__1,i__2);
}
}
}
if (nb >= nbmin && nb < *k && nx < *k) {
/* Use blocked code after the last block. */
/* The first kk columns are handled by the block method. */
ki = (*k - nx - 1) / nb * nb;
/* Computing MIN */
i__1 = *k, i__2 = ki + nb;
kk = lmin(i__1,i__2);
/* Set A(1:kk,kk+1:n) to zero. */
i__1 = *n;
for (j = kk + 1; j <= i__1; ++j) {
i__2 = kk;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * a_dim1;
a[i__3].r = 0., a[i__3].i = 0.;
/* L10: */
}
/* L20: */
}
} else {
kk = 0;
}
/* Use unblocked code for the last or only block. */
if (kk < *n) {
i__1 = *m - kk;
i__2 = *n - kk;
i__3 = *k - kk;
zung2r_(&i__1, &i__2, &i__3, &a[kk + 1 + (kk + 1) * a_dim1], lda, &
tau[kk + 1], &work[1], &iinfo);
}
if (kk > 0) {
/* Use blocked code */
i__1 = -nb;
for (i__ = ki + 1; i__1 < 0 ? i__ >= 1 : i__ <= 1; i__ += i__1) {
/* Computing MIN */
i__2 = nb, i__3 = *k - i__ + 1;
ib = lmin(i__2,i__3);
if (i__ + ib <= *n) {
/* Form the triangular factor of the block reflector */
/* H = H(i) H(i+1) . . . H(i+ib-1) */
i__2 = *m - i__ + 1;
zlarft_("Forward", "Columnwise", &i__2, &ib, &a[i__ + i__ *
a_dim1], lda, &tau[i__], &work[1], &ldwork);
/* Apply H to A(i:m,i+ib:n) from the left */
i__2 = *m - i__ + 1;
i__3 = *n - i__ - ib + 1;
zlarfb_("Left", "No transpose", "Forward", "Columnwise", &
i__2, &i__3, &ib, &a[i__ + i__ * a_dim1], lda, &work[
1], &ldwork, &a[i__ + (i__ + ib) * a_dim1], lda, &
work[ib + 1], &ldwork);
}
/* Apply H to rows i:m of current block */
i__2 = *m - i__ + 1;
zung2r_(&i__2, &ib, &ib, &a[i__ + i__ * a_dim1], lda, &tau[i__], &
work[1], &iinfo);
/* Set rows 1:i-1 of current block to zero */
i__2 = i__ + ib - 1;
for (j = i__; j <= i__2; ++j) {
i__3 = i__ - 1;
for (l = 1; l <= i__3; ++l) {
i__4 = l + j * a_dim1;
a[i__4].r = 0., a[i__4].i = 0.;
/* L30: */
}
/* L40: */
}
/* L50: */
}
}
work[1].r = (doublereal) iws, work[1].i = 0.;
return 0;
/* End of ZUNGQR */
} /* zungqr_ */
