implementation< ball_elementary, W, ball_rounded > Struct Template Reference

#include <ball_rounded.hpp>

List of all members.

Public Types

Static Public Member Functions

Detailed Description

template<typename W>
struct mmx::implementation< ball_elementary, W, ball_rounded >

Definition at line 303 of file ball_rounded.hpp.

Member Typedef Documentation

typedef implementation<ball_rounding,W> Rnd

Definition at line 304 of file ball_rounded.hpp.

Member Function Documentation

static void acos ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 399 of file ball_rounded.hpp.

References Ball, mmx::bnd_down(), mmx::center(), mmx::div(), Down, Nan, acos_op::op(), square_op::op(), mmx::promote(), R, mmx::radius(), Round_down, Round_up, and Up.

00399                               {
00400   typedef Round_up(R) Up;
00401   typedef Round_down(R) Down;
00402   Ball u= promote (1, z) - square_op::op (z);
00403   R v= Rnd::bnd_down (u);
00404   if (v <= 0) d= Nan (Ball);
00405   else {
00406     center (d)= acos_op::op (center (z));
00407     radius (d)= Up::div (radius (z), Down::sqrt (v));
00408     Rnd::add_elementary_error (d);
00409   }
00410 }

static void asin ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 413 of file ball_rounded.hpp.

References Ball, mmx::bnd_down(), mmx::center(), mmx::div(), Down, Nan, asin_op::op(), square_op::op(), mmx::promote(), R, mmx::radius(), Round_down, Round_up, and Up.

00413                               {
00414   typedef Round_up(R) Up;
00415   typedef Round_down(R) Down;
00416   Ball u= promote (1, z) - square_op::op (z);
00417   R v= Rnd::bnd_down (u);
00418   if (v <= 0) d= Nan (Ball);
00419   else {
00420     center (d)= asin_op::op (center (z));
00421     radius (d)= Up::div (radius (z), Down::sqrt (v));
00422     Rnd::add_elementary_error (d);
00423   }
00424 }

static void atan ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 427 of file ball_rounded.hpp.

References mmx::add(), mmx::bnd_down(), mmx::center(), mmx::div(), Down, atan_op::op(), mmx::promote(), R, mmx::radius(), Round_down, Round_up, and Up.

00427                               {
00428   typedef Round_up(R) Up;
00429   typedef Round_down(R) Down;
00430   center (d)= atan_op::op (center (z));
00431   R u= Rnd::bnd_down (z);
00432   R v= Down::add (promote (1, radius (z)), Down::square (u));
00433   if (u <= 0) radius (d)= radius (z);
00434   else radius (d)= Up::div (radius (z), v);
00435   Rnd::add_elementary_error (d);
00436 }

static void atan2 ( ball< C, R, V > &  d,
const ball< C, R, V > &  y,
const ball< C, R, V > &  x 
) [inline, static]

Definition at line 439 of file ball_rounded.hpp.

References mmx::abs(), mmx::add(), Ball, mmx::center(), mmx::div(), mmx::mul(), Nan, atan2_op::op(), square_op::op(), mmx::promote(), R, mmx::radius(), Round_up, and Up.

00439                                               {
00440   typedef Round_up(R) Up;
00441   Ball z= square_op::op (x) + square_op::op (y);
00442   if (z <= 0) d= Nan (Ball);
00443   else {
00444     R b = Up::div (promote (1, radius (y)), Rnd::bnd_down (z));
00445     R dx= Up::mul (Rnd::bnd_up (abs (y)), b);
00446     R dy= Up::mul (Rnd::bnd_up (abs (x)), b);
00447     center (d)= atan2_op::op (center (y), center (x));
00448     radius (d)= Up::add (Up::mul (dx, radius (x)), Up::mul (dy, radius (y)));
00449     Rnd::add_elementary_error (d);
00450   }
00451 }

static void cos ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 331 of file ball_rounded.hpp.

References mmx::abs(), mmx::center(), Down, mmx::max(), mmx::mul(), cos_op::op(), mmx::promote(), R, mmx::radius(), Round_down, Round_up, mmx::sin(), and Up.

00331                              {
00332   typedef Round_up(R) Up;
00333   typedef Round_down(R) Down;
00334   if (radius (z) >= Down::template pi<R> ()) {
00335     center (d)= promote (0, center (z));
00336     radius (d)= promote (1, radius (z));
00337   }
00338   else {
00339     center (d)= cos_op::op (center (z));
00340     radius (d)= radius (z);
00341     Rnd::add_elementary_error (d);
00342     if (radius (z) < abs (center (d))) {
00343       R u1= Up::sin (Rnd::bnd_down (z));
00344       R u2= Up::sin (Rnd::bnd_up (z));
00345       radius (d)= Up::mul (max (abs (u1), abs (u2)), radius (z));
00346       Rnd::add_elementary_error (d);
00347     }
00348   }
00349 }

static void cosh ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 378 of file ball_rounded.hpp.

References mmx::abs(), mmx::center(), mmx::mul(), cosh_op::op(), R, mmx::radius(), Round_up, and Up.

00378                               {
00379   typedef Round_up(R) Up;
00380   center (d)= cosh_op::op (center (z));
00381   radius (d)= Up::mul (Up::sinh (Rnd::bnd_up (abs (z))), radius (z));
00382   Rnd::add_elementary_error (d);
00383 }

static void exp ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 307 of file ball_rounded.hpp.

References mmx::center(), mmx::mul(), exp_op::op(), R, mmx::radius(), Round_up, and Up.

00307                              {
00308   typedef Round_up(R) Up;
00309   center (d)= exp_op::op (center (z));
00310   radius (d)= Up::mul (Up::exp (Rnd::bnd_up (z)), radius (z));
00311   Rnd::add_elementary_error (d);
00312 }

static void log ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 315 of file ball_rounded.hpp.

References Ball, mmx::center(), mmx::div(), Nan, log_op::op(), R, mmx::radius(), Round_up, and Up.

00315                              {
00316   typedef Round_up(R) Up;
00317   if (is_negative_or_zero (z)) d= Nan (Ball);
00318   else {
00319     center (d)= log_op::op (center (z));
00320     radius (d)= Up::div (radius (z), Rnd::bnd_down (z));
00321     Rnd::add_elementary_error (d);
00322   }
00323 }

static void pow ( ball< C, R, V > &  d,
const ball< C, R, V > &  z,
const ball< C, R, V > &  y 
) [inline, static]

Definition at line 326 of file ball_rounded.hpp.

References log_op::op(), and exp_op::op().

00326                                             {
00327   d= exp_op::op (y * log_op::op (z));
00328 }

static void sin ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 352 of file ball_rounded.hpp.

References mmx::abs(), mmx::center(), mmx::cos(), Down, mmx::max(), mmx::mul(), sin_op::op(), mmx::promote(), R, mmx::radius(), Round_down, Round_up, and Up.

00352                              {
00353   typedef Round_up(R) Up;
00354   typedef Round_down(R) Down;
00355   if (radius (z) >= Down::template pi<R> ()) {
00356     center (d)= promote (0, center (z));
00357     radius (d)= promote (1, radius (z));
00358   }
00359   else {
00360     center (d)= sin_op::op (center (z));
00361     radius (d)= radius (z);
00362     Rnd::add_elementary_error (d);
00363     if (radius (z) < abs (center (d))) {
00364       R u1= Up::cos (Rnd::bnd_down (z));
00365       R u2= Up::cos (Rnd::bnd_up (z));
00366       radius (d)= Up::mul (max (abs (u1), abs (u2)), radius (z));
00367       Rnd::add_elementary_error (d);
00368     }
00369   }
00370 }

static void sinh ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 386 of file ball_rounded.hpp.

References mmx::abs(), mmx::center(), mmx::mul(), sinh_op::op(), R, mmx::radius(), Round_up, and Up.

00386                               {
00387   typedef Round_up(R) Up;
00388   center (d)= sinh_op::op (center (z));
00389   radius (d)= Up::mul (Up::cosh (Rnd::bnd_up (abs (z))), radius (z));
00390   Rnd::add_elementary_error (d);
00391 }

static void tan ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 373 of file ball_rounded.hpp.

References cos_op::op(), and sin_op::op().

00373                              {
00374   d= sin_op::op (z) / cos_op::op (z);
00375 }

static void tanh ( ball< C, R, V > &  d,
const ball< C, R, V > &  z 
) [inline, static]

Definition at line 394 of file ball_rounded.hpp.

References cosh_op::op(), and sinh_op::op().

00394                               {
00395   d= sinh_op::op (z) / cosh_op::op (z);
00396 }

The documentation for this struct was generated from the following file:
Generated on 6 Dec 2012 for numerix by  doxygen 1.6.1