.. wxPython Phoenix documentation

   This file was generated by Phoenix's sphinx generator and associated
   tools, do not edit by hand.

   Copyright: (c) 2011-2017 by Total Control Software
   License:   wxWindows License

.. include:: headings.inc

.. currentmodule:: wx.lib.agw.floatspin

.. highlight:: python



.. _wx.lib.agw.floatspin.FixedPoint:

==========================================================================================================================================
|phoenix_title|  **wx.lib.agw.floatspin.FixedPoint**
==========================================================================================================================================

FixedPoint objects support decimal arithmetic with a fixed number of
digits (called the object's precision) after the decimal point.  The
number of digits before the decimal point is variable & unbounded.

The precision is user-settable on a per-object basis when a FixedPoint
is constructed, and may vary across FixedPoint objects.  The precision
may also be changed after construction via `FixedPoint.set_precision(p)`.
Note that if the precision of a FixedPoint is reduced via :meth:`FixedPoint.set_precision() <FixedPoint.set_precision>`,
information may be lost to rounding.

Example::

    >>> x = FixedPoint("5.55")  # precision defaults to 2
    >>> print(x)
    5.55
    >>> x.set_precision(1)      # round to one fraction digit
    >>> print(x)
    5.6
    >>> print(FixedPoint("5.55", 1))  # same thing setting to 1 in constructor
    5.6
    >>> repr(x) #  returns constructor string that reproduces object exactly
    "FixedPoint('5.6', 1)"
    >>>


When :class:`FixedPoint` objects of different precision are combined via + - * /,
the result is computed to the larger of the inputs' precisions, which also
becomes the precision of the resulting :class:`FixedPoint` object. Example::

    >>> print FixedPoint("3.42") + FixedPoint("100.005", 3)
    103.425
    >>>


When a :class:`FixedPoint` is combined with other numeric types (ints, floats,
strings representing a number) via + - * /, then similarly the computation
is carried out using -- and the result inherits -- the :class:`FixedPoint`'s
precision. Example::

    >>> print(FixedPoint(1) / 7)
    0.14
    >>> print(FixedPoint(1, 30) / 7)
    0.142857142857142857142857142857
    >>>


The string produced by `str(x)` (implictly invoked by `print`) always
contains at least one digit before the decimal point, followed by a
decimal point, followed by exactly `x.get_precision()` digits.  If `x` is
negative, `str(x)[0] == "-"`.

The :class:`FixedPoint` constructor can be passed an int, long, string, float,
:class:`FixedPoint`, or any object convertible to a float via `float()` or to a
long via `long()`. Passing a precision is optional; if specified, the
precision must be a non-negative int. There is no inherent limit on
the size of the precision, but if very very large you'll probably run
out of memory.

Note that conversion of floats to :class:`FixedPoint` can be surprising, and
should be avoided whenever possible. Conversion from string is exact
(up to final rounding to the requested precision), so is greatly
preferred. Example::

    >>> print(FixedPoint(1.1e30))
    1099999999999999993725589651456.00
    >>> print(FixedPoint("1.1e30"))
    1100000000000000000000000000000.00
    >>>



|

|class_hierarchy| Class Hierarchy
=================================

.. raw:: html

   <div id="toggleBlock" onclick="return toggleVisibility(this)" class="closed" style="cursor:pointer;">
   <img id="toggleBlock-trigger" src="_static/images/closed.png"/>
   Inheritance diagram for class <strong>FixedPoint</strong>:
   </div>
   <div id="toggleBlock-summary" style="display:block;"></div>
   <div id="toggleBlock-content" style="display:none;">
   <p class="graphviz">
   <center><img src="_static/images/inheritance/wx.lib.agw.floatspin.FixedPoint_inheritance.png" alt="Inheritance diagram of FixedPoint" usemap="#dummy" class="inheritance"/></center>
   </div>
   <script type="text/javascript">toggleVisibilityOnLoad(document.getElementById('toggleBlock'))</script>
   <map id="dummy" name="dummy"> <area shape="rect" id="node1" href="wx.lib.agw.floatspin.FixedPoint.html" title="wx.lib.agw.floatspin.FixedPoint" alt="" coords="4,5,213,35"/> </map> 
   </p>

|


|method_summary| Methods Summary
================================

================================================================================ ================================================================================
:meth:`~wx.lib.agw.floatspin.FixedPoint.__init__`                                Default class constructor.
:meth:`~wx.lib.agw.floatspin.FixedPoint.copy`                                    Create a copy of the current :class:`FixedPoint`.
:meth:`~wx.lib.agw.floatspin.FixedPoint.frac`                                    Returns fractional portion as a :class:`FixedPoint`.
:meth:`~wx.lib.agw.floatspin.FixedPoint.get_precision`                           Return the precision of this :class:`FixedPoint`.
:meth:`~wx.lib.agw.floatspin.FixedPoint.set_precision`                           Change the precision carried by this :class:`FixedPoint` to `precision`.
================================================================================ ================================================================================


|


|api| Class API
===============


.. class:: FixedPoint(object)

   FixedPoint objects support decimal arithmetic with a fixed number of
   digits (called the object's precision) after the decimal point.  The
   number of digits before the decimal point is variable & unbounded.
   
   The precision is user-settable on a per-object basis when a FixedPoint
   is constructed, and may vary across FixedPoint objects.  The precision
   may also be changed after construction via `FixedPoint.set_precision(p)`.
   Note that if the precision of a FixedPoint is reduced via :meth:`FixedPoint.set_precision() <FixedPoint.set_precision>`,
   information may be lost to rounding.
   
   Example::
   
       >>> x = FixedPoint("5.55")  # precision defaults to 2
       >>> print(x)
       5.55
       >>> x.set_precision(1)      # round to one fraction digit
       >>> print(x)
       5.6
       >>> print(FixedPoint("5.55", 1))  # same thing setting to 1 in constructor
       5.6
       >>> repr(x) #  returns constructor string that reproduces object exactly
       "FixedPoint('5.6', 1)"
       >>>
   
   
   When :class:`FixedPoint` objects of different precision are combined via + - * /,
   the result is computed to the larger of the inputs' precisions, which also
   becomes the precision of the resulting :class:`FixedPoint` object. Example::
   
       >>> print FixedPoint("3.42") + FixedPoint("100.005", 3)
       103.425
       >>>
   
   
   When a :class:`FixedPoint` is combined with other numeric types (ints, floats,
   strings representing a number) via + - * /, then similarly the computation
   is carried out using -- and the result inherits -- the :class:`FixedPoint`'s
   precision. Example::
   
       >>> print(FixedPoint(1) / 7)
       0.14
       >>> print(FixedPoint(1, 30) / 7)
       0.142857142857142857142857142857
       >>>
   
   
   The string produced by `str(x)` (implictly invoked by `print`) always
   contains at least one digit before the decimal point, followed by a
   decimal point, followed by exactly `x.get_precision()` digits.  If `x` is
   negative, `str(x)[0] == "-"`.
   
   The :class:`FixedPoint` constructor can be passed an int, long, string, float,
   :class:`FixedPoint`, or any object convertible to a float via `float()` or to a
   long via `long()`. Passing a precision is optional; if specified, the
   precision must be a non-negative int. There is no inherent limit on
   the size of the precision, but if very very large you'll probably run
   out of memory.
   
   Note that conversion of floats to :class:`FixedPoint` can be surprising, and
   should be avoided whenever possible. Conversion from string is exact
   (up to final rounding to the requested precision), so is greatly
   preferred. Example::
   
       >>> print(FixedPoint(1.1e30))
       1099999999999999993725589651456.00
       >>> print(FixedPoint("1.1e30"))
       1100000000000000000000000000000.00
       >>>

   .. method:: __init__(self, value=0, precision=DEFAULT_PRECISION)

      Default class constructor.
      
      :param `value`: the initial value;
      :param `precision`: must be an int >= 0, and defaults to ``DEFAULT_PRECISION``.


   .. method:: copy(self)

      Create a copy of the current :class:`FixedPoint`. 


   .. method:: frac(self)

      Returns fractional portion as a :class:`FixedPoint`.
      
      :note: In :class:`FixedPoint`,
      
       this equality holds true::
      
              x = x.frac() + long(x)


   .. method:: get_precision(self)

      Return the precision of this :class:`FixedPoint`.
      
      :note: The precision is the number of decimal digits carried after
       the decimal point, and is an int >= 0.


   .. method:: set_precision(self, precision=DEFAULT_PRECISION)

      Change the precision carried by this :class:`FixedPoint` to `precision`.
      
      :param `precision`: must be an int >= 0, and defaults to
       ``DEFAULT_PRECISION``.
      
      :note: If `precision` is less than this :class:`FixedPoint`'s current precision,
       information may be lost to rounding.


