static Errcode read_next_dirent(Tiff_file *tf, Dirent *entry)
/*****************************************************************************
* load a directory entry (tag, count, type, offset) from the current ifd.
****************************************************************************/
{
if (Success != fseek(tf->file, tf->off_ifd_cur, SEEK_SET))
return pj_errno_errcode();
if (1 != fread(entry, sizeof(*entry), 1, tf->file))
return pj_errno_errcode();
if (tf->swap_bytes)
{
swapw(&entry->tag);
swapw(&entry->type);
swapd(&entry->count);
if (entry->type == TYPE_SHORT && entry->count <= 2)
{
swapw(&entry->value.word);
if (entry->count == 2)
swapw(((char *)(&entry->value.word))+2);
}
else
swapd(&entry->value.dword);
}
return Success;
}
int nbt_write_double(nbt_file *nbt, double *val)
{
double temp = *val;
if (get_endianness() == L_ENDIAN)
temp = swapd(temp);
return gzwrite(nbt->fp, &temp, sizeof(double));
}
static int solve_third_case(t_cubic c, double *a, double *r)
{
c.ratio = c.sgnbr * sqrt(c.br2 / c.bq3);
c.theta = acos(c.ratio);
c.norm = -2 * sqrt(c.bq);
c.r0 = c.norm * cos(c.theta / 3) - a[2] / 3;
c.r1 = c.norm * cos((c.theta + 2.0 * M_PI) / 3) - a[2] / 3;
c.r2 = c.norm * cos((c.theta - 2.0 * M_PI) / 3) - a[2] / 3;
if (c.r0 > c.r1)
swapd(&c.r0, &c.r1);
if (c.r1 > c.r2)
{
swapd(&c.r1, &c.r2);
if (c.r0 > c.r1)
swapd(&c.r0, &c.r1);
}
r[0] = c.r0;
r[1] = c.r1;
r[2] = c.r2;
return (3);
}
/**
* @brief Transposition / Complex conjugation. i.e. this'.
*
* @return Matrix::tr()
*/
inline Matrix<T,P>
operator! () const {
assert(_dim.size() ==2);
Matrix<T,P> res = *this;
for (size_t i = 0; i < _dim[1]; ++i)
for (size_t j = 0; j < i; j++)
swapd(res(j,i),res(i,j));
return res;
}
int nbt_read_double(nbt_file *nbt, double **out)
{
double t;
gzread(nbt->fp, &t, sizeof(t));
if (get_endianness() == L_ENDIAN)
t = swapd(t);
*out = malloc(sizeof(double));
memcpy(*out, &t, sizeof(double));
return 0;
}
void mswap(double a[], double b[], int la, int lb, int m, int n)
{
int i, j, ka, kb;
double *p, *q;
if(m <= 0 || n <= 0 || la < n || lb < n)
{
fprintf(stderr, "Error : Illegal parameter in mswap()\n");
return;
}
for(i = ka = kb = 0; i < m; i++, ka += la, kb += lb)
for(j = 0, p = a + ka, q = b + kb; j < n; j++) swapd(p++, q++);
return;
}
void mtra1(double a[], int l, int m, int n)
{
int i, j, ka, mn;
double *p, *q;
if(m <= 0 || n <= 0 || l < m || l < n || m < n)
{
fprintf(stderr, "Error : Illegal parameter in mtra1()\n");
return;
}
mn = m;
if(mn < n) mn = n;
for(i = 0, ka = 0; i < mn - 1; i++, ka += l)
for(j = i + 1, p = a + ka + j, q = p + l - 1; j < mn; j++, q += l)
swapd(p++, q);
}
double minver(double a[], int l, int m, double eps)
{
int i, iw, j, k, *p, r, s, t, u, v, *work;
double api, pivot, *q, *q1, w, w1, wmax;
if(m < 2 || l < m || eps <= 0.)
{
fprintf(stderr, "Error : Illegal parameter in minver()\n");
return 0.;
}
work = (int *)malloc(m * sizeof(int));
if(work == NULL)
{
fprintf(stderr, "Error : Out of memory in minver()\n");
return 0.;
}
w1 = 1.;
for(i = 0, p = work; i < m; i++) *p++ = i;
for(k = 0, u = 0; k < m; k++, u += l)
{
wmax = 0.;
for(i = k; i < m; i++)
{
w = fabs(*(a + i * l + k));
if(w > wmax)
{
wmax = w;
r = i;
}
}
api = fabs(pivot = *(a + r * l + k));
if(api < eps)
{
fprintf(stderr, "Error : api < eps in minver()\n");
free((char *)work);
return w1;
}
w1 *= pivot;
v = r * l;
if(r != k)
{
w1 = -w1;
swapi(work + k, work + r);
for(j = 0, q = a + u, q1 = a + v; j < m; j++) swapd(q++, q1++);
}
for(i = 0, q = a + u; i < m; i++) *q++ /= pivot;
for(i = 0, v = 0; i < m; i++, v += l)
{
if(i != k)
{
s = v + k;
w = *(a + s);
if(w != 0.)
{
for(j = 0, q = a + u, q1 = a + v; j < m; j++, q++, q1++)
if (j != k) *q1 -= w * *q;
*(a + s) = - w / pivot;
}
}
}
*(a + u + k) = 1. / pivot;
}
for(i = 0; i < m; i++)
{
for(;;)
{
k = *(work + i);
if(k == i) break;
swapi(work + k, work + i);
for(j = 0, u = 0; j < m; j++, u += l) swapd(a + u + i, a + u + k);
}
}
free((char *)work);
return w1;
}
