int main(int argc, char const *argv[])
{
while (scanf("%d", &n) && n) {
for (int i = 0; i < n; i++) {
scanf("%lf%lf%lf", x + i, y + i, z + i);
}
double x0 = 0, y0 = 0, z0 = 0, lambda = 1;
for (int k = 0; k < 100000; k++) {
int i_opt;
double d_opt = -1;
for (int i = 0; i < n; i++) {
double d = sqsum(x[i] - x0, y[i] - y0, z[i] - z0);
if (d_opt < d) {
d_opt = d;
i_opt = i;
}
}
x0 += lambda * (x[i_opt] - x0);
y0 += lambda * (y[i_opt] - y0);
z0 += lambda * (z[i_opt] - z0);
lambda *= 0.99;
}
double radius = 0;
for (int i = 0; i < n; i++) {
double d = sqsum(x[i] - x0, y[i] - y0, z[i] - z0);
if (radius < d) {
radius = d;
}
}
printf("%.9f\n", sqrt(radius));
printf("%.9f %.9f %.9f\n", x0, y0, z0);
}
return 0;
}
/*
* Set the threshold in the recorder_context structure.
*/
static void detect_threshold_cb(pa_stream *stream, size_t length, void *userdata)
{
//TODO: Calculate a dynamic threshold both when the environment has changed
// and when a SIGPIPE signal has been received.
const void *data;
size_t size = 0;
static size_t acc_size = 0;
double sum;
static double acc_sqsum = 0;
recorder_context_t *rctx = (recorder_context_t *) userdata;
pa_stream_peek(stream, &data, &size);
#ifdef DEBUG
fwrite(data, sizeof(uint8_t), size, threshold_file);
#endif
if (data)
pa_stream_drop(stream);
/* We are sampling with 16 bits but size is measured in bytes */
size >>= 1;
sum = sqsum((const uint8_t *) data, size);
acc_sqsum += sum;
acc_size += size;
rctx->threshold = sqrt(acc_sqsum / acc_size);
}
void meanStdDev(const Size2D &size,
const u8 * srcBase, ptrdiff_t srcStride,
f32 * pMean, f32 * pStdDev)
{
internal::assertSupportedConfiguration();
#ifdef CAROTENE_NEON
f64 fsum = 0.0f, fsqsum = 0.0f;
sqsum(size, srcBase, srcStride, &fsum, &fsqsum, 1);
// calc mean and stddev
f64 itotal = 1.0 / size.total();
f64 mean = fsum * itotal;
f64 stddev = sqrt(std::max(fsqsum * itotal - mean * mean, 0.0));
if (pMean)
*pMean = mean;
if (pStdDev)
*pStdDev = stddev;
#else
(void)size;
(void)srcBase;
(void)srcStride;
(void)pMean;
(void)pStdDev;
#endif
}
/*
* Calculates the root-median-square power of a sequence of size's length
*/
static double calculate_rms_power(const uint8_t *data, size_t size)
{
double sum = sqsum(data, size);
return sqrt(sum / size);
}